xytara 3.1.13 → 3.1.15

package/scripts/verify_verify_execute_settle.js

@@ -1,208 +1,209 @@
-"use strict";
-
-// Verifies the don't-charge-on-failure guarantee for the x402 command path:
-//   - when external execution FAILS, the deferred x402 settlement is NEVER called
-//     (the facilitator /settle is not hit), the response is a non-2xx carrying
-//     payment_settled:false and a "you were not charged" remediation, and no
-//     PAYMENT-RESPONSE receipt is emitted;
-//   - when external execution SUCCEEDS, settlement runs exactly once AFTER the work,
-//     the response is 200 with the real tool output surfaced and a PAYMENT-RESPONSE
-//     receipt attached.
-//
-// This is the verify -> execute -> settle reorder: an x402 authorization is verified
-// up front but only settled once the deliverable is produced, so a failed call costs
-// the paying agent nothing. No real network or chain is used.
-
-const assert = require("assert");
-const http = require("http");
-
-const ACCEPTS = [
-  {
-    scheme: "exact",
-    network: "eip155:84532",
-    asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
-    amount: "1000",
-    payTo: "0x7cd2E0Ed2721319B20FAac4109774d030833F84D",
-    extra: { name: "USDC", version: "2" },
-    maxTimeoutSeconds: 60
-  }
-];
-
-// One mock server stands in for BOTH the x402 facilitator (/verify, /settle) and the
-// external execution target (/exec-ok succeeds, /exec-fail rejects with a 502).
-function startMockServer() {
-  const calls = { verify: 0, settle: 0, execOk: 0, execFail: 0 };
-  const server = http.createServer((req, res) => {
-    const chunks = [];
-    req.on("data", (c) => chunks.push(c));
-    req.on("end", () => {
-      let body = {};
-      try { body = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}"); } catch (_) { body = {}; }
-      const reply = (payload, status) => {
-        const text = JSON.stringify(payload);
-        res.writeHead(status || 200, { "content-type": "application/json", "content-length": Buffer.byteLength(text) });
-        res.end(text);
-      };
-      if (req.method === "POST" && req.url === "/verify") {
-        calls.verify += 1;
-        return reply({ isValid: true, payer: "0x1111111111111111111111111111111111111111" });
-      }
-      if (req.method === "POST" && req.url === "/settle") {
-        calls.settle += 1;
-        const sig = body && body.paymentPayload && body.paymentPayload.payload ? String(body.paymentPayload.payload.signature || "") : "";
-        if (sig === "settle-fails") return reply({ success: false, errorReason: "insufficient_funds" });
-        return reply({ success: true, transaction: "0xmocktx", network: "eip155:84532", payer: "0x1111111111111111111111111111111111111111" });
-      }
-      if (req.method === "POST" && req.url === "/exec-ok") {
-        calls.execOk += 1;
-        return reply({ ok: true, status: "completed", output: { value: "0xdeadbeef" } });
-      }
-      if (req.method === "POST" && req.url === "/exec-fail") {
-        calls.execFail += 1;
-        return reply({ ok: false, reason: "data_required" }, 502);
-      }
-      res.writeHead(404); res.end();
-    });
-  });
-  return new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve({ server, calls, port: server.address().port })));
-}
-
-function paymentHeader(signature) {
-  const accepted = ACCEPTS[0];
-  return Buffer.from(JSON.stringify({
-    x402Version: 2,
-    accepted,
-    payload: {
-      signature,
-      authorization: {
-        from: "0x1111111111111111111111111111111111111111",
-        to: accepted.payTo,
-        value: accepted.amount,
-        validAfter: "0",
-        validBefore: String(Math.floor(Date.now() / 1000) + 600),
-        nonce: `0x${"ab".repeat(32)}`
-      }
-    }
-  }), "utf8").toString("base64");
-}
-
-async function post(baseUrl, path, body, headers = {}) {
-  const res = await fetch(`${baseUrl}${path}`, {
-    method: "POST",
-    headers: { "content-type": "application/json", ...headers },
-    body: JSON.stringify(body)
-  });
-  let json = null;
-  try { json = await res.json(); } catch (_) { json = null; }
-  return { status: res.status, json, headers: res.headers };
-}
-
-async function main() {
-  const mock = await startMockServer();
-  const mockBase = `http://127.0.0.1:${mock.port}`;
-  const previous = {
-    mode: process.env.XYTARA_PAYMENT_VERIFICATION_MODE,
-    accepts: process.env.XYTARA_X402_ACCEPTS_JSON,
-    facUrl: process.env.XYTARA_X402_FACILITATOR_URL,
-    targets: process.env.XYTARA_EXECUTION_TARGETS_JSON
-  };
-  process.env.XYTARA_PAYMENT_VERIFICATION_MODE = "x402_facilitator";
-  process.env.XYTARA_X402_ACCEPTS_JSON = JSON.stringify(ACCEPTS);
-  process.env.XYTARA_X402_FACILITATOR_URL = mockBase;
-  process.env.XYTARA_EXECUTION_TARGETS_JSON = JSON.stringify([
-    { target_id: "exec_ok", task_ref: "exec.ok", endpoint_url: `${mockBase}/exec-ok` },
-    { target_id: "exec_fail", task_ref: "exec.fail", endpoint_url: `${mockBase}/exec-fail` }
-  ]);
-
-  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}`;
-
-  try {
-    // 1. Execution FAILS -> deferred settlement is never reached; caller is not charged.
-    const settleBeforeFail = mock.calls.settle;
-    const verifyBeforeFail = mock.calls.verify;
-    const failBody = { account_id: "acct_ves", command: "failing execution", task_ref: "exec.fail", body: { subject_id: "s-1" } };
-    const failed = await post(baseUrl, "/x402/commands/execute", failBody, { "payment-signature": paymentHeader("ok") });
-    assert.strictEqual(failed.status, 502, "failed execution must return 502");
-    assert.strictEqual(failed.json.ok, false, "failed execution must report ok:false");
-    assert.strictEqual(failed.json.payment_settled, false, "a failed x402 call must NOT be settled");
-    assert.ok(/not charged/i.test(String(failed.json.remediation || "")), "failed x402 call must tell the agent it was not charged");
-    assert.ok(!failed.json.settlement, "failed x402 call must carry no settlement");
-    assert.strictEqual(failed.headers.get("payment-response"), null, "failed x402 call must NOT emit a PAYMENT-RESPONSE receipt");
-    assert.strictEqual(mock.calls.settle, settleBeforeFail, "facilitator /settle must NOT be called when execution fails");
-    assert.strictEqual(mock.calls.verify, verifyBeforeFail + 1, "the payment must still have been verified up front");
-    assert.strictEqual(mock.calls.execFail, 1, "the failing execution target must have been attempted");
-
-    // 2. Execution SUCCEEDS -> settle runs exactly once, after the work, with a receipt.
-    const settleBeforeOk = mock.calls.settle;
-    const okBody = { account_id: "acct_ves", command: "successful execution", task_ref: "exec.ok", body: { subject_id: "s-2" } };
-    const ok = await post(baseUrl, "/x402/commands/execute", okBody, { "payment-signature": paymentHeader("ok") });
-    assert.strictEqual(ok.status, 200, "successful execution must return 200");
-    assert.strictEqual(ok.json.transaction.status, "completed", "successful transaction must be completed");
-    assert.strictEqual(ok.json.transaction.payment.verification_mode, "x402_facilitator", "verification mode must be recorded");
-    assert.strictEqual(mock.calls.settle, settleBeforeOk + 1, "facilitator /settle must be called exactly once on success");
-    assert.strictEqual(mock.calls.execOk, 1, "the successful execution target must have been invoked");
-    const receiptHeader = ok.headers.get("payment-response");
-    assert.strictEqual(typeof receiptHeader, "string", "a settled success must carry a PAYMENT-RESPONSE receipt");
-    const receipt = JSON.parse(Buffer.from(receiptHeader, "base64").toString("utf8"));
-    assert.strictEqual(receipt.success, true, "settlement receipt must report success");
-    assert.strictEqual(receipt.transaction, "0xmocktx", "settlement receipt transaction mismatch");
-
-    // 3. Settle FAILS after a SUCCESSFUL execution -> deliverable withheld, not charged.
-    const settleBeforeSf = mock.calls.settle;
-    const sfBody = { account_id: "acct_ves", command: "settle fails after success", task_ref: "exec.ok", body: { subject_id: "s-3" } };
-    const settleFail = await post(baseUrl, "/x402/commands/execute", sfBody, { "payment-signature": paymentHeader("settle-fails") });
-    assert.strictEqual(settleFail.status, 402, "a failed post-execution settlement must 402");
-    assert.strictEqual(settleFail.json.ok, false, "a failed settlement must report ok:false");
-    assert.strictEqual(settleFail.json.payment_settled, false, "a failed settlement must report payment_settled:false");
-    assert.ok(/not charged/i.test(String(settleFail.json.remediation || "")), "settle-fail must tell the agent it was not charged");
-    assert.ok(!settleFail.json.transaction, "settle-fail must NOT return the deliverable");
-    assert.strictEqual(settleFail.headers.get("payment-response"), null, "settle-fail must emit no receipt");
-    assert.strictEqual(mock.calls.settle, settleBeforeSf + 1, "settle must have been attempted once");
-    assert.strictEqual(mock.calls.execOk, 2, "the work must have executed before the settle attempt");
-
-    // 4. Non-x402 lane (presence mode, no on-chain settlement) that fails execution must
-    //    NOT claim the caller was charged and must NOT point them at a refund flow — the
-    //    failure flag is keyed on an actual receipt, not merely on "not deferred".
-    await new Promise((resolve) => server.close(resolve));
-    const prevMode = process.env.XYTARA_PAYMENT_VERIFICATION_MODE;
-    process.env.XYTARA_PAYMENT_VERIFICATION_MODE = "presence";
-    delete require.cache[require.resolve("../server")];
-    const presenceServerFactory = require("../server").createServer;
-    const presenceServer = presenceServerFactory();
-    await new Promise((resolve) => presenceServer.listen(0, "127.0.0.1", resolve));
-    const presenceBase = `http://127.0.0.1:${presenceServer.address().port}`;
-    try {
-      const presFail = await post(presenceBase, "/v1/commands/execute", { account_id: "acct_ves", command: "presence failing exec", task_ref: "exec.fail", body: { subject_id: "s-4" } }, {
-        "x-wallet-id": "wallet-presence",
-        "x-payment": "encoded",
-        "x-payment-signature": "sig"
-      });
-      assert.strictEqual(presFail.json.ok, false, "presence failing execution must report ok:false");
-      assert.strictEqual(presFail.json.payment_settled, false, "presence lane must NOT claim a charge on failure");
-      assert.ok(!/refund/i.test(String(presFail.json.remediation || "")), "presence lane must NOT point to a refund flow on failure");
-      assert.strictEqual(presFail.headers.get("payment-response"), null, "presence failure must emit no receipt");
-    } finally {
-      await new Promise((resolve) => presenceServer.close(resolve));
-      if (prevMode === undefined) delete process.env.XYTARA_PAYMENT_VERIFICATION_MODE; else process.env.XYTARA_PAYMENT_VERIFICATION_MODE = prevMode;
-    }
-
-    console.log("xytara verify:verify-execute-settle passed");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-    await new Promise((resolve) => mock.server.close(resolve));
-    const restore = (key, value) => { if (value === undefined) delete process.env[key]; else process.env[key] = value; };
-    restore("XYTARA_PAYMENT_VERIFICATION_MODE", previous.mode);
-    restore("XYTARA_X402_ACCEPTS_JSON", previous.accepts);
-    restore("XYTARA_X402_FACILITATOR_URL", previous.facUrl);
-    restore("XYTARA_EXECUTION_TARGETS_JSON", previous.targets);
-  }
-}
-
-main().catch((error) => {
-  console.error(error && error.message ? error.message : error);
-  process.exitCode = 1;
-});
+"use strict";
+
+// Verifies the don't-charge-on-failure guarantee for the x402 command path:
+//   - when external execution FAILS, the deferred x402 settlement is NEVER called
+//     (the facilitator /settle is not hit), the response is a non-2xx carrying
+//     payment_settled:false and a "you were not charged" remediation, and no
+//     PAYMENT-RESPONSE receipt is emitted;
+//   - when external execution SUCCEEDS, settlement runs exactly once AFTER the work,
+//     the response is 200 with the real tool output surfaced and a PAYMENT-RESPONSE
+//     receipt attached.
+//
+// This is the verify -> execute -> settle reorder: an x402 authorization is verified
+// up front but only settled once the deliverable is produced, so a failed call costs
+// the paying agent nothing. No real network or chain is used.
+
+const assert = require("assert");
+const http = require("http");
+
+const ACCEPTS = [
+  {
+    scheme: "exact",
+    network: "eip155:84532",
+    asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    amount: "1000",
+    payTo: "0x7cd2E0Ed2721319B20FAac4109774d030833F84D",
+    extra: { name: "USDC", version: "2" },
+    maxTimeoutSeconds: 60
+  }
+];
+
+// One mock server stands in for BOTH the x402 facilitator (/verify, /settle) and the
+// external execution target (/exec-ok succeeds, /exec-fail rejects with a 502).
+function startMockServer() {
+  const calls = { verify: 0, settle: 0, execOk: 0, execFail: 0 };
+  const server = http.createServer((req, res) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      let body = {};
+      try { body = JSON.parse(Buffer.concat(chunks).toString("utf8") || "{}"); } catch (_) { body = {}; }
+      const reply = (payload, status) => {
+        const text = JSON.stringify(payload);
+        res.writeHead(status || 200, { "content-type": "application/json", "content-length": Buffer.byteLength(text) });
+        res.end(text);
+      };
+      if (req.method === "POST" && req.url === "/verify") {
+        calls.verify += 1;
+        return reply({ isValid: true, payer: "0x1111111111111111111111111111111111111111" });
+      }
+      if (req.method === "POST" && req.url === "/settle") {
+        calls.settle += 1;
+        const sig = body && body.paymentPayload && body.paymentPayload.payload ? String(body.paymentPayload.payload.signature || "") : "";
+        if (sig === "settle-fails") return reply({ success: false, errorReason: "insufficient_funds" });
+        return reply({ success: true, transaction: "0xmocktx", network: "eip155:84532", payer: "0x1111111111111111111111111111111111111111" });
+      }
+      if (req.method === "POST" && req.url === "/exec-ok") {
+        calls.execOk += 1;
+        return reply({ ok: true, status: "completed", output: { value: "0xdeadbeef" } });
+      }
+      if (req.method === "POST" && req.url === "/exec-fail") {
+        calls.execFail += 1;
+        return reply({ ok: false, reason: "data_required" }, 502);
+      }
+      res.writeHead(404); res.end();
+    });
+  });
+  return new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve({ server, calls, port: server.address().port })));
+}
+
+function paymentHeader(signature) {
+  const accepted = ACCEPTS[0];
+  return Buffer.from(JSON.stringify({
+    x402Version: 2,
+    accepted,
+    payload: {
+      signature,
+      authorization: {
+        from: "0x1111111111111111111111111111111111111111",
+        to: accepted.payTo,
+        value: accepted.amount,
+        validAfter: "0",
+        validBefore: String(Math.floor(Date.now() / 1000) + 600),
+        // A fresh nonce per payment, as a real wallet signs; a reused nonce is a replay.
+        nonce: `0x${require("crypto").randomBytes(32).toString("hex")}`
+      }
+    }
+  }), "utf8").toString("base64");
+}
+
+async function post(baseUrl, path, body, headers = {}) {
+  const res = await fetch(`${baseUrl}${path}`, {
+    method: "POST",
+    headers: { "content-type": "application/json", ...headers },
+    body: JSON.stringify(body)
+  });
+  let json = null;
+  try { json = await res.json(); } catch (_) { json = null; }
+  return { status: res.status, json, headers: res.headers };
+}
+
+async function main() {
+  const mock = await startMockServer();
+  const mockBase = `http://127.0.0.1:${mock.port}`;
+  const previous = {
+    mode: process.env.XYTARA_PAYMENT_VERIFICATION_MODE,
+    accepts: process.env.XYTARA_X402_ACCEPTS_JSON,
+    facUrl: process.env.XYTARA_X402_FACILITATOR_URL,
+    targets: process.env.XYTARA_EXECUTION_TARGETS_JSON
+  };
+  process.env.XYTARA_PAYMENT_VERIFICATION_MODE = "x402_facilitator";
+  process.env.XYTARA_X402_ACCEPTS_JSON = JSON.stringify(ACCEPTS);
+  process.env.XYTARA_X402_FACILITATOR_URL = mockBase;
+  process.env.XYTARA_EXECUTION_TARGETS_JSON = JSON.stringify([
+    { target_id: "exec_ok", task_ref: "exec.ok", endpoint_url: `${mockBase}/exec-ok` },
+    { target_id: "exec_fail", task_ref: "exec.fail", endpoint_url: `${mockBase}/exec-fail` }
+  ]);
+
+  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}`;
+
+  try {
+    // 1. Execution FAILS -> deferred settlement is never reached; caller is not charged.
+    const settleBeforeFail = mock.calls.settle;
+    const verifyBeforeFail = mock.calls.verify;
+    const failBody = { account_id: "acct_ves", command: "failing execution", task_ref: "exec.fail", body: { subject_id: "s-1" } };
+    const failed = await post(baseUrl, "/x402/commands/execute", failBody, { "payment-signature": paymentHeader("ok") });
+    assert.strictEqual(failed.status, 502, "failed execution must return 502");
+    assert.strictEqual(failed.json.ok, false, "failed execution must report ok:false");
+    assert.strictEqual(failed.json.payment_settled, false, "a failed x402 call must NOT be settled");
+    assert.ok(/not charged/i.test(String(failed.json.remediation || "")), "failed x402 call must tell the agent it was not charged");
+    assert.ok(!failed.json.settlement, "failed x402 call must carry no settlement");
+    assert.strictEqual(failed.headers.get("payment-response"), null, "failed x402 call must NOT emit a PAYMENT-RESPONSE receipt");
+    assert.strictEqual(mock.calls.settle, settleBeforeFail, "facilitator /settle must NOT be called when execution fails");
+    assert.strictEqual(mock.calls.verify, verifyBeforeFail + 1, "the payment must still have been verified up front");
+    assert.strictEqual(mock.calls.execFail, 1, "the failing execution target must have been attempted");
+
+    // 2. Execution SUCCEEDS -> settle runs exactly once, after the work, with a receipt.
+    const settleBeforeOk = mock.calls.settle;
+    const okBody = { account_id: "acct_ves", command: "successful execution", task_ref: "exec.ok", body: { subject_id: "s-2" } };
+    const ok = await post(baseUrl, "/x402/commands/execute", okBody, { "payment-signature": paymentHeader("ok") });
+    assert.strictEqual(ok.status, 200, "successful execution must return 200");
+    assert.strictEqual(ok.json.transaction.status, "completed", "successful transaction must be completed");
+    assert.strictEqual(ok.json.transaction.payment.verification_mode, "x402_facilitator", "verification mode must be recorded");
+    assert.strictEqual(mock.calls.settle, settleBeforeOk + 1, "facilitator /settle must be called exactly once on success");
+    assert.strictEqual(mock.calls.execOk, 1, "the successful execution target must have been invoked");
+    const receiptHeader = ok.headers.get("payment-response");
+    assert.strictEqual(typeof receiptHeader, "string", "a settled success must carry a PAYMENT-RESPONSE receipt");
+    const receipt = JSON.parse(Buffer.from(receiptHeader, "base64").toString("utf8"));
+    assert.strictEqual(receipt.success, true, "settlement receipt must report success");
+    assert.strictEqual(receipt.transaction, "0xmocktx", "settlement receipt transaction mismatch");
+
+    // 3. Settle FAILS after a SUCCESSFUL execution -> deliverable withheld, not charged.
+    const settleBeforeSf = mock.calls.settle;
+    const sfBody = { account_id: "acct_ves", command: "settle fails after success", task_ref: "exec.ok", body: { subject_id: "s-3" } };
+    const settleFail = await post(baseUrl, "/x402/commands/execute", sfBody, { "payment-signature": paymentHeader("settle-fails") });
+    assert.strictEqual(settleFail.status, 402, "a failed post-execution settlement must 402");
+    assert.strictEqual(settleFail.json.ok, false, "a failed settlement must report ok:false");
+    assert.strictEqual(settleFail.json.payment_settled, false, "a failed settlement must report payment_settled:false");
+    assert.ok(/not charged/i.test(String(settleFail.json.remediation || "")), "settle-fail must tell the agent it was not charged");
+    assert.ok(!settleFail.json.transaction, "settle-fail must NOT return the deliverable");
+    assert.strictEqual(settleFail.headers.get("payment-response"), null, "settle-fail must emit no receipt");
+    assert.strictEqual(mock.calls.settle, settleBeforeSf + 1, "settle must have been attempted once");
+    assert.strictEqual(mock.calls.execOk, 2, "the work must have executed before the settle attempt");
+
+    // 4. Non-x402 lane (presence mode, no on-chain settlement) that fails execution must
+    //    NOT claim the caller was charged and must NOT point them at a refund flow — the
+    //    failure flag is keyed on an actual receipt, not merely on "not deferred".
+    await new Promise((resolve) => server.close(resolve));
+    const prevMode = process.env.XYTARA_PAYMENT_VERIFICATION_MODE;
+    process.env.XYTARA_PAYMENT_VERIFICATION_MODE = "presence";
+    delete require.cache[require.resolve("../server")];
+    const presenceServerFactory = require("../server").createServer;
+    const presenceServer = presenceServerFactory();
+    await new Promise((resolve) => presenceServer.listen(0, "127.0.0.1", resolve));
+    const presenceBase = `http://127.0.0.1:${presenceServer.address().port}`;
+    try {
+      const presFail = await post(presenceBase, "/v1/commands/execute", { account_id: "acct_ves", command: "presence failing exec", task_ref: "exec.fail", body: { subject_id: "s-4" } }, {
+        "x-wallet-id": "wallet-presence",
+        "x-payment": "encoded",
+        "x-payment-signature": "sig"
+      });
+      assert.strictEqual(presFail.json.ok, false, "presence failing execution must report ok:false");
+      assert.strictEqual(presFail.json.payment_settled, false, "presence lane must NOT claim a charge on failure");
+      assert.ok(!/refund/i.test(String(presFail.json.remediation || "")), "presence lane must NOT point to a refund flow on failure");
+      assert.strictEqual(presFail.headers.get("payment-response"), null, "presence failure must emit no receipt");
+    } finally {
+      await new Promise((resolve) => presenceServer.close(resolve));
+      if (prevMode === undefined) delete process.env.XYTARA_PAYMENT_VERIFICATION_MODE; else process.env.XYTARA_PAYMENT_VERIFICATION_MODE = prevMode;
+    }
+
+    console.log("xytara verify:verify-execute-settle passed");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+    await new Promise((resolve) => mock.server.close(resolve));
+    const restore = (key, value) => { if (value === undefined) delete process.env[key]; else process.env[key] = value; };
+    restore("XYTARA_PAYMENT_VERIFICATION_MODE", previous.mode);
+    restore("XYTARA_X402_ACCEPTS_JSON", previous.accepts);
+    restore("XYTARA_X402_FACILITATOR_URL", previous.facUrl);
+    restore("XYTARA_EXECUTION_TARGETS_JSON", previous.targets);
+  }
+}
+
+main().catch((error) => {
+  console.error(error && error.message ? error.message : error);
+  process.exitCode = 1;
+});