ScripFacilitator

Addresses

FXRP is never hardcoded in the code that runs: it is resolved through the Flare Contract Registry → AssetManagerFXRP → fAsset(), so a redeployment of the token does not silently break anything. The address above is what that path returned.

Interface

struct PaymentIntent {
    bytes32 invoiceId;
    address payer;
    address payee;
    uint256 amount;
    uint256 deadline;
}

struct Signature { uint8 v; bytes32 r; bytes32 s; }

function settle(
    PaymentIntent calldata intent,
    Signature     calldata permitSig,   // over FXRP's EIP-712 domain
    Signature     calldata intentSig    // over this contract's domain
) external;

function intentDigest(PaymentIntent calldata intent) external view returns (bytes32);
function token()          external view returns (address);
function settled(bytes32) external view returns (bool);
function DOMAIN_SEPARATOR()        external view returns (bytes32);
function PAYMENT_INTENT_TYPEHASH() external view returns (bytes32);

event PaymentSettled(
    bytes32 indexed invoiceId,
    address indexed payer,
    address indexed payee,
    uint256 requested,
    uint256 delivered
);

The intent and both signatures are passed as calldata structs rather than as flat parameters. That is not stylistic: eleven flat arguments overflow the stack under legacy codegen, and structs fix it without turning on via-ir, which would change the codegen the london target was chosen to control.

Check the digest before you sign

intentDigest() is exposed so an offchain signer can assert its locally built digest matches the chain's, rather than discovering a mismatch as an unexplained revert. If the two disagree, every settle() fails with IntentNotSignedByPayer and the error names no cause. settle.ts makes this check before it signs anything.

const local = hashTypedData({
  domain: { name: "Scrip", version: "1", chainId: 114, verifyingContract: facilitator },
  types: { PaymentIntent: [
    { name: "invoiceId", type: "bytes32" },
    { name: "payer",     type: "address" },
    { name: "payee",     type: "address" },
    { name: "amount",    type: "uint256" },
    { name: "deadline",  type: "uint256" },
  ]},
  primaryType: "PaymentIntent",
  message: intent,
});

const onchain = await client.readContract({
  address: facilitator, abi, functionName: "intentDigest", args: [intent],
});

if (local !== onchain) throw new Error("do not sign - the domains disagree");

Custom errors

Every failure is a named error rather than a bare revert. Put these in your ABI so a revert decodes to a cause instead of a selector.

Properties it enforces

• The payee cannot be substituted. Every field a relayer supplies is covered by the intent digest.
• An invoice settles once. The ID is marked before any external call - effects before interactions.
• A replayed permit cannot grief a payment. The permit call is wrapped, and the allowance is checked explicitly afterwards.
• Signatures are not malleable. s is constrained to the lower half order, and ecrecover returning zero is treated as failure rather than as an address.
• Underpayment reverts. The payee's balance is read before and after, so a transfer fee cannot silently shortchange the invoice.
• Signatures cannot cross a fork. The domain separator is rebuilt if chainid changes.

The first three are exercised as attacks, not asserted - see the evidence.