xytara 3.1.0 → 3.1.2

package/scripts/verify_treasury_public_boundary.js

@@ -1,97 +1,97 @@
-"use strict";
-
-const assert = require("assert");
-const {
-  buildOperatorTreasuryDestinationsPack,
-  buildTreasuryDestinationsPack,
-  validateTreasuryDestinationPublicBoundary
-} = require("../lib/treasury_destinations_contract");
-
-function clone(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-
-function assertRejected(pack, expectedCode) {
-  const validation = validateTreasuryDestinationPublicBoundary(pack);
-  assert.strictEqual(validation.public_boundary_valid, false, `expected ${expectedCode} to block treasury public boundary`);
-  assert.strictEqual(
-    validation.rejection_codes.includes(expectedCode),
-    true,
-    `missing deterministic rejection code ${expectedCode}`
-  );
-  return validation;
-}
-
-function main() {
-  const publicPack = buildTreasuryDestinationsPack();
-  const operatorPack = buildOperatorTreasuryDestinationsPack();
-  const publicValidation = validateTreasuryDestinationPublicBoundary(publicPack);
-  const operatorValidation = validateTreasuryDestinationPublicBoundary(operatorPack);
-
-  assert.strictEqual(publicPack.category, "machine-commerce-treasury-destinations-pack", "public treasury pack category mismatch");
-  assert.strictEqual(publicValidation.public_boundary_valid, true, "public treasury boundary should validate");
-  assert.deepStrictEqual(publicValidation.rejection_codes, [], "public treasury boundary should not carry rejections");
-  assert.strictEqual(operatorValidation.public_boundary_valid, true, "operator treasury boundary should validate");
-  assert.strictEqual(publicValidation.deterministic_rejection_codes.length >= 11, true, "treasury rejection code count missing");
-
-  const custodyLeak = clone(publicPack);
-  custodyLeak.profiles[0].custody_destination = {
-    external_ref: "bsv://real-merchant-treasury"
-  };
-  assertRejected(custodyLeak, "public_custody_destination_leak");
-
-  const externalRefLeak = clone(publicPack);
-  externalRefLeak.profiles[0].destination_visibility.external_ref = "bsv://real-merchant-treasury";
-  assertRejected(externalRefLeak, "public_external_ref_leak");
-
-  const custodyRefLeak = clone(publicPack);
-  custodyRefLeak.profiles[0].custody_ref = "vault://private";
-  assertRejected(custodyRefLeak, "public_custody_ref_leak");
-
-  const reportingRefLeak = clone(publicPack);
-  reportingRefLeak.profiles[0].destination_visibility.reporting_ref = "ledger://private";
-  assertRejected(reportingRefLeak, "public_reporting_ref_leak");
-
-  const walletRefLeak = clone(publicPack);
-  walletRefLeak.profiles[0].wallet_ref = "wallet://private";
-  assertRejected(walletRefLeak, "public_wallet_ref_leak");
-
-  const providerRefLeak = clone(publicPack);
-  providerRefLeak.profiles[0].destination_visibility.provider_ref = "rpc://private";
-  assertRejected(providerRefLeak, "public_provider_ref_leak");
-
-  const internalClaim = clone(publicPack);
-  const moneroProfile = internalClaim.profiles.find((entry) => entry.rail_id === "monero");
-  moneroProfile.public_claim_allowed = true;
-  assertRejected(internalClaim, "internal_rail_public_claimed");
-
-  const readinessClaim = clone(publicPack);
-  readinessClaim.public_claim_boundary.readiness_only_rails = [readinessClaim.profiles[0].rail_id];
-  readinessClaim.profiles[0].public_claim_allowed = true;
-  assertRejected(readinessClaim, "readiness_only_rail_public_claimed");
-
-  const boundaryMismatch = clone(publicPack);
-  boundaryMismatch.public_claim_boundary.internal_only_rails = [];
-  assertRejected(boundaryMismatch, "claim_boundary_mismatch");
-
-  const unsupportedLiveRail = clone(publicPack);
-  unsupportedLiveRail.public_claim_boundary.live_claimable_rails = ["made_up_rail"];
-  assertRejected(unsupportedLiveRail, "unsupported_live_claim_rail");
-
-  const operatorRuleMissing = clone(operatorPack);
-  operatorRuleMissing.custody_visibility_rule = "unsafe";
-  assertRejected(operatorRuleMissing, "operator_visibility_rule_missing");
-
-  const output = {
-    ok: true,
-    product: "xytara",
-    category: "xytara-treasury-public-boundary-verification",
-    status: "treasury_public_surfaces_do_not_leak_landing_or_custody_refs_and_claim_boundary_matches_profiles",
-    deterministic_rejection_code_count: publicValidation.deterministic_rejection_codes.length,
-    adversarial_case_count: 11,
-    boundary: publicValidation.boundary
-  };
-  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
-}
-
-main();
+"use strict";
+
+const assert = require("assert");
+const {
+  buildOperatorTreasuryDestinationsPack,
+  buildTreasuryDestinationsPack,
+  validateTreasuryDestinationPublicBoundary
+} = require("../lib/treasury_destinations_contract");
+
+function clone(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+
+function assertRejected(pack, expectedCode) {
+  const validation = validateTreasuryDestinationPublicBoundary(pack);
+  assert.strictEqual(validation.public_boundary_valid, false, `expected ${expectedCode} to block treasury public boundary`);
+  assert.strictEqual(
+    validation.rejection_codes.includes(expectedCode),
+    true,
+    `missing deterministic rejection code ${expectedCode}`
+  );
+  return validation;
+}
+
+function main() {
+  const publicPack = buildTreasuryDestinationsPack();
+  const operatorPack = buildOperatorTreasuryDestinationsPack();
+  const publicValidation = validateTreasuryDestinationPublicBoundary(publicPack);
+  const operatorValidation = validateTreasuryDestinationPublicBoundary(operatorPack);
+
+  assert.strictEqual(publicPack.category, "machine-commerce-treasury-destinations-pack", "public treasury pack category mismatch");
+  assert.strictEqual(publicValidation.public_boundary_valid, true, "public treasury boundary should validate");
+  assert.deepStrictEqual(publicValidation.rejection_codes, [], "public treasury boundary should not carry rejections");
+  assert.strictEqual(operatorValidation.public_boundary_valid, true, "operator treasury boundary should validate");
+  assert.strictEqual(publicValidation.deterministic_rejection_codes.length >= 11, true, "treasury rejection code count missing");
+
+  const custodyLeak = clone(publicPack);
+  custodyLeak.profiles[0].custody_destination = {
+    external_ref: "bsv://real-merchant-treasury"
+  };
+  assertRejected(custodyLeak, "public_custody_destination_leak");
+
+  const externalRefLeak = clone(publicPack);
+  externalRefLeak.profiles[0].destination_visibility.external_ref = "bsv://real-merchant-treasury";
+  assertRejected(externalRefLeak, "public_external_ref_leak");
+
+  const custodyRefLeak = clone(publicPack);
+  custodyRefLeak.profiles[0].custody_ref = "vault://private";
+  assertRejected(custodyRefLeak, "public_custody_ref_leak");
+
+  const reportingRefLeak = clone(publicPack);
+  reportingRefLeak.profiles[0].destination_visibility.reporting_ref = "ledger://private";
+  assertRejected(reportingRefLeak, "public_reporting_ref_leak");
+
+  const walletRefLeak = clone(publicPack);
+  walletRefLeak.profiles[0].wallet_ref = "wallet://private";
+  assertRejected(walletRefLeak, "public_wallet_ref_leak");
+
+  const providerRefLeak = clone(publicPack);
+  providerRefLeak.profiles[0].destination_visibility.provider_ref = "rpc://private";
+  assertRejected(providerRefLeak, "public_provider_ref_leak");
+
+  const internalClaim = clone(publicPack);
+  const moneroProfile = internalClaim.profiles.find((entry) => entry.rail_id === "monero");
+  moneroProfile.public_claim_allowed = true;
+  assertRejected(internalClaim, "internal_rail_public_claimed");
+
+  const readinessClaim = clone(publicPack);
+  readinessClaim.public_claim_boundary.readiness_only_rails = [readinessClaim.profiles[0].rail_id];
+  readinessClaim.profiles[0].public_claim_allowed = true;
+  assertRejected(readinessClaim, "readiness_only_rail_public_claimed");
+
+  const boundaryMismatch = clone(publicPack);
+  boundaryMismatch.public_claim_boundary.internal_only_rails = [];
+  assertRejected(boundaryMismatch, "claim_boundary_mismatch");
+
+  const unsupportedLiveRail = clone(publicPack);
+  unsupportedLiveRail.public_claim_boundary.live_claimable_rails = ["made_up_rail"];
+  assertRejected(unsupportedLiveRail, "unsupported_live_claim_rail");
+
+  const operatorRuleMissing = clone(operatorPack);
+  operatorRuleMissing.custody_visibility_rule = "unsafe";
+  assertRejected(operatorRuleMissing, "operator_visibility_rule_missing");
+
+  const output = {
+    ok: true,
+    product: "xytara",
+    category: "xytara-treasury-public-boundary-verification",
+    status: "treasury_public_surfaces_do_not_leak_landing_or_custody_refs_and_claim_boundary_matches_profiles",
+    deterministic_rejection_code_count: publicValidation.deterministic_rejection_codes.length,
+    adversarial_case_count: 11,
+    boundary: publicValidation.boundary
+  };
+  process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+}
+
+main();

package/scripts/verify_x402_facilitator.js

@@ -0,0 +1,174 @@
+"use strict";
+
+// Verifies the x402_facilitator payment mode end to end against a mock facilitator:
+//   - an unpaid x402 execute returns 402 and advertises the configured accepts
+//   - a well-formed payment is verified and settled, the command runs, and the
+//     response carries a PAYMENT-RESPONSE settlement receipt
+//   - malformed, mismatched, facilitator-rejected, and unsettled payments all 402
+//
+// No real network or chain is used; the mock facilitator stands in for x402.org.
+
+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
+  }
+];
+
+function startMockFacilitator() {
+  const calls = { verify: 0, settle: 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 sig = body && body.paymentPayload && body.paymentPayload.payload ? String(body.paymentPayload.payload.signature || "") : "";
+      const reply = (payload) => {
+        const text = JSON.stringify(payload);
+        res.writeHead(200, { "content-type": "application/json", "content-length": Buffer.byteLength(text) });
+        res.end(text);
+      };
+      if (req.method === "POST" && req.url === "/verify") {
+        calls.verify += 1;
+        if (sig === "reject-me") return reply({ isValid: false, invalidReason: "invalid_signature" });
+        return reply({ isValid: true, payer: "0x1111111111111111111111111111111111111111" });
+      }
+      if (req.method === "POST" && req.url === "/settle") {
+        calls.settle += 1;
+        if (sig === "settle-fails") return reply({ success: false, errorReason: "insufficient_funds" });
+        return reply({ success: true, transaction: "0xmocktx", network: "eip155:84532", payer: "0x1111111111111111111111111111111111111111" });
+      }
+      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, overrides = {}) {
+  const accepted = ACCEPTS[0];
+  return Buffer.from(JSON.stringify({
+    x402Version: 2,
+    accepted: { ...accepted, ...overrides.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 facilitator = await startMockFacilitator();
+  const previous = {
+    mode: process.env.XYTARA_PAYMENT_VERIFICATION_MODE,
+    accepts: process.env.XYTARA_X402_ACCEPTS_JSON,
+    facUrl: process.env.XYTARA_X402_FACILITATOR_URL
+  };
+  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}`;
+
+  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 execBody = { account_id: "acct_x402", command: "x402 facilitator demo", task_ref: "trust.verify", body: { subject_id: "s-1" } };
+
+  try {
+    // 1. Unpaid -> 402 advertising accepts.
+    const unpaid = await post(baseUrl, "/x402/commands/execute", execBody);
+    assert.strictEqual(unpaid.status, 402, "unpaid x402 execute must return 402");
+    const required = unpaid.json && unpaid.json.payment_required;
+    assert.ok(required, "402 must carry payment_required");
+    assert.strictEqual(required.x402Version, 2, "challenge must be x402 v2");
+    assert.ok(Array.isArray(required.accepts) && required.accepts.length === 1, "challenge must advertise accepts");
+    assert.strictEqual(required.accepts[0].network, "eip155:84532", "advertised network mismatch");
+    assert.strictEqual(typeof unpaid.headers.get("payment-required"), "string", "PAYMENT-REQUIRED header missing");
+
+    // 2. Bogus header -> 402 payment_signature_invalid.
+    const bogus = await post(baseUrl, "/x402/commands/execute", execBody, { "payment-signature": "not-a-payment" });
+    assert.strictEqual(bogus.status, 402, "bogus payment header must 402");
+    assert.strictEqual(bogus.json.reason, "payment_signature_invalid", "bogus reason mismatch");
+
+    // 3. Mismatched requirements -> 402 before the facilitator.
+    const verifyBefore = facilitator.calls.verify;
+    const mismatch = await post(baseUrl, "/x402/commands/execute", execBody, { "payment-signature": paymentHeader("ok", { accepted: { amount: "9" } }) });
+    assert.strictEqual(mismatch.status, 402, "mismatched requirements must 402");
+    assert.strictEqual(mismatch.json.reason, "payment_requirements_mismatch", "mismatch reason");
+    assert.strictEqual(facilitator.calls.verify, verifyBefore, "facilitator must not be called on a requirements mismatch");
+
+    // 4. Facilitator rejects -> 402 payment_verification_failed.
+    const rejected = await post(baseUrl, "/x402/commands/execute", execBody, { "payment-signature": paymentHeader("reject-me") });
+    assert.strictEqual(rejected.status, 402, "facilitator-rejected payment must 402");
+    assert.strictEqual(rejected.json.reason, "payment_verification_failed", "rejection reason");
+    assert.strictEqual(rejected.json.detail, "invalid_signature", "rejection detail");
+
+    // 5. Settlement fails -> 402, no tool output.
+    const settleFails = await post(baseUrl, "/x402/commands/execute", execBody, { "payment-signature": paymentHeader("settle-fails") });
+    assert.strictEqual(settleFails.status, 402, "failed settlement must 402");
+    assert.strictEqual(settleFails.json.reason, "payment_settlement_failed", "settlement failure reason");
+
+    // 6. Verified + settled -> 200 with a result and a PAYMENT-RESPONSE receipt.
+    const settleBefore = facilitator.calls.settle;
+    const paid = await post(baseUrl, "/x402/commands/execute", execBody, { "payment-signature": paymentHeader("ok") });
+    assert.strictEqual(paid.status, 200, "verified+settled payment must 200");
+    assert.strictEqual(typeof paid.json.transaction.transaction_id, "string", "paid result missing transaction");
+    assert.strictEqual(paid.json.transaction.status, "completed", "paid transaction must be completed");
+    assert.strictEqual(paid.json.transaction.payment.verification_mode, "x402_facilitator", "verification mode not recorded");
+    assert.strictEqual(facilitator.calls.settle, settleBefore + 1, "facilitator settle must be called once");
+    const receiptHeader = paid.headers.get("payment-response");
+    assert.strictEqual(typeof receiptHeader, "string", "PAYMENT-RESPONSE header missing on a settled 200");
+    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");
+
+    // 7. Native routes must not be disabled by x402_facilitator: a native paid attempt
+    //    falls back to local_signed semantics, never payment_verification_mode_unsupported.
+    const nativeAttempt = await post(baseUrl, "/v1/commands/execute", execBody, {
+      "x-wallet-id": "wallet-not-registered",
+      "x-payment": "encoded",
+      "x-payment-signature": "sig"
+    });
+    assert.notStrictEqual(nativeAttempt.json && nativeAttempt.json.reason, "payment_verification_mode_unsupported", "native route must fall back to local_signed under x402_facilitator");
+
+    console.log("xytara verify:x402-facilitator passed");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+    await new Promise((resolve) => facilitator.server.close(resolve));
+    if (previous.mode === undefined) delete process.env.XYTARA_PAYMENT_VERIFICATION_MODE; else process.env.XYTARA_PAYMENT_VERIFICATION_MODE = previous.mode;
+    if (previous.accepts === undefined) delete process.env.XYTARA_X402_ACCEPTS_JSON; else process.env.XYTARA_X402_ACCEPTS_JSON = previous.accepts;
+    if (previous.facUrl === undefined) delete process.env.XYTARA_X402_FACILITATOR_URL; else process.env.XYTARA_X402_FACILITATOR_URL = previous.facUrl;
+  }
+}
+
+main().catch((error) => {
+  console.error(error && error.message ? error.message : error);
+  process.exitCode = 1;
+});