@metalntwx/metal-pay 0.3.0 → 0.3.2

package/src/clearing-client.test.ts

@@ -0,0 +1,850 @@
+import { createServer, type Server } from "node:http";
+import { afterAll, beforeAll, describe, expect, it } from "vitest";
+import { x402Client } from "@x402/core/client";
+import { encodePaymentRequiredHeader } from "@x402/core/http";
+import type { PaymentRequirements } from "@x402/core/types";
+import { decodeFunctionData, encodeFunctionResult, hexToBytes, toHex, type Hex } from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import { clearingAbi } from "./clearing-abi.js";
+import { p256 } from "@noble/curves/p256";
+import { CLEARING_REFERENCE, clearingSignatureDigest, createClearingSigner, encodeSend } from "./clearing-codec.js";
+import { ClearingRefusal, createClearingClient, type ClearingClientState, type ClearingPaid, type ClearingPayment } from "./clearing-client.js";
+import { clearingInvoice, clearingRequirements, registerClearingClient } from "./clearing-x402.js";
+import { createMetalPaymentClient } from "./client.js";
+
+const NETWORK = "eip155:1337";
+const SETTLEMENT = `0x${"22".repeat(20)}` as const;
+const ASSET = `0x${"33".repeat(20)}` as const;
+const ANCHOR = `0x${"aa".repeat(32)}` as const;
+const ZERO32 = `0x${"00".repeat(32)}` as const;
+const SERVICE_URL = "http://clearing.test";
+/** The contract's clearing unit: an 18-decimal token's, a millionth of it. */
+const UNIT = 10n ** 12n;
+const payer = createClearingSigner(`0x${"12".repeat(32)}`);
+const seller = createClearingSigner(`0x${"23".repeat(32)}`);
+const operator = createClearingSigner(`0x${"34".repeat(32)}`);
+const CHUNK = "http://seller.test/chunk/1";
+const OTHER = "http://seller.test/chunk/2";
+
+/** The Clearing contract's epoch count, the service's epoch 1 admitted, its fault, none, the chain's id, and whether the contract is there, unless set otherwise. */
+const chain = { admitted: 1n, fault: 0, id: 1337, deployed: true };
+const head = { root: ZERO32, operations: 0n, floor: 0n };
+const views: Record<string, () => unknown> = {
+  registered: () => true,
+  fault: () => chain.fault,
+  admittedCount: () => chain.admitted,
+  unit: () => UNIT,
+  operatorKey: () => operator.publicKey,
+  contextOf: () => ({
+    anchor: ANCHOR,
+    epoch: 1n,
+    operatorKey: operator.publicKey,
+    deployment: ZERO32,
+    deposits: ZERO32,
+    withdrawals: ZERO32,
+    liability: 0n,
+    admissionDeadline: 100n,
+    challengeDeadline: 200n,
+    limits: { states: 0n, rows: 0n, withdrawals: 0n, accountEntries: 0n, totalEntries: 0n, paymentTotal: 0n, depositTotal: 0n, withdrawalTotal: 0n },
+    committee: ZERO32,
+    predecessor: ZERO32,
+    activity: head,
+    payouts: head,
+    activityFloor: 0n,
+    payoutFloor: 0n,
+  }),
+};
+const rpc = createServer((req, res) => {
+  let body = "";
+  req.on("data", (c) => (body += c));
+  req.on("end", () => {
+    const { id, method, params } = JSON.parse(body);
+    const ok = (result: unknown) => res.end(JSON.stringify({ jsonrpc: "2.0", id, result }));
+    res.setHeader("content-type", "application/json");
+    if (method === "eth_chainId") return ok(`0x${chain.id.toString(16)}`);
+    if (method === "eth_getBlockByNumber")
+      return ok({
+        number: "0xa", hash: ZERO32, parentHash: ZERO32, timestamp: "0x1", baseFeePerGas: "0x7", gasLimit: "0x1", gasUsed: "0x0",
+        transactions: [], logsBloom: `0x${"00".repeat(256)}`, miner: `0x${"00".repeat(20)}`, extraData: "0x", difficulty: "0x0",
+        nonce: "0x0000000000000000", sha3Uncles: ZERO32, stateRoot: ZERO32, receiptsRoot: ZERO32, transactionsRoot: ZERO32, size: "0x1", uncles: [],
+      });
+    if (!chain.deployed) return ok("0x");
+    const { functionName } = decodeFunctionData({ abi: clearingAbi, data: params[0].data ?? params[0].input });
+    ok(encodeFunctionResult({ abi: clearingAbi, functionName, result: views[functionName]!() } as never));
+  });
+});
+let rpcUrl: string;
+beforeAll(async () => {
+  rpcUrl = await listen(rpc);
+});
+afterAll(() => new Promise<void>((resolve) => rpc.close(() => resolve())));
+
+/** The service's answers, as the builders saw them. */
+const open = (epoch = "1") =>
+  Response.json({ reference: CLEARING_REFERENCE, network: NETWORK, settlement: SETTLEMENT, asset: ASSET, operator: operator.publicKey, epoch, anchor: ANCHOR });
+const betweenEpochs = () => Response.json({ error: "clearing request unavailable" }, { status: 409 });
+const rejected = () => Response.json({ error: "clearing request unavailable", rejected: true }, { status: 409 });
+/** The service's estimate of what the account can spend, in clearing units. */
+const spendable = (amount: bigint) => () => Response.json({ amount: amount.toString() });
+const busy = () => Response.json({ error: "busy" }, { status: 503 });
+const lost = (): Response => {
+  throw new TypeError("fetch failed");
+};
+const accepted = (payment: ClearingPayment) =>
+  Response.json({
+    invoice: payment.invoice,
+    receipt: { body: payment.body, payerSignature: payment.payerSignature, operatorSignature: operator.sign("_COMMONWARE_CLEARING_VECTOR_ACK", payment.body) },
+    invoiceSignature: payment.invoiceSignature,
+    entries: payment.entries,
+  });
+
+/** A wallet over a clearing service that answers `/context`, `/spendable`, `/receipt` and each `POST /payments` in turn, `open`, nothing spendable, no receipt known (404) and `accepted` once its list runs out. */
+function wallet(
+  answers: { context?: (() => Response)[]; spendable?: (() => Response)[]; receipt?: (() => Response)[]; payments?: ((payment: ClearingPayment) => Response)[] } = {},
+  maxAmount = 1000n * UNIT,
+) {
+  let state: ClearingClientState | null = null;
+  const posted: ClearingPayment[] = [];
+  const asked: string[] = [];
+  const client = createClearingClient({
+    serviceUrl: SERVICE_URL,
+    rpcUrl,
+    network: NETWORK,
+    settlement: SETTLEMENT,
+    asset: ASSET,
+    signer: payer,
+    maxAmount,
+    store: {
+      async load() {
+        return structuredClone(state);
+      },
+      async save(value) {
+        state = structuredClone(value);
+      },
+    },
+    fetch: async (input, init) => {
+      const path = new URL(String(input)).pathname;
+      asked.push(new URL(String(input)).pathname + new URL(String(input)).search);
+      if (path === "/context") return (answers.context?.shift() ?? open)();
+      if (path === `/spendable/${payer.publicKey}`) return (answers.spendable?.shift() ?? spendable(0n))();
+      if (path.startsWith(`/receipt/${payer.publicKey}/`)) return (answers.receipt?.shift() ?? (() => new Response(null, { status: 404 })))();
+      if (path === "/payments") {
+        const payment = JSON.parse(String(init?.body)) as ClearingPayment;
+        posted.push(payment);
+        return (answers.payments?.shift() ?? accepted)(payment);
+      }
+      return new Response(null, { status: 404 });
+    },
+  });
+  return { client, posted, asked, state: () => state };
+}
+const offer = (url: string, amount = 5n * UNIT) =>
+  clearingRequirements({ network: NETWORK, asset: ASSET, settlement: SETTLEMENT, recipient: seller.publicKey, serviceUrl: SERVICE_URL }, amount, url);
+const invoiceFor = (url: string, amount = 5n * UNIT) => clearingInvoice(offer(url, amount), `${offer(url, amount).extra!.invoicePrefix}:${url.at(-1)}`);
+const refusal = (paying: Promise<unknown>) =>
+  paying.then(
+    () => expect.unreachable("the payment went through"),
+    (error: unknown) => {
+      expect(error).toBeInstanceOf(ClearingRefusal);
+      return error as ClearingRefusal;
+    },
+  );
+
+describe("clearing refusals", () => {
+  it("between epochs: /context answers 409 `clearing request unavailable`; nothing is held and a later request pays", async () => {
+    const { client, posted, state } = wallet({ context: [betweenEpochs] });
+    const error = await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    expect(error.reason).toBe("between_epochs");
+    // The service registers an epoch 2 s after the last one's admission, then a block includes it.
+    expect(error.retry).toEqual({ action: "retry_after_ms", ms: 3000 });
+    expect(error.message).toMatch(/between epochs/);
+    expect(error.message).toMatch(/a few seconds/);
+    expect(error.message).toMatch(/every epoch/);
+    expect(error.message).toMatch(/after 3000 ms, and again after each further between_epochs refusal/);
+    // A validator's URL as serviceUrl, or a service that is down, answers the same for good.
+    expect(error.message).toMatch(/if it lasts longer than an epoch, check that serviceUrl is the facilitator's extra\.serviceUrl \(a validator takes no payments\), or the service is down/);
+    expect(error.message).toMatch(/nothing was paid/);
+    expect(posted).toHaveLength(0);
+    expect(state()?.pending).toBeUndefined();
+    await client.pay(invoiceFor(OTHER), OTHER);
+  });
+
+  it("between epochs: the contract has not admitted the epoch the service opened", async () => {
+    chain.admitted = 0n;
+    try {
+      const { client, posted } = wallet();
+      const error = await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+      expect(error).toMatchObject({ reason: "between_epochs", retry: { action: "retry_after_ms" } });
+      expect(posted).toHaveLength(0);
+    } finally {
+      chain.admitted = 1n;
+    }
+  });
+
+  it("between epochs: a payment the service refuses for good because its epoch closed as it was sent", async () => {
+    const { client, state } = wallet({ context: [open, betweenEpochs], payments: [rejected] });
+    const error = await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    expect(error).toMatchObject({ reason: "between_epochs", retry: { action: "retry_after_ms", ms: 3000 } });
+    expect(state()?.pending).toBeUndefined();
+  });
+
+  it("between epochs: a refused payment whose epoch the service has moved past", async () => {
+    const { client } = wallet({ context: [open, () => open("2")], payments: [rejected] });
+    expect((await refusal(client.pay(invoiceFor(CHUNK), CHUNK))).reason).toBe("between_epochs");
+  });
+
+  it("a faulted deployment: /context answers 409 `clearing request unavailable` for good, and the refusal names recoverFromClearing", async () => {
+    const faulted = (error: Error) => {
+      expect(error).not.toBeInstanceOf(ClearingRefusal);
+      expect(error.message).toMatch(/faulted/);
+      expect(error.message).toMatch(/nothing was paid/);
+      expect(error.message).toMatch(/recoverFromClearing/);
+    };
+    const failed = (paying: Promise<unknown>) => paying.then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+    // A payment held from before the fault, sent again: the service rejects it, and the re-read refuses.
+    const held = wallet({ context: [open, betweenEpochs], payments: [lost, rejected] });
+    await refusal(held.client.pay(invoiceFor(CHUNK), CHUNK));
+    chain.fault = 1;
+    try {
+      faulted(await failed(held.client.pay(invoiceFor(CHUNK), CHUNK)));
+      expect(held.state()?.pending).toBeUndefined();
+      // A new payment: /context refuses first, or the service has yet to see the fault.
+      for (const answers of [{ context: [betweenEpochs] }, {}]) {
+        const { client, posted } = wallet(answers);
+        faulted(await failed(client.pay(invoiceFor(CHUNK), CHUNK)));
+        expect(posted).toHaveLength(0);
+      }
+    } finally {
+      chain.fault = 0;
+    }
+  });
+
+  it("insufficient deposit: the service refuses the payment for good while its epoch is open and the account cannot spend its price", async () => {
+    const { client, state } = wallet({ payments: [rejected], spendable: [spendable(4n)] });
+    const error = await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    expect(error.reason).toBe("insufficient_deposit");
+    expect(error.retry).toEqual({ action: "deposit" });
+    expect(error.message).toMatch(/deposit does not cover/);
+    expect(error.message).toMatch(/nothing was paid/);
+    expect(error.message).toMatch(/depositToClearing/);
+    expect(state()?.pending).toBeUndefined();
+  });
+
+  it("a refusal the deposit does not explain: the account can spend the price, so the wallet does not say to deposit", async () => {
+    const { client, state } = wallet({ payments: [rejected], spendable: [spendable(5n)] });
+    const error = await client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+    expect(error).not.toBeInstanceOf(ClearingRefusal);
+    expect(error.message).toMatch(/deposit covers it/);
+    expect(error.message).toMatch(/nothing was paid/);
+    expect(error.message).not.toMatch(/deposit more/);
+    expect((error.cause as Error).message).toBe("clearing payment rejected before acknowledgment");
+    expect(state()?.pending).toBeUndefined();
+  });
+
+  it("a refusal the wallet cannot explain: the /context re-read answers 503, which is not between epochs", async () => {
+    const { client, state } = wallet({ context: [open, busy], payments: [rejected] });
+    const error = await client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+    expect(error).not.toBeInstanceOf(ClearingRefusal);
+    expect(error.message).toMatch(/503/);
+    expect(error.message).toMatch(/nothing was paid/);
+    expect((error.cause as Error).message).toBe("clearing payment rejected before acknowledgment");
+    expect(state()?.pending).toBeUndefined();
+  });
+
+  it("a wrong chain: the RPC serves another chain while the contract there looks between epochs, and the error names the chain, not a gap", async () => {
+    Object.assign(chain, { id: 1, admitted: 0n });
+    try {
+      const { client, posted } = wallet();
+      const error = await client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+      expect(error).not.toBeInstanceOf(ClearingRefusal);
+      expect(error.message).toMatch(/serves eip155:1, not eip155:1337/);
+      expect(posted).toHaveLength(0);
+    } finally {
+      Object.assign(chain, { id: 1337, admitted: 1n });
+    }
+  });
+
+  it("a wrong chain with no Clearing contract at the address: the error names the chain, not the missing contract", async () => {
+    Object.assign(chain, { id: 1, deployed: false });
+    try {
+      for (const answers of [{}, { context: [betweenEpochs] }]) {
+        const error = await wallet(answers).client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+        expect(error.message).toMatch(/serves eip155:1, not eip155:1337/);
+      }
+    } finally {
+      Object.assign(chain, { id: 1337, deployed: true });
+    }
+  });
+
+  it("a held payment sent again to a service that has yet to see the fault: its rejection names recoverFromClearing, not a deposit or a resend", async () => {
+    for (const answers of [{ spendable: [spendable(0n)] }, { spendable: [spendable(5n)] }, { context: [open, () => open("2")] }]) {
+      const { client } = wallet({ ...answers, payments: [lost, rejected] });
+      await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+      chain.fault = 1;
+      try {
+        const error = await client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+        expect(error).not.toBeInstanceOf(ClearingRefusal);
+        expect(error.message).toMatch(/faulted.*nothing was paid.*recoverFromClearing/);
+      } finally {
+        chain.fault = 0;
+      }
+    }
+  });
+
+  it("a held payment whose deployment faulted while the service is gone: the error names recoverFromClearing, not another resend", async () => {
+    const { client } = wallet({ payments: [lost, lost] });
+    await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    chain.fault = 1;
+    try {
+      const error = await client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+      expect(error).not.toBeInstanceOf(ClearingRefusal);
+      expect(error.message).toMatch(/faulted.*recoverFromClearing/);
+      // The hold outlives the deployment: a replacement takes a new wallet.
+      expect(error.message).toMatch(/keeps it held, so a replacement deployment takes a new wallet/);
+      expect(error.message).not.toMatch(/nothing was paid/);
+    } finally {
+      chain.fault = 0;
+    }
+  });
+
+  it("a first /context that answers 503 names it, says nothing was paid, and says to send the request again", async () => {
+    const { client, posted } = wallet({ context: [busy] });
+    const error = await client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+    expect(error.message).toMatch(/503/);
+    expect(error.message).toMatch(/nothing was paid/);
+    expect(error.message).toMatch(/send the request again/);
+    expect((error.cause as Error).message).toBe("clearing service returned 503");
+    expect(posted).toHaveLength(0);
+  });
+
+  it("an acknowledgment that does not verify, on every resend, holds the payment as answer_lost and says the service answered, not that the answer was lost", async () => {
+    const forged = (payment: ClearingPayment) =>
+      Response.json({
+        invoice: payment.invoice,
+        // Signed by a key that is not the operator's.
+        receipt: { body: payment.body, payerSignature: payment.payerSignature, operatorSignature: seller.sign("_COMMONWARE_CLEARING_VECTOR_ACK", payment.body) },
+        invoiceSignature: payment.invoiceSignature,
+        entries: payment.entries,
+      });
+    const { client, posted, state } = wallet({ payments: [forged, forged] });
+    for (let send = 0; send < 2; send++) {
+      const error = await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+      expect(error).toMatchObject({ reason: "answer_lost", retry: { action: "repeat_same_request", url: CHUNK, ms: 3000 } });
+      expect(error.message).toMatch(/the clearing service answered/);
+      expect(error.message).toMatch(/does not verify against this payment and the deployment's operator key/);
+      expect(error.message).toMatch(/serviceUrl may belong to another deployment/);
+      expect(error.message).toMatch(/facilitator's \/supported/);
+      expect(error.message).toMatch(/until it is sent once to the right service/);
+      expect(error.message).not.toMatch(/lost|no receipt/);
+      expect(state()?.pending?.invoice).toEqual(invoiceFor(CHUNK));
+    }
+    // Sent to a service that acknowledges it, it is the same payment, paid once.
+    await client.pay(invoiceFor(CHUNK), CHUNK);
+    expect(posted[2]).toEqual(posted[0]);
+    expect(state()?.pending).toBeUndefined();
+  });
+
+  it("answer lost: `fetch failed` on POST /payments holds the payment, and the same request sends it again, paid once", async () => {
+    const { client, posted, state } = wallet({ payments: [lost] });
+    const error = await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    expect(error.reason).toBe("answer_lost");
+    expect(error.retry).toEqual({ action: "repeat_same_request", url: CHUNK, amount: (5n * UNIT).toString(), ms: 3000 });
+    expect(error.message).toMatch(/fetch failed/);
+    expect(error.message).toMatch(/after 3000 ms/);
+    expect(error.message).toMatch(/outcome is unknown/);
+    expect(error.message).toMatch(/send the same request again/);
+    expect(error.message).toContain("pass the wallet's pendingInvoice() to its pay");
+    expect(error.message).toContain(CHUNK);
+    expect(error.message).toMatch(/if it is still held after an epoch, check that serviceUrl is the facilitator's extra\.serviceUrl \(a validator takes no payments\)/);
+    expect(state()?.pending?.invoice).toEqual(invoiceFor(CHUNK));
+    await client.pay(invoiceFor(CHUNK), CHUNK);
+    expect(posted).toHaveLength(2);
+    expect(posted[1]).toEqual(posted[0]);
+    expect(state()?.pending).toBeUndefined();
+  });
+
+  it("a POST /payments refusal with no rejected flag, 409 or 503, holds the payment and resends it byte-identical", async () => {
+    for (const refused of [betweenEpochs, busy]) {
+      const { client, posted, state } = wallet({ payments: [refused, accepted] });
+      const error = await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+      expect(error.reason).toBe("answer_lost");
+      expect(state()?.pending?.invoice).toEqual(invoiceFor(CHUNK));
+      expect(posted).toHaveLength(1);
+      await client.pay(invoiceFor(CHUNK), CHUNK);
+      expect(posted).toHaveLength(2);
+      expect(posted[1]).toEqual(posted[0]);
+      expect(state()?.pending).toBeUndefined();
+    }
+  });
+
+  it("a held payment the service keeps refusing is released once its epoch has closed with no receipt, and not before", async () => {
+    // A 400 the service answers for the same bytes every time, as it does for a payment it cannot parse.
+    const unparseable = () => Response.json({ error: "malformed payment" }, { status: 400 });
+    const none = () => Response.json(null);
+    const { client, posted, state } = wallet({ payments: [unparseable, unparseable, unparseable], receipt: [none, none] });
+    expect((await refusal(client.pay(invoiceFor(CHUNK), CHUNK))).reason).toBe("answer_lost");
+    // Sent again while its epoch is open, the service has no receipt and may yet take it: it stays held.
+    expect((await refusal(client.pay(invoiceFor(CHUNK), CHUNK))).reason).toBe("answer_lost");
+    expect(state()?.pending?.invoice).toEqual(invoiceFor(CHUNK));
+    chain.admitted = 2n;
+    try {
+      const error = await client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+      expect(error).not.toBeInstanceOf(ClearingRefusal);
+      expect(error.message).toMatch(/the clearing service has no record of this payment, 5000000000000 base units for http:\/\/seller\.test\/chunk\/1, and the epoch it was signed for has closed or is no longer the live one/);
+      expect(error.message).toMatch(/released; nothing was paid and nothing is held: send the request again/);
+      expect(state()?.pending).toBeUndefined();
+      expect(posted).toHaveLength(3);
+    } finally {
+      chain.admitted = 1n;
+    }
+  });
+
+  it("releases a held payment whose epoch is no longer the service's live one, even when an epoch numbered like it is open, and starts its vector over", async () => {
+    const unparseable = () => Response.json({ error: "malformed payment" }, { status: 400 });
+    // A chain reset: the service's epoch 1 carries another anchor than the payment was signed under.
+    const reset = () =>
+      Response.json({ reference: CLEARING_REFERENCE, network: NETWORK, settlement: SETTLEMENT, asset: ASSET, operator: operator.publicKey, epoch: "1", anchor: `0x${"bb".repeat(32)}` });
+    const { client, state } = wallet({ context: [open, open, reset], payments: [accepted, unparseable, unparseable], receipt: [() => Response.json(null)] });
+    await client.pay(invoiceFor(OTHER), OTHER);
+    await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    expect(state()?.sequence).toBe("1");
+    expect(state()?.entries).toHaveLength(1);
+    const error = await client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+    expect(error.message).toMatch(/the epoch it was signed for has closed or is no longer the live one/);
+    expect(state()?.pending).toBeUndefined();
+    expect(state()).toMatchObject({ entries: [], sequence: "0" });
+    expect(state()?.epoch).toBeUndefined();
+  });
+
+  it("releases a held payment once the service has moved past its epoch, without the chain having admitted it", async () => {
+    const unparseable = () => Response.json({ error: "malformed payment" }, { status: 400 });
+    const later = () => open("2");
+    const { client, state } = wallet({ context: [open, later], payments: [unparseable, unparseable], receipt: [() => Response.json(null)] });
+    await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    const error = await client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+    expect(error.message).toMatch(/is released/);
+    expect(state()?.pending).toBeUndefined();
+  });
+
+  it("does not release a held payment on a null receipt from a service that is not this wallet's deployment", async () => {
+    const unparseable = () => Response.json({ error: "malformed payment" }, { status: 400 });
+    const other = () =>
+      Response.json({ reference: CLEARING_REFERENCE, network: NETWORK, settlement: ASSET, asset: ASSET, operator: operator.publicKey, epoch: "1", anchor: ANCHOR });
+    const { client, state } = wallet({ context: [open, other], payments: [unparseable, unparseable], receipt: [() => Response.json(null)] });
+    await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    chain.admitted = 2n;
+    try {
+      expect((await refusal(client.pay(invoiceFor(CHUNK), CHUNK))).reason).toBe("answer_lost");
+      expect(state()?.pending?.invoice).toEqual(invoiceFor(CHUNK));
+    } finally {
+      chain.admitted = 1n;
+    }
+  });
+
+  it("reads the service's epoch and the chain before it reads the receipt, and asks for the receipt of the payment's own epoch", async () => {
+    const unparseable = () => Response.json({ error: "malformed payment" }, { status: 400 });
+    const { client, asked } = wallet({ payments: [unparseable, unparseable], receipt: [() => Response.json(null)] });
+    await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    asked.length = 0;
+    await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    const receipt = asked.findIndex((path) => path.startsWith("/receipt/"));
+    expect(asked.indexOf("/context")).toBeGreaterThanOrEqual(0);
+    expect(asked.indexOf("/context")).toBeLessThan(receipt);
+    expect(asked[receipt]).toMatch(/\?epoch=1$/);
+  });
+
+  it("does not settle a sent-again payment from a verifying receipt for another payment: another body, another payer signature or another invoice", async () => {
+    const send = "_COMMONWARE_CLEARING_VECTOR_SEND";
+    const ack = "_COMMONWARE_CLEARING_VECTOR_ACK";
+    // Receipts every check but the comparison with the held payment accepts: the payer and the operator both signed them.
+    const receipts = [
+      // Another body: the payer's next payment in the epoch.
+      (paid: ClearingPayment) => {
+        const body = encodeSend({ anchor: ANCHOR, epoch: 1n, payer: payer.publicKey, sequence: 9n, debit: 1n, vector: ZERO32 });
+        return { invoice: paid.invoice, body, payerSignature: payer.sign(send, body) };
+      },
+      // The same body under another valid payer signature.
+      (paid: ClearingPayment) => {
+        const other = toHex(
+          p256.sign(hexToBytes(clearingSignatureDigest(send, paid.body)), hexToBytes(`0x${"12".repeat(32)}`), { lowS: true, prehash: false, extraEntropy: true }).toCompactRawBytes(),
+        );
+        expect(other).not.toBe(paid.payerSignature);
+        return { invoice: paid.invoice, body: paid.body, payerSignature: other };
+      },
+      // Another invoice under the same body.
+      (paid: ClearingPayment) => ({ invoice: { ...paid.invoice, amount: (BigInt(paid.invoice.amount) + UNIT).toString() }, body: paid.body, payerSignature: paid.payerSignature }),
+    ];
+    for (const receipt of receipts) {
+      const w: ReturnType<typeof wallet> = wallet({
+        payments: [lost, busy],
+        receipt: [
+          () => {
+            const original = w.posted[0]!;
+            const { invoice, body, payerSignature } = receipt(original);
+            return Response.json({ invoice, receipt: { body, payerSignature, operatorSignature: operator.sign(ack, body) }, invoiceSignature: original.invoiceSignature, entries: original.entries });
+          },
+        ],
+      });
+      await refusal(w.client.pay(invoiceFor(CHUNK), CHUNK));
+      const error = await refusal(w.client.pay(invoiceFor(CHUNK), CHUNK));
+      expect(error.message).toMatch(/does not verify/);
+      expect(w.posted).toHaveLength(2);
+      expect(w.state()?.pending?.invoice).toEqual(invoiceFor(CHUNK));
+    }
+  });
+
+  it("holds a payment whose epoch has closed when the service cannot say whether it has a receipt", async () => {
+    const unparseable = () => Response.json({ error: "malformed payment" }, { status: 400 });
+    const { client, state } = wallet({ payments: [unparseable, unparseable], receipt: [busy] });
+    await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    chain.admitted = 2n;
+    try {
+      expect((await refusal(client.pay(invoiceFor(CHUNK), CHUNK))).reason).toBe("answer_lost");
+      expect(state()?.pending?.invoice).toEqual(invoiceFor(CHUNK));
+    } finally {
+      chain.admitted = 1n;
+    }
+  });
+
+  it("settles a sent-again payment from the receipt the service retained, paid once", async () => {
+    const w: ReturnType<typeof wallet> = wallet({ payments: [lost, busy], receipt: [() => accepted(w.posted[0]!)] });
+    await refusal(w.client.pay(invoiceFor(CHUNK), CHUNK));
+    const paid = await w.client.pay(invoiceFor(CHUNK), CHUNK);
+    expect(paid.invoice).toEqual(invoiceFor(CHUNK));
+    expect(w.posted).toHaveLength(2);
+    expect(w.state()?.pending).toBeUndefined();
+    expect(w.state()?.payments[invoiceFor(CHUNK).id]).toBeDefined();
+  });
+
+  it("does not settle a sent-again payment from a receipt the operator did not sign", async () => {
+    const forged = () =>
+      Response.json({
+        invoice: invoiceFor(CHUNK),
+        receipt: { body: w.posted[0]!.body, payerSignature: w.posted[0]!.payerSignature, operatorSignature: seller.sign("_COMMONWARE_CLEARING_VECTOR_ACK", w.posted[0]!.body) },
+        invoiceSignature: w.posted[0]!.invoiceSignature,
+        entries: w.posted[0]!.entries,
+      });
+    const w: ReturnType<typeof wallet> = wallet({ payments: [lost, busy], receipt: [forged] });
+    await refusal(w.client.pay(invoiceFor(CHUNK), CHUNK));
+    const error = await refusal(w.client.pay(invoiceFor(CHUNK), CHUNK));
+    expect(error.message).toMatch(/does not verify/);
+    expect(w.state()?.pending?.invoice).toEqual(invoiceFor(CHUNK));
+  });
+
+  it("takes the most recipients one payment's vector holds, and refuses a 1025th before signing it, as the service's parser would refuse the vector", async () => {
+    // A wallet that has paid `count` recipients this epoch, the first of them the seller.
+    const crowded = (count: number) => {
+      let saved: ClearingClientState | null = {
+        epoch: "1",
+        sequence: "0",
+        payments: {},
+        entries: Array.from({ length: count }, (_, i) => ({
+          recipient: i === 0 ? seller.publicKey : createClearingSigner(`0x${(i + 1).toString(16).padStart(64, "0")}`).publicKey,
+          cumulative: "1",
+          count: "1",
+        })),
+      };
+      const posted: ClearingPayment[] = [];
+      const client = createClearingClient({
+        serviceUrl: SERVICE_URL,
+        rpcUrl,
+        network: NETWORK,
+        settlement: SETTLEMENT,
+        asset: ASSET,
+        signer: payer,
+        maxAmount: 1000n * UNIT,
+        store: { load: async () => structuredClone(saved), save: async (value) => void (saved = structuredClone(value)) },
+        fetch: async (input, init) => {
+          if (new URL(String(input)).pathname === "/context") return open();
+          const payment = JSON.parse(String(init?.body)) as ClearingPayment;
+          posted.push(payment);
+          return accepted(payment);
+        },
+      });
+      const toNew = () => {
+        const requirements = clearingRequirements({ network: NETWORK, asset: ASSET, settlement: SETTLEMENT, recipient: createClearingSigner(`0x${"77".repeat(32)}`).publicKey, serviceUrl: SERVICE_URL }, 5n * UNIT, OTHER);
+        return clearingInvoice(requirements, `${requirements.extra!.invoicePrefix}:new`);
+      };
+      return { client, posted, saved: () => saved, toNew };
+    };
+    // 1023 recipients and a new one is the 1024th; 1024 and one of them again stays 1024.
+    const room = crowded(1023);
+    await room.client.pay(room.toNew(), OTHER);
+    expect(room.posted).toHaveLength(1);
+    const repeat = crowded(1024);
+    await repeat.client.pay(invoiceFor(CHUNK), CHUNK);
+    expect(repeat.posted).toHaveLength(1);
+    // 1024 and a new one is the 1025th.
+    const full = crowded(1024);
+    const error = await full.client.pay(full.toNew(), OTHER).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+    expect(error.message).toMatch(/has paid 1024 recipients in epoch 1, the most one payment's vector holds; nothing was paid and nothing is held: send the request again after the next epoch/);
+    expect(full.posted).toHaveLength(0);
+    expect(full.saved()?.pending).toBeUndefined();
+  });
+
+  it("names the hold when the held payment is refused because the wallet's maxAmount was lowered", async () => {
+    let saved: ClearingClientState | null = null;
+    const store = { load: async () => structuredClone(saved), save: async (value: ClearingClientState) => void (saved = structuredClone(value)) };
+    const over = (maxAmount: bigint) =>
+      createClearingClient({
+        serviceUrl: SERVICE_URL,
+        rpcUrl,
+        network: NETWORK,
+        settlement: SETTLEMENT,
+        asset: ASSET,
+        signer: payer,
+        maxAmount,
+        store,
+        fetch: async (input) => (new URL(String(input)).pathname === "/context" ? open() : lost()),
+      });
+    await refusal(over(1000n * UNIT).pay(invoiceFor(CHUNK), CHUNK));
+    const error = await over(1n * UNIT).pay((await over(1n * UNIT).pendingInvoice())!).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+    expect(error.message).toMatch(/is above this wallet's maxAmount.*the wallet holds this payment and pays nothing else until it goes through: raise the wallet's maxAmount to send it/);
+  });
+
+  it("a payment held for another deployment can never go through here: the error names a new wallet and recovery on the old deployment", async () => {
+    let saved: ClearingClientState | null = null;
+    const store = { load: async () => structuredClone(saved), save: async (value: ClearingClientState) => void (saved = structuredClone(value)) };
+    const over = (settlement: Hex, answers: ((payment: ClearingPayment) => Response)[]) =>
+      createClearingClient({
+        serviceUrl: SERVICE_URL,
+        rpcUrl,
+        network: NETWORK,
+        settlement,
+        asset: ASSET,
+        signer: payer,
+        maxAmount: 1000n * UNIT,
+        store,
+        fetch: async (input) => {
+          const path = new URL(String(input)).pathname;
+          if (path === "/context") return Response.json({ reference: CLEARING_REFERENCE, network: NETWORK, settlement, asset: ASSET, operator: operator.publicKey, epoch: "1", anchor: ANCHOR });
+          return answers.shift()!({} as ClearingPayment);
+        },
+      });
+    await refusal(over(SETTLEMENT, [lost]).pay(invoiceFor(CHUNK), CHUNK));
+    const REPLACEMENT = `0x${"44".repeat(20)}` as const;
+    const replacement = over(REPLACEMENT, []);
+    const held = (await replacement.pendingInvoice())!;
+    const requirements = clearingRequirements({ network: NETWORK, asset: ASSET, settlement: REPLACEMENT, recipient: seller.publicKey, serviceUrl: SERVICE_URL }, 5n * UNIT, OTHER);
+    const fresh = clearingInvoice(requirements, `${requirements.extra!.invoicePrefix}:2`);
+    // The held payment itself, and a new one for the replacement deployment.
+    for (const attempt of [() => replacement.pay(held), () => replacement.pay(fresh, OTHER)]) {
+      const error = await attempt().then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+      expect(error).not.toBeInstanceOf(ClearingRefusal);
+      expect(error.message).toMatch(/holds a payment for deployment 0x2222222222222222222222222222222222222222, which this wallet cannot send to 0x4444444444444444444444444444444444444444/);
+      expect(error.message).toMatch(/withdrawFromClearing, or recoverFromClearing once it has faulted/);
+      expect(error.message).toMatch(/new wallet/);
+      expect(error.message).not.toMatch(/pendingInvoice\(\)/);
+    }
+  });
+
+  it("a /context that answers 404 or 403 is a service URL that is not the clearing service, not a request to send again", async () => {
+    for (const status of [401, 403, 404]) {
+      const { client, posted } = wallet({ context: [() => new Response(null, { status })] });
+      const error = await client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+      expect(error.message).toMatch(new RegExp(`${status} for /context`));
+      expect(error.message).toMatch(/serviceUrl is not the clearing service/);
+      expect(error.message).toMatch(/nothing was paid and nothing is held/);
+      expect(error.message).not.toMatch(/send the request again/);
+      expect(posted).toHaveLength(0);
+    }
+  });
+
+  it("a failed balance read while the epoch is open is not between epochs", async () => {
+    const { client, state } = wallet({ context: [open, open], payments: [rejected], spendable: [betweenEpochs] });
+    const error = await client.pay(invoiceFor(CHUNK), CHUNK).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+    expect(error).not.toBeInstanceOf(ClearingRefusal);
+    expect(error.message).toMatch(/reading why failed/);
+    expect(state()?.pending).toBeUndefined();
+  });
+
+  it("a 200 that is not a receipt holds the payment, as an acknowledgment that does not verify", async () => {
+    for (const answer of [() => Response.json({}), () => Response.json(null), () => Response.json({ receipt: {} })]) {
+      const { client, state } = wallet({ payments: [answer] });
+      const error = await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+      expect(error.reason).toBe("answer_lost");
+      expect(error.message).toMatch(/does not verify/);
+      expect(state()?.pending?.invoice).toEqual(invoiceFor(CHUNK));
+    }
+  });
+
+  it("payment held: another request while one is held names the held request's URL and price, and sends nothing", async () => {
+    const { client, posted } = wallet({ payments: [lost] });
+    await refusal(client.pay(invoiceFor(CHUNK), CHUNK));
+    const error = await refusal(client.pay(invoiceFor(OTHER, 7n * UNIT), OTHER));
+    expect(error.reason).toBe("payment_held");
+    expect(error.retry).toEqual({ action: "repeat_same_request", url: CHUNK, amount: (5n * UNIT).toString(), ms: 3000 });
+    expect(error.message).toContain(CHUNK);
+    expect(error.message).toMatch(/send that request again after 3000 ms/);
+    expect(posted).toHaveLength(1);
+    // The same URL at another price is another payment, held off the same way.
+    const repriced = await refusal(client.pay(invoiceFor(CHUNK, 6n * UNIT), CHUNK));
+    expect(repriced.reason).toBe("payment_held");
+    // The way out when the URL no longer offers that price: the held payment itself, sent once more.
+    expect(repriced.message).toContain("pass the wallet's pendingInvoice() to its pay");
+    await client.pay((await client.pendingInvoice())!);
+    expect(posted).toHaveLength(2);
+    expect(posted[1]).toEqual(posted[0]);
+    expect(await client.pendingInvoice()).toBeNull();
+  });
+});
+
+describe("registerClearingClient", () => {
+  it("refuses a request for another URL while a payment is held, naming the held one, then pays the held one once", async () => {
+    const { client: clearing, posted } = wallet({ payments: [lost] });
+    const client = registerClearingClient(new x402Client().setSpendControls({ allowedAssets: true }), NETWORK, clearing);
+    const required = (url: string) => ({ x402Version: 2, resource: { url }, accepts: [offer(url)] });
+    const lostAnswer = await refusal(client.createPaymentPayload(required(CHUNK)));
+    expect(lostAnswer).toMatchObject({ reason: "answer_lost", retry: { action: "repeat_same_request", url: CHUNK } });
+    // The builders' `invalid clearing requirement`.
+    const held = await refusal(client.createPaymentPayload(required(OTHER)));
+    expect(held).toMatchObject({ reason: "payment_held", retry: { action: "repeat_same_request", url: CHUNK, amount: (5n * UNIT).toString() } });
+    await client.createPaymentPayload(required(CHUNK));
+    expect(posted).toHaveLength(2);
+    expect(posted[1]).toEqual(posted[0]);
+  });
+
+  it("names the URL the payer fetched, not the seller's name for it, behind a TLS-terminating proxy", async () => {
+    // The seller's listener sees plain http, so its offer names http://.
+    const declared = "http://seller.test/chunk/1";
+    const fetched = "https://seller.test/chunk/1";
+    const sent: string[] = [];
+    const seller = async (input: RequestInfo | URL, init?: RequestInit) => {
+      const signature = new Request(input, init).headers.get("PAYMENT-SIGNATURE");
+      if (signature) return sent.push(signature), new Response("chunk");
+      return new Response(null, {
+        status: 402,
+        headers: { "PAYMENT-REQUIRED": encodePaymentRequiredHeader({ x402Version: 2, resource: { url: declared }, accepts: [offer(declared)] }) },
+      });
+    };
+    const { client: clearing } = wallet({ payments: [lost] });
+    const { client, fetchWithPayment } = createMetalPaymentClient({ account: privateKeyToAccount(`0x${"45".repeat(32)}`), network: "devnet", fetch: seller });
+    registerClearingClient(client, NETWORK, clearing);
+    const error = await fetchWithPayment(fetched).then(() => expect.unreachable("the payment went through"), (e: Error) => e);
+    expect(error.cause).toBeInstanceOf(ClearingRefusal);
+    expect((error.cause as ClearingRefusal).retry).toMatchObject({ action: "repeat_same_request", url: fetched });
+    expect(error.message).toContain(fetched);
+    // The payment the seller receives names the resource as the seller did.
+    expect((await fetchWithPayment(fetched)).status).toBe(200);
+    expect(JSON.parse(atob(sent[0]!)).resource).toEqual({ url: declared });
+  });
+
+  const TESTNET = "eip155:63825";
+  const BASE = "eip155:8453";
+  /** A clearing wallet that pays any offer on `network`. */
+  const payingOn = (network: string) => ({
+    pendingInvoice: async () => null,
+    unpayable: (invoice: { network: string }) => (invoice.network === network ? undefined : { reason: "offer is for another network", aboveMaxAmount: false }),
+    pay: async (invoice: unknown) => ({ invoice }) as ClearingPaid,
+  });
+  const on = (network: string, scheme = "bajillion"): PaymentRequirements => ({ ...offer(CHUNK), network: network as `${string}:${string}`, scheme });
+  const exact = { scheme: "exact", createPaymentPayload: async (x402Version: number) => ({ x402Version, payload: {} }) };
+  const chosen = async (client: x402Client, accepts: PaymentRequirements[]) =>
+    (await client.createPaymentPayload({ x402Version: 2, resource: { url: CHUNK }, accepts })).accepted;
+
+  it("two registrations on one client: each pays its own network's requests and leaves the other's untouched", async () => {
+    const client = new x402Client().setSpendControls({ allowedAssets: true });
+    registerClearingClient(client, NETWORK, payingOn(NETWORK));
+    registerClearingClient(client, TESTNET, payingOn(TESTNET));
+    expect((await chosen(client, [on(NETWORK)])).network).toBe(NETWORK);
+    expect((await chosen(client, [on(TESTNET)])).network).toBe(TESTNET);
+    expect([NETWORK, TESTNET]).toContain((await chosen(client, [on(NETWORK), on(TESTNET)])).network);
+  });
+
+  it("a request with no offer on the registration's network goes to the client's other schemes; one on it with no clearing offer still fails", async () => {
+    const client = new x402Client().setSpendControls({ allowedAssets: true });
+    client.register(BASE, exact);
+    client.register(NETWORK, exact);
+    registerClearingClient(client, NETWORK, payingOn(NETWORK));
+    expect(await chosen(client, [on(BASE, "exact")])).toMatchObject({ network: BASE, scheme: "exact" });
+    await expect(chosen(client, [on(NETWORK, "exact")])).rejects.toThrow(/offers no clearing payment on eip155:1337/);
+  });
+
+  it("names what is wrong with a clearing offer it cannot pay: its price, its form, or its deployment and limit", async () => {
+    const client = registerClearingClient(new x402Client().setSpendControls({ allowedAssets: true }), NETWORK, wallet().client);
+    const refused = (accepts: PaymentRequirements[]) => chosen(client, accepts).then(() => expect.unreachable("the offer was paid"), (e: Error) => e.message);
+    expect(await refused([{ ...on(NETWORK), amount: "0" }])).toMatch(/\(offer is priced at "0", not a positive whole number of base units\), and paying by exact is off/);
+    expect(await refused([{ ...on(NETWORK), amount: "1.5" }])).toMatch(/\(offer is priced at "1.5", not a positive whole number of base units\)/);
+    // A leading zero passes /^[0-9]+$/ and BigInt(); the service's canonical() rejects it as malformed.
+    expect(await refused([{ ...on(NETWORK), amount: "05000000000000" }])).toMatch(/\(offer of 05000000000000 base units is not a positive whole number in canonical form\)/);
+    expect(await refused([{ ...on(NETWORK), payTo: "0x1234" }])).toMatch(/\(offer is malformed \(invalid clearing requirement\)\)/);
+    expect(await refused([{ ...on(NETWORK), extra: { ...on(NETWORK).extra, settlement: ASSET } }])).toContain(
+      `(offer is for deployment ${ASSET}, not this wallet's ${SETTLEMENT}), and paying by exact is off; nothing was paid: pass exactFallback: true`,
+    );
+    expect(await refused([{ ...on(NETWORK), asset: SETTLEMENT }])).toContain(`(offer is for asset ${SETTLEMENT}, not this wallet's ${ASSET})`);
+  });
+
+  it("refuses a leading-zero amount before signing, so nothing is sent for the service to refuse as malformed", async () => {
+    const { client: clearing, posted } = wallet();
+    const client = registerClearingClient(new x402Client().setSpendControls({ allowedAssets: true }), NETWORK, clearing);
+    const leadingZero = { ...on(NETWORK), amount: "05000000000000" };
+    await expect(chosen(client, [leadingZero])).rejects.toThrow(/not a positive whole number in canonical form/);
+    expect(posted).toHaveLength(0);
+  });
+
+  it("names a clearing offer above the wallet's maxAmount with both amounts, and says to raise it or pay another seller, not to pay by exact", async () => {
+    // k12-backend's probe: a 0.50 *USDZ offer to a wallet whose maxAmount is 0.30 *USDZ.
+    const client = registerClearingClient(new x402Client().setSpendControls({ allowedAssets: true }), NETWORK, wallet({}, 300_000n * UNIT).client);
+    const refused = (accepts: PaymentRequirements[]) => chosen(client, accepts).then(() => expect.unreachable("the offer was paid"), (e: Error) => e.message);
+    const over = { ...on(NETWORK), amount: String(500_000n * UNIT) };
+    expect(await refused([over])).toBe(
+      "this clearing wallet pays none of the clearing offers here (offer 0.5 *USDZ is above this wallet's maxAmount 0.3 *USDZ); nothing was paid: raise the wallet's maxAmount or pay another seller",
+    );
+    // Beside an offer for another deployment, the one for the wallet's own decides the advice.
+    const elsewhere = { ...on(NETWORK), extra: { ...on(NETWORK).extra, settlement: ASSET } };
+    const both = await refused([elsewhere, over]);
+    expect(both).toContain(`(offer is for deployment ${ASSET}, not this wallet's ${SETTLEMENT}; offer 0.5 *USDZ is above this wallet's maxAmount 0.3 *USDZ)`);
+    expect(both).not.toContain("exactFallback");
+    expect(await refused([elsewhere])).toContain("pass exactFallback: true");
+  });
+
+  it("falls back to exact when the clearing offer it refuses is listed first and carries no paymentFlow", async () => {
+    // A seller's own 402, built with the exported clearingRequirements() rather than ClearingServerScheme,
+    // lists clearing before exact; the stock selector would otherwise pick the clearing offer again.
+    const neverPays = {
+      pendingInvoice: async () => null,
+      unpayable: () => ({ reason: "offer is for another deployment, not this wallet's", aboveMaxAmount: false }),
+      pay: async () => expect.unreachable("a refused clearing offer was signed"),
+    };
+    const client = new x402Client().setSpendControls({ allowedAssets: true });
+    client.register(NETWORK, exact);
+    registerClearingClient(client, NETWORK, neverPays, { exactFallback: true });
+    expect(await chosen(client, [on(NETWORK), on(NETWORK, "exact")])).toMatchObject({ network: NETWORK, scheme: "exact" });
+  });
+
+  it("with exactFallback, an exact offer on another network is not a way to pay a request whose offers on this network are all refused clearing offers", async () => {
+    const neverPays = {
+      pendingInvoice: async () => null,
+      unpayable: () => ({ reason: "offer is for another deployment, not this wallet's", aboveMaxAmount: false }),
+      pay: async () => expect.unreachable("a refused clearing offer was signed"),
+    };
+    const client = new x402Client().setSpendControls({ allowedAssets: true });
+    client.register(NETWORK, exact);
+    client.register(BASE, exact);
+    registerClearingClient(client, NETWORK, neverPays, { exactFallback: true });
+    await expect(chosen(client, [on(NETWORK), on(BASE, "exact")])).rejects.toThrow(/this request offers no other way to pay it; nothing was paid/);
+  });
+
+  it("without exactFallback, still throws naming the refused clearing offers even when an exact one is also listed", async () => {
+    const neverPays = {
+      pendingInvoice: async () => null,
+      unpayable: () => ({ reason: "offer is for another deployment, not this wallet's", aboveMaxAmount: false }),
+      pay: async () => expect.unreachable("a refused clearing offer was signed"),
+    };
+    const client = new x402Client().setSpendControls({ allowedAssets: true });
+    client.register(NETWORK, exact);
+    registerClearingClient(client, NETWORK, neverPays);
+    await expect(chosen(client, [on(NETWORK), on(NETWORK, "exact")])).rejects.toThrow(/paying by exact is off/);
+  });
+});
+
+function listen(server: Server): Promise<string> {
+  return new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => {
+      const address = server.address();
+      if (!address || typeof address === "string") return reject(new Error("no port"));
+      resolve(`http://127.0.0.1:${address.port}`);
+    });
+  });
+}