xytara 3.1.13 → 3.1.15

package/scripts/verify_x402_settlement_recovery.js

@@ -0,0 +1,153 @@
+"use strict";
+
+// End-to-end check (real local server, mock facilitator + mock chain RPC) that a facilitator settle
+// timeout never leaves a buyer charged with nothing:
+//  - settle times out but the authorization IS used on-chain -> the result is delivered;
+//  - settle times out and the chain does not show it yet -> held, and resending the SAME payment
+//    delivers once the chain confirms (no second settle, no re-execution);
+//  - a normally settled payment resent -> the stored result is returned (replayed), not re-run;
+//  - the same payment resent for a DIFFERENT request -> refused (on-chain data can't fetch results).
+
+const assert = require("assert");
+const http = require("http");
+const { AUTHORIZATION_STATE_SELECTOR } = require("../lib/x402_settlement_recovery");
+
+const PAYER = "0x1111111111111111111111111111111111111111";
+const ACCEPTS = [{
+  scheme: "exact",
+  network: "eip155:84532",
+  asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  amount: "1000",
+  payTo: "0x7cd2E0Ed2721319B20FAac4109774d030833F84D",
+  extra: { name: "USDC", version: "2" },
+  maxTimeoutSeconds: 60
+}];
+
+function listen(handler) {
+  const server = http.createServer((req, res) => {
+    const chunks = [];
+    req.on("data", (chunk) => chunks.push(chunk));
+    req.on("end", () => {
+      let body = {};
+      try { body = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}"); } catch (_) { body = {}; }
+      handler(req, res, body);
+    });
+  });
+  return new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve({ server, port: server.address().port })));
+}
+
+function reply(res, payload) {
+  const text = JSON.stringify(payload);
+  res.writeHead(200, { "content-type": "application/json", "content-length": Buffer.byteLength(text) });
+  res.end(text);
+}
+
+function paymentHeader(signature, nonceByte) {
+  return Buffer.from(JSON.stringify({
+    x402Version: 2,
+    accepted: ACCEPTS[0],
+    payload: {
+      signature,
+      authorization: { from: PAYER, to: ACCEPTS[0].payTo, value: "1000", validAfter: "0", validBefore: String(Math.floor(Date.now() / 1000) + 600), nonce: `0x${nonceByte.repeat(32)}` }
+    }
+  })).toString("base64");
+}
+
+async function post(baseUrl, body, header) {
+  const res = await fetch(`${baseUrl}/x402/commands/execute`, {
+    method: "POST",
+    headers: { "content-type": "application/json", "payment-signature": header },
+    body: JSON.stringify(body)
+  });
+  let json = null;
+  try { json = await res.json(); } catch (_) { json = null; }
+  return { status: res.status, json };
+}
+
+async function main() {
+  const calls = { settle: 0, rpc: 0 };
+  // Facilitator: verify always ok; settle hangs for signatures marked "hang", succeeds otherwise.
+  const facilitator = await listen((req, res, body) => {
+    const sig = String((body.paymentPayload && body.paymentPayload.payload && body.paymentPayload.payload.signature) || "");
+    if (req.url === "/verify") return reply(res, { isValid: true, payer: PAYER });
+    if (req.url === "/settle") {
+      calls.settle += 1;
+      if (sig.startsWith("hang")) return; // never answers: the client times out
+      return reply(res, { success: true, transaction: "0xmocktx", network: ACCEPTS[0].network, payer: PAYER });
+    }
+    res.writeHead(404); res.end();
+  });
+  // Chain RPC: authorizationState(PAYER, nonce) -> used for nonces in usedNonces.
+  const usedNonces = new Set();
+  const rpc = await listen((req, res, body) => {
+    calls.rpc += 1;
+    const data = String((body.params && body.params[0] && body.params[0].data) || "");
+    assert.ok(data.startsWith(AUTHORIZATION_STATE_SELECTOR), "RPC asked for authorizationState");
+    const nonce = `0x${data.slice(-64)}`;
+    reply(res, { jsonrpc: "2.0", id: body.id, result: `0x${(usedNonces.has(nonce) ? 1 : 0).toString(16).padStart(64, "0")}` });
+  });
+
+  const keys = ["XYTARA_PAYMENT_VERIFICATION_MODE", "XYTARA_X402_ACCEPTS_JSON", "XYTARA_X402_FACILITATOR_URL", "XYTARA_X402_FACILITATOR_TIMEOUT_MS", "XYTARA_RPC_URL_EIP155_84532"];
+  const previous = Object.fromEntries(keys.map((key) => [key, process.env[key]]));
+  process.env.XYTARA_PAYMENT_VERIFICATION_MODE = "x402_facilitator";
+  process.env.XYTARA_X402_ACCEPTS_JSON = JSON.stringify(ACCEPTS);
+  process.env.XYTARA_X402_FACILITATOR_URL = `http://127.0.0.1:${facilitator.port}`;
+  process.env.XYTARA_X402_FACILITATOR_TIMEOUT_MS = "1000";
+  process.env.XYTARA_RPC_URL_EIP155_84532 = `http://127.0.0.1:${rpc.port}`;
+
+  delete require.cache[require.resolve("../server")];
+  const { createServer } = require("../server");
+  const server = createServer();
+  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+  const baseUrl = `http://127.0.0.1:${server.address().port}`;
+  const job = { account_id: "acct_recovery", task_ref: "trust.verify", body: { subject_id: "s-1" } };
+  try {
+    // A. Settle times out, but the chain shows the authorization used -> delivered.
+    usedNonces.add(`0x${"a1".repeat(32)}`);
+    const recovered = await post(baseUrl, job, paymentHeader("hang-a", "a1"));
+    assert.strictEqual(recovered.status, 200, "a settled-on-chain payment must deliver despite the facilitator timeout");
+    assert.ok(recovered.json.delivery_receipt || recovered.json.command || recovered.json.ok, "the result is delivered");
+
+    // B. Settle times out and the chain does not show it (yet) -> held, never "pay again".
+    const held = await post(baseUrl, job, paymentHeader("hang-b", "b2"));
+    assert.strictEqual(held.status, 502);
+    assert.strictEqual(held.json.reason, "settlement_not_confirmed");
+    assert.ok(/SAME payment signature/.test(held.json.detail), "the buyer is told to resend the same payment, not a new one");
+    // The transfer lands later; resending the same payment delivers the held result.
+    usedNonces.add(`0x${"b2".repeat(32)}`);
+    const settleCallsBefore = calls.settle;
+    const delivered = await post(baseUrl, job, paymentHeader("hang-b", "b2"));
+    assert.strictEqual(delivered.status, 200, "resending the same payment delivers once it is on-chain");
+    assert.strictEqual(delivered.json.replayed, true);
+    assert.strictEqual(calls.settle, settleCallsBefore, "no second settlement attempt");
+
+    // C. The same payment resent for a different request -> refused.
+    const other = await post(baseUrl, { ...job, body: { subject_id: "someone-else" } }, paymentHeader("hang-b", "b2"));
+    assert.strictEqual(other.status, 409);
+    assert.strictEqual(other.json.reason, "payment_already_used");
+
+    // D. Normal settle, then a resend (e.g. the buyer lost the response) -> stored result, no re-run.
+    const first = await post(baseUrl, job, paymentHeader("ok-d", "d4"));
+    assert.strictEqual(first.status, 200);
+    const settles = calls.settle;
+    const again = await post(baseUrl, job, paymentHeader("ok-d", "d4"));
+    assert.strictEqual(again.status, 200);
+    assert.strictEqual(again.json.replayed, true, "a resent settled payment returns the stored result");
+    assert.strictEqual(calls.settle, settles, "and is not settled again");
+
+    console.log("xytara verify:x402-settlement-recovery passed");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+    facilitator.server.closeAllConnections && facilitator.server.closeAllConnections();
+    await new Promise((resolve) => facilitator.server.close(resolve));
+    await new Promise((resolve) => rpc.server.close(resolve));
+    for (const key of keys) {
+      if (previous[key] === undefined) delete process.env[key]; else process.env[key] = previous[key];
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});