Build X402Settler, a contract that settles x402-style 'exact' payments in any standard ERC-20 through a Permit2 witness transfer, with Foundry tests, an independent review and a fix pass. Local only: do not deploy, and nothing here touches the swarm's own payment path.

Contract (src/X402Settler.sol, Solidity 0.8.26):

• constructor(address permit2) stores it immutable (zero reverts). No owner, admin, fee or ETH handling (no payable function, no receive).
• struct X402Payment { bytes32 paymentId; address to; uint256 validAfter; }. X402_PAYMENT_TYPEHASH = keccak256("X402Payment(bytes32 paymentId,address to,uint256 validAfter)"); witness = keccak256(abi.encode(X402_PAYMENT_TYPEHASH, paymentId, to, validAfter)); WITNESS_TYPE_STRING = "X402Payment witness)TokenPermissions(address token,uint256 amount)X402Payment(bytes32 paymentId,address to,uint256 validAfter)" (dependent types in alphabetical order, as EIP-712 requires).
• settle(ISignatureTransfer.PermitTransferFrom permit, address owner, X402Payment payment, bytes signature): anyone may call (the facilitator). Reverts ZeroRecipient if payment.to is zero, SelfPayment if payment.to == owner, NotYetValid if block.timestamp < payment.validAfter (validAfter itself is valid), AlreadySettled if receipts[owner][paymentId] exists. It then writes the receipt (before the external call), calls PERMIT2.permitWitnessTransferFrom(permit, SignatureTransferDetails(payment.to, permit.permitted.amount), owner, witness, WITNESS_TYPE_STRING, signature) — the exact scheme always moves the full permitted amount — and requires payment.to's token balance to have risen by exactly that amount (UnsupportedToken otherwise, which rejects fee-on-transfer tokens). The Permit2 deadline is the payment's valid-before time and Permit2's nonce stops replays of the same signature.
• Receipt { address token; uint256 amount; address to; address facilitator; uint64 settledAt; } in receipts[owner][paymentId]; views receipt(owner, paymentId) and isSettled(owner, paymentId); event Settled(bytes32 indexed paymentId, address indexed owner, address indexed to, address token, uint256 amount, address facilitator). Receipts are keyed by (owner, paymentId) so nobody but the payer can occupy a payer's paymentId: only the owner can sign a permit that moves the owner's tokens. A server proves settlement by reading receipt(owner, paymentId) and comparing token, amount and to with what it asked for.

Tests: Permit2 is not vendored and builds have no network, so add test/mocks/MockPermit2.sol implementing only permitWitnessTransferFrom with canonical Permit2 hashing (EIP-712 domain name "Permit2", chainId, verifyingContract, no version; spender = msg.sender in the struct; the PermitWitnessTransferFrom stub followed by witnessTypeString; unordered bitmap nonces; deadline check; 65-byte ECDSA owners). Pin its digest for one fixed input to a value computed independently in the test from the EIP-712 formula. Cover: happy path with vm.sign; validAfter - 1, validAfter, deadline and deadline + 1; the same permit replayed; a fresh permit reusing a paymentId for the same owner (AlreadySettled); one paymentId used by two different owners (both settle, separate receipts); a signature whose witness names another to or paymentId; a signature made for another spender contract; a fee-on-transfer token (UnsupportedToken); a token whose transferFrom re-enters settle cannot settle twice. Scope: the contract stays under ~150 lines.