@atumlabs/mppx-atum-escrow 0.4.1 → 0.5.0

package/CHANGELOG.md

@@ -7,16 +7,30 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.5.0] - 2026-10-09
+
 ### Changed
-- **Breaking: `PaymentSettlementStatus` now reads `'pending' | 'finalizing' | 'completed' | 'failed'`.** `cancelled` is removed — the gateway could not produce it, and a payment that ends undelivered is reported as `failed`. `finalizing` is added: the transaction is on chain but has not yet reached the confirmations its chain requires, so it is **not** terminal and a payment in that state is still waited on rather than written off. Code doing an exhaustive `switch` on this type will not compile until a `finalizing` branch is added. A status this package does not recognise is treated as pending rather than terminal, which is the safe direction: it raises `SettlementPendingError` (retry this purchase) instead of `SettlementFailedError` (start a new one), so a payment still in flight is never answered with an instruction to charge again.
+- The challenge's `source.amount` is validated before it is signed as the Permit2 spend cap: it must be a positive base-10 integer in the source token's smallest units. `0` or a leading zero, which used to be signed, is now refused on the client, and a decimal is refused with a clear error rather than failing inside the signing step. Canonical amounts are unaffected.
+- EVM and Tron payments are always built with the four-member deposit witness, and building a Solana payment fails for a signature domain version below 4. Every deployed escrow is at version 4 or later.
 
 ### Security
-- The axios copy bundled from the payment-gateway client is now 1.20.0, which patches the 1.13.x advisories. The notices file lists the new MIT transitives (`https-proxy-agent`, `agent-base`) that ride along.
+- The server refuses a credential whose payee or `request_id` differs from the one the payer signed, on EVM, Tron and Solana. The signed deposit carries both, and they must match the payment request's own `destination` and `request_id`. A deposit that commits no destination is refused.
+- Each value a verifier reads has one accepted spelling: `message` is `0x`-prefixed hex on every chain, Tron included; a signature is `0x` followed by 65 bytes of hex (recovery id 0, 1, 27 or 28) on EVM and Tron and `0x` followed by 64 bytes on Solana; and `max_source_amount` is a decimal integer with no sign, prefix, padding or leading zero.
+- Payers must be key accounts: the signer is recovered off chain, so a contract account (ERC-1271, such as a Safe), whose signature comes from an owner key, is refused.
+- New `onCommitmentResult` option on `registerServer`: it receives the result of every payee check, admissions and refusals alike, with log fields named as in the Go and TypeScript SDKs (`sender_auth_result`, `signed_destination`, `request_destination`, ...). Count payments by `sender_auth_result` and log every refusal.
+- The server checks the payment request, not only the deposit: it refuses a repeated member name, including names that differ only in letter case, where the request is read (any top-level name, or inside `source`, `destination`, `request_id` or `sender_auth`), and a `message_scheme` other than the one it verifies for the source chain (`EVM_PERMIT2` on EVM and Tron, `SOLANA` on Solana).
+- **Breaking:** the client refuses to sign a corridor the payer does not trust. It used to sign whatever escrow, reserver and releaser a merchant's challenge named, so a merchant could name its own contract as the escrow, or itself as reserver and releaser, and take up to the cap. Before anything is signed, `extra.escrow`, `extra.reserver` and `extra.releaser` are now compared with the source chain's trusted escrow, quote selector and fulfillment verifier account, and `extra.fulfillmentProxy` with the destination chain's trusted proxy; a mismatch throws `AtumEscrowTrustError` (`UNTRUSTED_ESCROW`, `UNTRUSTED_RESERVER`, `UNTRUSTED_RELEASER`, `UNTRUSTED_FULFILLMENT_PROXY`). The trust source is the new optional `trust` option on `registerClient`; without it the client asks `GET /v1/defaults` on Atum's production gateways (`ATUM_DEFAULT_TRUST_GATEWAYS`, via `atumGatewayTrust`), and a chain they do not serve, or an answer they cannot give, refuses (`CHAIN_NOT_TRUSTED`, `TRUST_SOURCE_UNAVAILABLE`). Building the signed request itself still makes no network call. **Payers on a devnet, a staging deployment or another operator must now pass `trust`**, or every payment is refused. A trust source's own refusal keeps its code, including an `AtumEscrowTrustError` thrown by another Atum package's resolver (matched by `name` and `code`, since each package bundles its own class), and an answer that is not well-formed roles — a role that is not a non-empty string, or a missing or malformed `tokens` list — is refused as `TRUST_SOURCE_UNAVAILABLE`. Payers on 0.4.x must upgrade to this release to get the check: it is not in a 0.4.x patch.
+- **Breaking:** the client bounds the spend cap. The source and destination tokens must be listed by the trust source (`UNTRUSTED_ASSET`) and be the same money — the same symbol, or in one of `pegGroups` (default `DEFAULT_PEG_GROUPS`) — or the payment is refused (`ASSETS_NOT_COMPARABLE`); `source.amount` may exceed `fulfillmentAmount` by at most `maxMarkupBps` (default `DEFAULT_MAX_MARKUP_BPS`, 500) after both are put in one unit (`MARKUP_EXCEEDED`). The same names, codes and defaults as `@atumlabs/x402-atum-escrow`'s client. **Merchants whose corridor `markupBps` is above 500 will be refused by payers on the default bound.**
+- The client refuses a challenge whose `fulfillmentAmount` is not a base-10 integer before anything is signed. It is not signed, and the cap bound is computed from it, so a hex, binary or padded value, which JavaScript's `BigInt` would also read, could otherwise inflate the bound, and an empty one would be read as 0.
 
 ## [0.4.1] - 2026-09-18
 
 ### Changed
 - Published under Apache-2.0 with `publishConfig.access: public`. npm will not overwrite 0.4.0, so this version exists to ship the LICENSE, NOTICE, and public visibility that 0.4.0 cannot take.
+- **Breaking: `PaymentSettlementStatus` now reads `'pending' | 'finalizing' | 'completed' | 'failed'`.** `cancelled` is removed — the gateway could not produce it, and a payment that ends undelivered is reported as `failed`. `finalizing` is added: the transaction is on chain but has not yet reached the confirmations its chain requires, so it is **not** terminal and a payment in that state is still waited on rather than written off. Code doing an exhaustive `switch` on this type will not compile until a `finalizing` branch is added. A status this package does not recognise is treated as pending rather than terminal, which is the safe direction: it raises `SettlementPendingError` (retry this purchase) instead of `SettlementFailedError` (start a new one), so a payment still in flight is never answered with an instruction to charge again.
+
+### Security
+- The axios copy bundled from the payment-gateway client is now 1.20.0, which patches the 1.13.x advisories. The notices file lists the new MIT transitives (`https-proxy-agent`, `agent-base`) that ride along.
 
 ## [0.4.0] - 2026-09-16
 

package/README.md

@@ -90,7 +90,7 @@ for the gateway connection and corridor defaults.
 | **Corridor** | The merchant's payment configuration: what it receives (destination), and which source chains/tokens it accepts. You define it once. |
 | **Source option** | A source chain (with its escrow and role addresses) and one or more tokens (`assets`) a payer may pay from on it. A corridor may list several; each challenge offers one `(chain, token)`. |
 | **`fulfillmentAmount`** | The exact amount, in the destination token's atomic units, the merchant will receive. USDC/USDT use 6 decimals, so `"10000000"` = 10 USDC. Set per charge. |
-| **Source cap** | The most the payer can spend on the source side: `fulfillmentAmount` + a markup (`markupBps`) to cover the cross-chain spread. The payer signs this cap. |
+| **Source cap** | The most the payer can spend on the source side: `fulfillmentAmount` + a markup (`markupBps`) to cover the cross-chain spread. The payer signs this cap. This package's payer client refuses a cap more than 500 bps above `fulfillmentAmount` unless the payer raises its `maxMarkupBps`, so keep `markupBps` at or below 500. |
 | **Escrow** | The source-chain contract the payer's funds lock into until the merchant is paid. |
 | **Deadlines** | Two budgets in seconds: `quoteDeadlineSeconds` (how long the auction runs) and `fulfillmentDeadlineSeconds` (how long settlement may take). Required order: `now < quote < fulfillment`. |
 | **`PaymentSubmitter`** | A small adapter *you* provide that hands a signed payment request to the Atum Payment Gateway and returns the result. |
@@ -224,6 +224,111 @@ const resource = await res.text();
 > corridor whose settlement can genuinely take minutes — see
 > [Settlement outcomes](#settlement-outcomes) for the retry pattern that handles it.
 
+### Trusted corridors and the spend cap
+
+**Who the escrow protects, and against whom.** The escrow protects the payer against a settler
+that does not pay: it holds the payer's funds until the fulfillment verifier confirms that the
+settler paid the merchant on the destination chain. (It does not cover the merchant failing to
+deliver the HTTP resource.) That protection only holds if the escrow, the reserver (who picks the
+settler and how much of the cap it is paid) and the releaser (who opens the escrow) are ones the
+payer trusts. The merchant writes all of them into the
+challenge, so a merchant that named its own contract as the escrow, or itself as reserver or
+releaser, could take up to the cap without delivering anything. The client therefore protects the
+**payer** against the **merchant's** choice of corridor: before anything is signed, it checks the
+challenge against a source the payer controls, the way a browser checks a site's certificate
+against the authorities it trusts. The check cannot be turned off; only the trust source is
+configurable, and it never comes from the challenge. The merchant's `verify()` checks the opposite
+direction — that the credential matches the merchant's own terms — so it offers the payer nothing
+here.
+
+What is checked:
+
+- on the source chain: `extra.escrow` against the trusted escrow, `extra.reserver` against the
+  trusted quote selector, and `extra.releaser` against the trusted fulfillment verifier account;
+- on the destination chain: `extra.fulfillmentProxy` against the trusted fulfillment proxy;
+- both tokens must be ones the trust source lists for their chain, and must be the same money:
+  the same symbol, or in one peg group;
+- the cap (`source.amount`) may exceed `fulfillmentAmount` by at most `maxMarkupBps`, after both
+  are put in one unit using the tokens' decimals.
+
+**The trust source.** By default the client asks `GET /v1/defaults` on Atum's production
+gateways (`ATUM_DEFAULT_TRUST_GATEWAYS`: production mainnet and production testnet) and caches a
+successful answer per chain for five minutes. Building the signed request itself makes no network
+call; this lookup does, and so does a Turnkey signer when it signs. Pass `trust` to use another
+source:
+
+```ts
+import {
+  AtumEscrowTrustError,
+  atumGatewayTrust,
+  registerClient,
+  type TrustedRoles,
+} from "@atumlabs/mppx-atum-escrow/client";
+
+// Another deployment's gateway (a staging environment, a local devnet, another operator)…
+const method = registerClient({
+  signer: { privateKey: process.env.PAYER_PRIVATE_KEY! },
+  account: process.env.PAYER_ADDRESS!,
+  trust: atumGatewayTrust({ gateways: ["http://localhost:8080"] }),
+});
+
+// …or a fixed set of addresses, with no network call. Each entry carries escrowContract,
+// quoteSelector, fulfillmentVerifierAccount, fulfillmentProxy and the payable tokens.
+const TRUSTED_CORRIDORS: Record<string, TrustedRoles> = {
+  /* "eip155:8453": { ... } */
+};
+const pinned = registerClient({
+  signer: { privateKey: process.env.PAYER_PRIVATE_KEY! },
+  account: process.env.PAYER_ADDRESS!,
+  trust: async (network) => {
+    const roles = TRUSTED_CORRIDORS[network];
+    if (!roles) {
+      throw new AtumEscrowTrustError({
+        code: "CHAIN_NOT_TRUSTED",
+        network,
+        message: `no trusted corridor on ${network}`,
+      });
+    }
+    return roles;
+  },
+});
+```
+
+> **Devnet and staging must pass `trust`.** A local devnet forks mainnet and keeps mainnet chain
+> ids, and staging runs its own escrow and roles, so the default would answer with production's
+> addresses and every payment would be refused. A devnet whose tokens are test stand-ins (for
+> example `TUSDC`, `TUSDT`) must also pass `pegGroups` naming them, or the client cannot price one
+> against the other and refuses with `ASSETS_NOT_COMPARABLE`:
+> `pegGroups: [[...DEFAULT_PEG_GROUPS[0], "TUSDC", "TUSDT"]]`.
+
+**The cap.** `maxMarkupBps` (default `DEFAULT_MAX_MARKUP_BPS`, 500) is the most the cap may exceed
+`fulfillmentAmount`, in basis points. `pegGroups` (default `DEFAULT_PEG_GROUPS`, the US-dollar
+stablecoins on the network's allowlists) lists the token symbols the payer treats as
+interchangeable 1:1; passing it replaces the default. Tokens that are neither the same symbol nor
+in one group are not priced against each other at all.
+
+**Refusals.** Every refusal is an `AtumEscrowTrustError`, and nothing is signed. Branch on `code`
+(or `name`), not on `instanceof`: each published Atum package bundles its own copy of this class,
+so an error from one package is not an instance of another package's class.
+
+| `code`                        | Meaning                                                                      |
+| ----------------------------- | ---------------------------------------------------------------------------- |
+| `UNTRUSTED_ESCROW`            | `extra.escrow` is not the trusted escrow                                     |
+| `UNTRUSTED_RESERVER`          | `extra.reserver` is not the trusted quote selector                           |
+| `UNTRUSTED_RELEASER`          | `extra.releaser` is not the trusted fulfillment verifier                     |
+| `UNTRUSTED_FULFILLMENT_PROXY` | the fulfillment proxy is not the destination chain's trusted proxy           |
+| `UNTRUSTED_ASSET`             | a token is not one the trust source lists for its chain; `field` says which (`source.asset` or `extra.destination.asset`) |
+| `ASSETS_NOT_COMPARABLE`       | the two tokens are not the same money                                        |
+| `MARKUP_EXCEEDED`             | `source.amount` is above the bound; `expected` is the largest amount allowed |
+| `CHAIN_NOT_TRUSTED`           | the trust source serves nothing on the chain                                 |
+| `TRUST_SOURCE_UNAVAILABLE`    | the trust source could not answer, or answered with something other than roles; retry only if the failure was transient |
+
+For the `UNTRUSTED_*` codes and `MARKUP_EXCEEDED`, `field`, `expected` (the trusted value or
+bound) and `actual` (what the challenge asked for) say exactly what failed.
+
+Before any of these checks, a challenge whose `fulfillmentAmount` is not a base-10 integer is
+refused with a plain `Error`: it is a malformed challenge, not a trust verdict.
+
 ### Approving the source token
 
 On EVM and Tron, the payer must approve the token-transfer contract (Permit2) to move the source
@@ -534,15 +639,18 @@ Import everything from the root, or from the role-specific entry points (which e
 each side needs):
 
 - `@atumlabs/mppx-atum-escrow` — everything below
-- `@atumlabs/mppx-atum-escrow/client` — `registerClient`, `ensureSourceApproval`, `needsSourceApproval` + payer types
+- `@atumlabs/mppx-atum-escrow/client` — `registerClient`, `ensureSourceApproval`, `needsSourceApproval`, the trust API + payer types
 - `@atumlabs/mppx-atum-escrow/server` — `registerServer`, `buildChargeChallenge`,
   `buildChargeRequest`, `validateCorridor`, `corridorFromDefaults`, the settlement errors +
   merchant types
 
 | Export | Description |
 | --- | --- |
-| `registerClient(config)` | Payer-side method. `config`: `{ signer, account, now?, solanaClockReader? }`. |
-| `registerServer(config)` | Merchant-side method. `config`: `{ submitter, now? }`. Returns an `AtumEscrowServer`, whose `verify()` resolves with an `AtumEscrowReceipt`. |
+| `registerClient(config)` | Payer-side method. `config`: `{ signer, account, now?, solanaClockReader?, trust?, maxMarkupBps?, pegGroups? }`. See [Trusted corridors and the spend cap](#trusted-corridors-and-the-spend-cap). |
+| `atumGatewayTrust(options?)` | A trust source backed by gateways' `GET /v1/defaults` (default: `ATUM_DEFAULT_TRUST_GATEWAYS`), cached per chain. The default `trust`. |
+| `AtumEscrowTrustError` | Why the client refused to sign a challenge; branch on `code`. |
+| `DEFAULT_MAX_MARKUP_BPS`, `DEFAULT_PEG_GROUPS` | The client's defaults for `maxMarkupBps` (500) and `pegGroups`. |
+| `registerServer(config)` | Merchant-side method. `config`: `{ submitter, now?, onCommitmentResult? }`; `onCommitmentResult(result, logFields)` receives every payee-check result, so you can count payments by `logFields.sender_auth_result` and log refusals. Returns an `AtumEscrowServer`, whose `verify()` resolves with an `AtumEscrowReceipt`. |
 | `buildChargeChallenge(corridor, select, fulfillmentAmount, { intentId, issuedAt? })` | Builds a `charge` challenge — the payment terms plus the per-purchase identifier that makes a retry safe. **Use this.** Returns `{ request, meta }`. |
 | `buildChargeRequest(corridor, select, fulfillmentAmount, options?)` | The payment terms alone, without the identifier. For supplying challenge metadata by hand. |
 | `validateCorridor(corridor)` | Validates a corridor's shape and per-source addresses (run automatically by both builders). |
@@ -558,6 +666,7 @@ each side needs):
 
 Key types: `AtumEscrowCorridor`, `AtumEscrowSource`, `SenderSigner`, `SenderSignerOptions`,
 `PaymentSubmitter`, `PaymentSubmitResult`, `PaymentSettlementStatus`, `AtumEscrowClientConfig`,
+`TrustResolver`, `TrustedRoles`, `TrustedToken`, `AtumEscrowTrustErrorCode`, `AtumGatewayTrustOptions`,
 `AtumEscrowServer`, `AtumEscrowServerConfig`, `ChainDefaultsSource`, `EnsureApprovalResult`,
 `AtumEscrowChallenge`, `AtumEscrowCredential`, `AtumEscrowReceipt`, `ChargeChallenge`, `ChargeRequest`,
 `SettlementErrorDetails`, `PaymentRequest`, `FulfillmentConfirmation`.

package/dist/{chunk-EWIOTGMO.js → chunk-5IQDNGVU.js}

@@ -13,7 +13,7 @@ import {
   require_dist2 as require_dist,
   sameAddress,
   sameAssetIdentifier
-} from "./chunk-LAWFMGYD.js";
+} from "./chunk-F3H73WI3.js";
 
 // src/server.ts
 var import_payment_request_sender_auth2 = __toESM(require_dist(), 1);
@@ -99,6 +99,32 @@ var PaymentRejectedError = class extends Errors.BadRequestError {
 // src/server.ts
 var DEADLINE_SKEW_TOLERANCE_MS = 6e4;
 var SOLANA_MAX_FULFILLMENT_DEADLINE_SECONDS = import_payment_request_sender_auth2.REPLAY_HORIZON_SECS - 10;
+function checkCommitment(config, check) {
+  let checked;
+  try {
+    checked = check();
+  } catch (e) {
+    const refused = (0, import_payment_request_sender_auth2.commitmentResultOf)(e);
+    if (refused !== void 0) {
+      try {
+        config.onCommitmentResult?.(refused, (0, import_payment_request_sender_auth2.commitmentLogFields)(refused));
+      } catch {
+      }
+    }
+    throw e;
+  }
+  try {
+    config.onCommitmentResult?.(checked.result, (0, import_payment_request_sender_auth2.commitmentLogFields)(checked.result));
+  } catch {
+    throw new Error("atum-escrow: the payment could not be recorded, so it is refused");
+  }
+  return checked.value;
+}
+var SCHEME_BY_NAMESPACE = /* @__PURE__ */ new Map([
+  ["eip155", "EVM_PERMIT2"],
+  ["tron", "EVM_PERMIT2"],
+  ["solana", "SOLANA"]
+]);
 function registerServer(config) {
   const now = config.now ?? (() => Date.now());
   return Method.toServer(atumEscrowChargeMethod, {
@@ -110,6 +136,11 @@ function registerServer(config) {
       if (!senderAuth || senderAuth.signed_messages.length === 0) {
         throw new Error("atum-escrow: credential is missing sender_auth");
       }
+      if (senderAuth.signed_messages.length !== 1) {
+        throw new Error(
+          "atum-escrow: sender_auth must carry exactly one signed message, the deposit"
+        );
+      }
       const signed = senderAuth.signed_messages[0];
       if (!signed.message_prehash) {
         throw new Error("atum-escrow: sender_auth is missing message_prehash");
@@ -117,38 +148,19 @@ function registerServer(config) {
       if (!pr.source) {
         throw new Error("atum-escrow: credential is missing a source");
       }
+      if (senderAuth.message_scheme !== SCHEME_BY_NAMESPACE.get(namespace)) {
+        throw new Error(
+          `atum-escrow: unsupported message_scheme for ${source.network}: ${senderAuth.message_scheme}`
+        );
+      }
       const maxSourceStr = pr.max_source_amount ?? "0";
+      if (!/^(?:0|[1-9][0-9]*)$/.test(maxSourceStr)) {
+        throw new Error("atum-escrow: max_source_amount is not a decimal integer string");
+      }
       const cap = BigInt(source.amount);
       if (BigInt(maxSourceStr) > cap) {
         throw new Error("atum-escrow: max_source_amount exceeds the source cap");
       }
-      const authTerms = (0, import_payment_request_sender_auth2.getChainAdapter)(source.network).recoverAndVerify(
-        signed,
-        { network: source.network, asset: source.asset, account: pr.source.account },
-        {
-          maxSourceAmount: maxSourceStr,
-          escrowContract: extra.escrow,
-          reserver: extra.reserver,
-          releaser: extra.releaser,
-          svmSignatureClusterId: extra.svmSignatureClusterId,
-          svmSignatureDomainVersion: extra.svmSignatureDomainVersion,
-          // Check permit freshness against the merchant's own clock (the same `now` used for
-          // deadline ordering/budgets), not the SDK's wall clock — so freshness is consistent
-          // with the rest of verify and deterministic under an injected clock.
-          nowSec: Math.floor(now() / 1e3)
-        }
-      );
-      const intentId = intentIdOf(credential.challenge);
-      if (intentId === void 0) {
-        throw new Error(
-          `atum-escrow: the challenge carries no '${INTENT_ID_META_KEY}' metadata, so this payment cannot be de-duplicated and is refused`
-        );
-      }
-      if (pr.request_id !== chargeRequestId(intentId, pr.source.account)) {
-        throw new Error(
-          "atum-escrow: request_id is not derived from the challenge's purchase identifier, so a retry of this payment would not de-duplicate"
-        );
-      }
       const dest = pr.destination?.[0];
       if (!dest) {
         throw new Error("atum-escrow: credential is missing a destination");
@@ -163,6 +175,44 @@ function registerServer(config) {
       if (pr.fulfillment_amount !== extra.fulfillmentAmount) {
         throw new Error("atum-escrow: fulfillment_amount does not match the challenge");
       }
+      const authTerms = checkCommitment(config, () => {
+        const verified = (0, import_payment_request_sender_auth2.getChainAdapter)(source.network).recoverAndVerify(
+          signed,
+          { network: source.network, asset: source.asset, account: pr.source.account },
+          { destinations: pr.destination, requestId: pr.request_id ?? "" },
+          {
+            maxSourceAmount: maxSourceStr,
+            escrowContract: extra.escrow,
+            reserver: extra.reserver,
+            releaser: extra.releaser,
+            svmSignatureClusterId: extra.svmSignatureClusterId,
+            svmSignatureDomainVersion: extra.svmSignatureDomainVersion,
+            // Use the same clock as the deadline checks below, so an injected `now` applies
+            // throughout.
+            nowSec: Math.floor(now() / 1e3)
+          }
+        );
+        const result2 = (0, import_payment_request_sender_auth2.verifyRequestCommitment)(
+          JSON.stringify(pr),
+          extra.svmSignatureDomainVersion == null ? void 0 : {
+            escrowProgramId: extra.escrow,
+            clusterId: extra.svmSignatureClusterId ?? "",
+            domainVersion: extra.svmSignatureDomainVersion
+          }
+        );
+        return { value: verified, result: result2 };
+      });
+      const intentId = intentIdOf(credential.challenge);
+      if (intentId === void 0) {
+        throw new Error(
+          `atum-escrow: the challenge carries no '${INTENT_ID_META_KEY}' metadata, so this payment cannot be de-duplicated and is refused`
+        );
+      }
+      if (pr.request_id !== chargeRequestId(intentId, pr.source.account)) {
+        throw new Error(
+          "atum-escrow: request_id is not derived from the challenge's purchase identifier, so a retry of this payment would not de-duplicate"
+        );
+      }
       const overrides = contractOverridesFromExtra(source.network, extra);
       const expectedQuoteSelector = overrides?.quote_selector ?? extra.reserver;
       const expectedVerifier = overrides?.fulfillment_verifier ?? {