xytara 3.1.13 → 3.1.15

package/scripts/verify_buyer_event_log.js

@@ -0,0 +1,123 @@
+"use strict";
+
+// End-to-end check (real local server) of the buyer event log: failed buyer attempts are recorded
+// with a stage/reason/fault and a request id the buyer also receives; normal 402 challenges are
+// counted, not logged; malformed JSON is a 400 (not a 500); executor events can be ingested with
+// the dedicated token only; reads are operator-only; nothing sensitive (payment signature, full
+// payer address) is ever stored.
+
+const assert = require("assert");
+
+const PAYER = "0x1111111111111111111111111111111111111111";
+const ACCEPTS = [{
+  scheme: "exact",
+  network: "eip155:8453",
+  asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  amount: "10000",
+  payTo: "0x7cd2E0Ed2721319B20FAac4109774d030833F84D",
+  extra: { name: "USD Coin", version: "2" },
+  maxTimeoutSeconds: 60
+}];
+const FAKE_SIGNATURE = `0x${"9f".repeat(65)}`;
+
+async function request(baseUrl, method, path, { body, raw, headers = {} } = {}) {
+  const res = await fetch(`${baseUrl}${path}`, {
+    method,
+    headers: { "content-type": "application/json", ...headers },
+    body: raw !== undefined ? raw : body !== undefined ? JSON.stringify(body) : undefined
+  });
+  let json = null;
+  try { json = await res.json(); } catch (_) { json = null; }
+  return { status: res.status, json, headers: res.headers };
+}
+
+async function main() {
+  const OP = "event-log-operator-token";
+  const INGEST = "event-log-ingest-token";
+  const keys = ["XYTARA_ACCOUNT_AUTH_BEARER_TOKEN", "XYTARA_EVENT_INGEST_TOKEN", "XYTARA_PAID_EXECUTION_POLICY", "XYTARA_PAYMENT_VERIFICATION_MODE", "XYTARA_X402_ACCEPTS_JSON", "XYTARA_X402_FACILITATOR_URL"];
+  const previous = Object.fromEntries(keys.map((key) => [key, process.env[key]]));
+  process.env.XYTARA_ACCOUNT_AUTH_BEARER_TOKEN = OP;
+  process.env.XYTARA_EVENT_INGEST_TOKEN = INGEST;
+  process.env.XYTARA_PAID_EXECUTION_POLICY = "strict";
+  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:9";
+
+  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 operator = { authorization: `Bearer ${OP}` };
+  try {
+    // 1. Malformed JSON is the buyer's error (400 invalid_json), with a request id, and is logged.
+    const malformed = await request(baseUrl, "POST", "/x402/commands/execute", { raw: "{not json" });
+    assert.strictEqual(malformed.status, 400, "malformed JSON must be a 400, not a 500");
+    assert.strictEqual(malformed.json.reason, "invalid_json");
+    assert.ok(/^req_[0-9a-f]{16}$/.test(malformed.headers.get("x-request-id") || ""), "every response carries X-Request-Id");
+
+    // 2. A non-executable task (strict) is refused and logged as a route failure.
+    const refused = await request(baseUrl, "POST", "/x402/commands/execute", { body: { task_ref: "trust.verify" } });
+    assert.strictEqual(refused.status, 501);
+
+    // 3. A payment attempt with a fake signature: logged with network/amount and a payer HASH only.
+    const header = Buffer.from(JSON.stringify({
+      x402Version: 2,
+      accepted: ACCEPTS[0],
+      payload: { signature: FAKE_SIGNATURE, authorization: { from: PAYER, to: ACCEPTS[0].payTo, value: "10000", validAfter: "0", validBefore: String(Math.floor(Date.now() / 1000) + 600), nonce: `0x${"ab".repeat(32)}` } }
+    })).toString("base64");
+    const executable = { task_ref: "adapter.mcp.invoke", body: { tool_name: "keccak256", arguments: { data: "abc" } } };
+    // No executable target here, so register nothing: the strict gate refuses before payment -> still an event.
+    await request(baseUrl, "POST", "/x402/commands/execute", { body: executable, headers: { "payment-signature": header } });
+
+    // 4. Reads are operator-only.
+    const anonymous = await request(baseUrl, "GET", "/v1/operator/buyer-events");
+    assert.strictEqual(anonymous.status, 403, "buyer events are operator-only");
+    const listed = await request(baseUrl, "GET", "/v1/operator/buyer-events?limit=50", { headers: operator });
+    assert.strictEqual(listed.status, 200);
+    const events = listed.json.events;
+    assert.ok(events.some((event) => event.reason === "invalid_json" && event.stage === "parse" && event.fault === "buyer" && event.request_id === malformed.headers.get("x-request-id")), "malformed JSON event recorded with the buyer's request id");
+    assert.ok(events.some((event) => event.reason === "capability_not_executable" && event.task_or_tool === "trust.verify"), "non-executable attempt recorded with its task");
+    const paid = events.find((event) => event.task_or_tool === "keccak256");
+    assert.ok(paid && paid.network === "eip155:8453" && paid.amount_atomic === "10000" && /^[0-9a-f]{12}$/.test(paid.payer_hash), "payment attempt recorded with network, amount and payer hash");
+    const serialized = JSON.stringify(listed.json);
+    assert.ok(!serialized.includes(PAYER.slice(2)) && !serialized.includes("9f9f9f9f9f"), "no full payer address or signature is ever stored");
+
+    // 5. Executor events: dedicated ingest token only.
+    const forbidden = await request(baseUrl, "POST", "/v1/operator/buyer-events/ingest", { body: { source: "xytara-mcp-executor", events: [] }, headers: operator });
+    assert.strictEqual(forbidden.status, 403, "the operator token cannot ingest; only the ingest token");
+    const ingested = await request(baseUrl, "POST", "/v1/operator/buyer-events/ingest", {
+      headers: { authorization: `Bearer ${INGEST}` },
+      body: {
+        source: "xytara-mcp-executor",
+        events: [
+          { stage: "challenge_issued", tool: "keccak256" },
+          { stage: "paid_ok", tool: "keccak256" },
+          { stage: "payment_settle", reason: "settle_outcome_unknown", fault: "upstream", tool: "summarize", money_moved: true, http_status: 200 }
+        ]
+      }
+    });
+    assert.strictEqual(ingested.status, 200);
+    assert.strictEqual(ingested.json.accepted, 3);
+
+    // 6. Summary: denominators and the attention flag.
+    const summary = await request(baseUrl, "GET", "/v1/operator/buyer-events/summary?days=7", { headers: operator });
+    assert.strictEqual(summary.status, 200);
+    assert.ok(summary.json.totals.failures >= 4, "failures counted");
+    assert.ok(summary.json.totals.challenges_issued >= 1 && summary.json.totals.paid_ok >= 1, "steps counted as denominators");
+    assert.strictEqual(summary.json.totals.money_moved, 1, "money moved without delivery is surfaced");
+    assert.strictEqual(summary.json.attention, true, "attention raised");
+
+    console.log("xytara verify:buyer-event-log passed");
+  } finally {
+    await new Promise((resolve) => 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);
+});

package/scripts/verify_buyer_safety.js

@@ -0,0 +1,141 @@
+"use strict";
+
+// End-to-end check (real local server) of the hosted-deploy money-safety policy:
+//  - strict paid execution: a task nothing can execute is refused up front (501, no 402, no charge),
+//    a missing task_ref is a 400, and an executable task still gets the normal 402 challenge;
+//  - strict credit spend: a bare account_id can never spend credits; the account's spend credential can;
+//  - credit spends accrue provider revenue on the units' purchase value, never on the catalog quote.
+
+const assert = require("assert");
+const { reconcileProviderSettlementAmount } = require("../lib/command_flow");
+const { buildTopupAccepts, topupUnitsForAccept } = require("../lib/buyer_safety_policy");
+
+const ACCEPTS = [
+  {
+    scheme: "exact",
+    network: "eip155:8453",
+    asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    amount: "10000",
+    payTo: "0x7cd2E0Ed2721319B20FAac4109774d030833F84D",
+    extra: { name: "USD Coin", version: "2" },
+    maxTimeoutSeconds: 60
+  },
+  {
+    scheme: "exact",
+    network: "eip155:84532",
+    asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    amount: "1000",
+    payTo: "0x7cd2E0Ed2721319B20FAac4109774d030833F84D",
+    extra: { name: "USDC", version: "2" },
+    maxTimeoutSeconds: 60
+  }
+];
+
+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 };
+}
+
+async function main() {
+  // Pure policy: top-up pricing and credit derivation.
+  const previousTestnet = process.env.XYTARA_X402_TESTNET_TOPUP;
+  delete process.env.XYTARA_X402_TESTNET_TOPUP;
+  const topupAccepts = buildTopupAccepts(ACCEPTS);
+  assert.deepStrictEqual(topupAccepts.map((a) => a.network), ["eip155:8453"], "testnet accepts cannot buy credits by default");
+  assert.strictEqual(topupAccepts[0].amount, "1000000", "a top-up costs 100x the per-call price ($1.00)");
+  assert.strictEqual(topupUnitsForAccept(topupAccepts[0]), 400, "$1.00 buys 400 credits at $0.0025");
+  assert.strictEqual(topupUnitsForAccept({ ...topupAccepts[0], extra: { credits: 1000000 } }), 400, "extra.credits can never exceed the paid value");
+  assert.strictEqual(topupUnitsForAccept({ ...topupAccepts[0], extra: { credits: 100 } }), 100, "extra.credits may lower the grant");
+  if (previousTestnet === undefined) delete process.env.XYTARA_X402_TESTNET_TOPUP; else process.env.XYTARA_X402_TESTNET_TOPUP = previousTestnet;
+
+  // Pure policy: credit-spend accrual basis.
+  const quote = { amount_minor: 40, currency: "USD_CENTS" };
+  const creditBasis = reconcileProviderSettlementAmount(quote, {
+    verification_mode: "account_credits",
+    payment_payload: { credit_spend_id: "cs_1", credit_units: 8, credit_unit_price_atomic: 2500 }
+  });
+  assert.strictEqual(creditBasis.settlement_basis, "credits_unit_value_min_quote");
+  assert.strictEqual(creditBasis.amount_minor, 2, "8 credits x $0.0025 = 2 cents accrue, not the 40-cent quote");
+
+  const OP = "buyer-safety-operator-token";
+  const BRIDGE = "buyer-safety-bridge-token";
+  const previous = {
+    exec: process.env.XYTARA_PAID_EXECUTION_POLICY,
+    credit: process.env.XYTARA_CREDIT_SPEND_POLICY,
+    op: process.env.XYTARA_ACCOUNT_AUTH_BEARER_TOKEN,
+    bridge: process.env.XYTARA_CREDIT_BRIDGE_BEARER_TOKEN,
+    mode: process.env.XYTARA_PAYMENT_VERIFICATION_MODE,
+    accepts: process.env.XYTARA_X402_ACCEPTS_JSON,
+    targets: process.env.XYTARA_EXECUTION_TARGETS_JSON
+  };
+  process.env.XYTARA_PAID_EXECUTION_POLICY = "strict";
+  process.env.XYTARA_CREDIT_SPEND_POLICY = "strict";
+  process.env.XYTARA_ACCOUNT_AUTH_BEARER_TOKEN = OP;
+  process.env.XYTARA_CREDIT_BRIDGE_BEARER_TOKEN = BRIDGE;
+  process.env.XYTARA_PAYMENT_VERIFICATION_MODE = "x402_facilitator";
+  process.env.XYTARA_X402_ACCEPTS_JSON = JSON.stringify(ACCEPTS);
+  // One operator-pinned target makes exactly one task executable (no network call happens before 402).
+  process.env.XYTARA_EXECUTION_TARGETS_JSON = JSON.stringify([
+    { target_id: "safety_target", task_ref: "adapter.mcp.invoke", endpoint_url: "http://127.0.0.1:9/execute" }
+  ]);
+
+  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. A catalog task with no execution target: refused before any payment is requested.
+    const notExecutable = await post(baseUrl, "/x402/commands/execute", { task_ref: "trust.verify", body: { subject_id: "s-1" } });
+    assert.strictEqual(notExecutable.status, 501, "non-executable task must be refused, not quoted");
+    assert.strictEqual(notExecutable.json.reason, "capability_not_executable");
+    assert.ok(notExecutable.json.executable_task_refs.includes("adapter.mcp.invoke"), "the refusal lists what IS executable");
+
+    // 2. Unknown task and missing task_ref.
+    const unknown = await post(baseUrl, "/x402/commands/execute", { task_ref: "nope.task" });
+    assert.strictEqual(unknown.status, 501, "unknown task must not be payable");
+    const missing = await post(baseUrl, "/x402/commands/execute", {});
+    assert.strictEqual(missing.status, 400, "missing task_ref must be a 400");
+    assert.strictEqual(missing.json.reason, "task_ref_required");
+
+    // 3. An executable task still gets the normal x402 challenge.
+    const executable = await post(baseUrl, "/x402/commands/execute", { task_ref: "adapter.mcp.invoke", body: { tool_name: "keccak256", arguments: { data: "abc" } } });
+    assert.strictEqual(executable.status, 402, "executable task must be quoted for payment");
+
+    // 4. Credits: a bare account_id can't spend, even with a balance.
+    const account = "acct_safety_owner";
+    const grant = await post(baseUrl, "/v1/credit-bridge/grants", { account_id: account, units: 50, source: "verify" }, { authorization: `Bearer ${BRIDGE}` });
+    assert.strictEqual(grant.status, 200, "operator grant must succeed");
+    const creditBody = { task_ref: "adapter.mcp.invoke", account_id: account, payment_preference: "credits_first", body: { tool_name: "keccak256", arguments: { data: "abc" } } };
+    const theft = await post(baseUrl, "/v1/commands/execute", creditBody);
+    assert.strictEqual(theft.status, 401, "spending another account's credits without its credential must be refused");
+    assert.strictEqual(theft.json.reason, "credit_spend_credential_required");
+
+    // 5. The account's own spend credential clears the credit gate (it then reaches execution,
+    //    which fails here because the pinned target is unreachable — and no credits are consumed).
+    const created = await post(baseUrl, "/v1/account-auth/spend-credentials", { account_id: account }, { authorization: `Bearer ${OP}` });
+    const cred = (created.json && created.json.spend_credential) || created.json;
+    assert.ok(cred && cred.bearer_token, "spend credential created");
+    const owned = await post(baseUrl, "/v1/commands/execute", creditBody, { authorization: `Bearer ${cred.bearer_token}` });
+    assert.notStrictEqual(owned.status, 401, "the owner's credential must clear the credit gate");
+    assert.strictEqual(owned.json && owned.json.credit_spend_status, "not_committed", "a failed execution must not consume credits");
+
+    // 6. A credential for one account can't be aimed at another.
+    const misaimed = await post(baseUrl, "/v1/commands/execute", { ...creditBody, account_id: "acct_someone_else" }, { authorization: `Bearer ${cred.bearer_token}` });
+    assert.strictEqual(misaimed.status, 403, "credential pinned to its own account");
+
+    console.log("xytara verify:buyer-safety passed");
+  } finally {
+    await new Promise((resolve) => server.close(resolve));
+    for (const [key, env] of [["exec", "XYTARA_PAID_EXECUTION_POLICY"], ["credit", "XYTARA_CREDIT_SPEND_POLICY"], ["op", "XYTARA_ACCOUNT_AUTH_BEARER_TOKEN"], ["bridge", "XYTARA_CREDIT_BRIDGE_BEARER_TOKEN"], ["mode", "XYTARA_PAYMENT_VERIFICATION_MODE"], ["accepts", "XYTARA_X402_ACCEPTS_JSON"], ["targets", "XYTARA_EXECUTION_TARGETS_JSON"]]) {
+      if (previous[key] === undefined) delete process.env[env]; else process.env[env] = previous[key];
+    }
+  }
+}
+
+main().catch((error) => {
+  console.error(error && error.stack ? error.stack : error);
+  process.exit(1);
+});

package/scripts/verify_cdp_facilitator.js

@@ -1,110 +1,110 @@
-"use strict";
-
-// Verifies the Coinbase CDP auth path for the x402 facilitator client: when a CDP Secret
-// API Key is configured, the client must mint a fresh, valid EdDSA Bearer JWT per request
-// (CDP rejects static tokens). A mock facilitator stands in for CDP and cryptographically
-// verifies the token's signature and claims before accepting the call. No real network/chain.
-
-const assert = require("assert");
-const http = require("http");
-const crypto = require("crypto");
-
-const { createFacilitatorClient } = require("../lib/x402_facilitator");
-const { loadPaymentConfig } = require("../lib/payment_config");
-
-// A throwaway Ed25519 key, exported as the base64 64-byte (seed||public) secret CDP uses.
-function makeCdpKey() {
-  const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
-  const seed = privateKey.export({ format: "der", type: "pkcs8" }).subarray(16); // last 32 bytes
-  const pub = publicKey.export({ format: "der", type: "spki" }).subarray(12); // last 32 bytes
-  return { publicKey, keySecret: Buffer.concat([seed, pub]).toString("base64") };
-}
-
-function startCdpMock(expectedPublicKey, seen) {
-  const server = http.createServer((req, res) => {
-    const chunks = [];
-    req.on("data", (c) => chunks.push(c));
-    req.on("end", () => {
-      const reply = (code, payload) => {
-        const text = JSON.stringify(payload);
-        res.writeHead(code, { "content-type": "application/json", "content-length": Buffer.byteLength(text) });
-        res.end(text);
-      };
-      const auth = String((req.headers.authorization || ""));
-      if (!auth.startsWith("Bearer ")) return reply(401, { error: "missing_bearer" });
-      const token = auth.slice("Bearer ".length);
-      const parts = token.split(".");
-      if (parts.length !== 3) return reply(401, { error: "malformed_jwt" });
-      const header = JSON.parse(Buffer.from(parts[0], "base64").toString("utf8"));
-      const claims = JSON.parse(Buffer.from(parts[1], "base64").toString("utf8"));
-      const sig = Buffer.from(parts[2].replace(/-/g, "+").replace(/_/g, "/"), "base64");
-      const signatureValid = crypto.verify(null, Buffer.from(`${parts[0]}.${parts[1]}`), expectedPublicKey, sig);
-      // Record what the facilitator observed so the test can assert on it.
-      seen.push({ header, claims, signatureValid, path: req.url, nonce: header.nonce });
-      if (header.alg !== "EdDSA") return reply(401, { error: "bad_alg" });
-      if (!signatureValid) return reply(401, { error: "bad_signature" });
-      if (claims.iss !== "cdp") return reply(401, { error: "bad_iss" });
-      if (!Array.isArray(claims.aud) || claims.aud[0] !== "cdp_service") return reply(401, { error: "bad_aud" });
-      const now = Math.floor(Date.now() / 1000);
-      if (!(claims.exp > now && claims.exp - claims.nbf <= 120)) return reply(401, { error: "bad_exp" });
-      if (!(claims.uri.startsWith("POST 127.0.0.1:") && claims.uri.endsWith(req.url))) return reply(401, { error: "bad_uri", uri: claims.uri });
-      if (req.url === "/verify") return reply(200, { isValid: true, payer: "0x2222222222222222222222222222222222222222" });
-      if (req.url === "/settle") return reply(200, { success: true, transaction: "0xcdpmocktx", network: "eip155:8453" });
-      return reply(404, { error: "not_found" });
-    });
-  });
-  return new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve({ server, port: server.address().port })));
-}
-
-const PAYLOAD = { x402Version: 2, accepted: { scheme: "exact" }, payload: { signature: "ok", authorization: {} } };
-const REQS = { scheme: "exact", network: "eip155:8453", asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", amount: "10000", payTo: "0xabc", resource: "https://x/y" };
-
-async function main() {
-  const { publicKey, keySecret } = makeCdpKey();
-  const seen = [];
-  const mock = await startCdpMock(publicKey, seen);
-  const baseUrl = `http://127.0.0.1:${mock.port}`;
-
-  try {
-    // 1. Config loader picks up the CDP env into config.x402.cdp.
-    const prev = { id: process.env.XYTARA_X402_CDP_KEY_ID, sec: process.env.XYTARA_X402_CDP_KEY_SECRET };
-    process.env.XYTARA_X402_CDP_KEY_ID = "11111111-2222-3333-4444-555555555555";
-    process.env.XYTARA_X402_CDP_KEY_SECRET = keySecret;
-    const cfg = loadPaymentConfig();
-    assert.ok(cfg.x402.cdp && cfg.x402.cdp.key_id === "11111111-2222-3333-4444-555555555555", "config must load CDP key id");
-    assert.strictEqual(cfg.x402.cdp.key_secret, keySecret, "config must load CDP key secret");
-
-    // 2. The client attaches a valid per-request Bearer that the mock CDP accepts.
-    const client = createFacilitatorClient({ url: baseUrl, cdp: cfg.x402.cdp, timeoutMs: 5000 });
-    const verify = await client.verify(PAYLOAD, REQS);
-    assert.strictEqual(verify.ok, true, "verify must succeed with a valid CDP Bearer");
-    assert.strictEqual(verify.json.isValid, true, "mock CDP must accept the token on /verify");
-    const settle = await client.settle(PAYLOAD, REQS);
-    assert.strictEqual(settle.ok, true, "settle must succeed with a valid CDP Bearer");
-    assert.strictEqual(settle.json.transaction, "0xcdpmocktx", "settle must return the mock tx");
-
-    // 3. Each request minted its own token (fresh nonce), signature valid, uri bound to the path.
-    assert.strictEqual(seen.length, 2, "mock must have seen two authenticated calls");
-    assert.ok(seen.every((e) => e.signatureValid), "every token signature must verify");
-    assert.notStrictEqual(seen[0].nonce, seen[1].nonce, "each request must mint a fresh token (distinct nonce)");
-    assert.ok(seen[0].claims.uri.endsWith("/verify") && seen[1].claims.uri.endsWith("/settle"), "uri claim must bind to each request path");
-
-    // 4. Without CDP creds, no Authorization header is sent (static-facilitator path unaffected).
-    const seen2 = [];
-    const mock2 = await startCdpMock(publicKey, seen2);
-    const plainClient = createFacilitatorClient({ url: `http://127.0.0.1:${mock2.port}`, timeoutMs: 5000 });
-    const plain = await plainClient.verify(PAYLOAD, REQS);
-    assert.strictEqual(plain.status, 401, "without CDP creds the mock sees no Bearer and rejects");
-    assert.strictEqual(seen2.length, 0, "no JWT should be minted when CDP is not configured");
-    await new Promise((r) => mock2.server.close(r));
-
-    if (prev.id === undefined) delete process.env.XYTARA_X402_CDP_KEY_ID; else process.env.XYTARA_X402_CDP_KEY_ID = prev.id;
-    if (prev.sec === undefined) delete process.env.XYTARA_X402_CDP_KEY_SECRET; else process.env.XYTARA_X402_CDP_KEY_SECRET = prev.sec;
-
-    console.log("xytara verify:cdp-facilitator passed");
-  } finally {
-    await new Promise((r) => mock.server.close(r));
-  }
-}
-
-main().catch((e) => { console.error(e && e.message ? e.message : e); process.exitCode = 1; });
+"use strict";
+
+// Verifies the Coinbase CDP auth path for the x402 facilitator client: when a CDP Secret
+// API Key is configured, the client must mint a fresh, valid EdDSA Bearer JWT per request
+// (CDP rejects static tokens). A mock facilitator stands in for CDP and cryptographically
+// verifies the token's signature and claims before accepting the call. No real network/chain.
+
+const assert = require("assert");
+const http = require("http");
+const crypto = require("crypto");
+
+const { createFacilitatorClient } = require("../lib/x402_facilitator");
+const { loadPaymentConfig } = require("../lib/payment_config");
+
+// A throwaway Ed25519 key, exported as the base64 64-byte (seed||public) secret CDP uses.
+function makeCdpKey() {
+  const { publicKey, privateKey } = crypto.generateKeyPairSync("ed25519");
+  const seed = privateKey.export({ format: "der", type: "pkcs8" }).subarray(16); // last 32 bytes
+  const pub = publicKey.export({ format: "der", type: "spki" }).subarray(12); // last 32 bytes
+  return { publicKey, keySecret: Buffer.concat([seed, pub]).toString("base64") };
+}
+
+function startCdpMock(expectedPublicKey, seen) {
+  const server = http.createServer((req, res) => {
+    const chunks = [];
+    req.on("data", (c) => chunks.push(c));
+    req.on("end", () => {
+      const reply = (code, payload) => {
+        const text = JSON.stringify(payload);
+        res.writeHead(code, { "content-type": "application/json", "content-length": Buffer.byteLength(text) });
+        res.end(text);
+      };
+      const auth = String((req.headers.authorization || ""));
+      if (!auth.startsWith("Bearer ")) return reply(401, { error: "missing_bearer" });
+      const token = auth.slice("Bearer ".length);
+      const parts = token.split(".");
+      if (parts.length !== 3) return reply(401, { error: "malformed_jwt" });
+      const header = JSON.parse(Buffer.from(parts[0], "base64").toString("utf8"));
+      const claims = JSON.parse(Buffer.from(parts[1], "base64").toString("utf8"));
+      const sig = Buffer.from(parts[2].replace(/-/g, "+").replace(/_/g, "/"), "base64");
+      const signatureValid = crypto.verify(null, Buffer.from(`${parts[0]}.${parts[1]}`), expectedPublicKey, sig);
+      // Record what the facilitator observed so the test can assert on it.
+      seen.push({ header, claims, signatureValid, path: req.url, nonce: header.nonce });
+      if (header.alg !== "EdDSA") return reply(401, { error: "bad_alg" });
+      if (!signatureValid) return reply(401, { error: "bad_signature" });
+      if (claims.iss !== "cdp") return reply(401, { error: "bad_iss" });
+      if (!Array.isArray(claims.aud) || claims.aud[0] !== "cdp_service") return reply(401, { error: "bad_aud" });
+      const now = Math.floor(Date.now() / 1000);
+      if (!(claims.exp > now && claims.exp - claims.nbf <= 120)) return reply(401, { error: "bad_exp" });
+      if (!(claims.uri.startsWith("POST 127.0.0.1:") && claims.uri.endsWith(req.url))) return reply(401, { error: "bad_uri", uri: claims.uri });
+      if (req.url === "/verify") return reply(200, { isValid: true, payer: "0x2222222222222222222222222222222222222222" });
+      if (req.url === "/settle") return reply(200, { success: true, transaction: "0xcdpmocktx", network: "eip155:8453" });
+      return reply(404, { error: "not_found" });
+    });
+  });
+  return new Promise((resolve) => server.listen(0, "127.0.0.1", () => resolve({ server, port: server.address().port })));
+}
+
+const PAYLOAD = { x402Version: 2, accepted: { scheme: "exact" }, payload: { signature: "ok", authorization: {} } };
+const REQS = { scheme: "exact", network: "eip155:8453", asset: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913", amount: "10000", payTo: "0xabc", resource: "https://x/y" };
+
+async function main() {
+  const { publicKey, keySecret } = makeCdpKey();
+  const seen = [];
+  const mock = await startCdpMock(publicKey, seen);
+  const baseUrl = `http://127.0.0.1:${mock.port}`;
+
+  try {
+    // 1. Config loader picks up the CDP env into config.x402.cdp.
+    const prev = { id: process.env.XYTARA_X402_CDP_KEY_ID, sec: process.env.XYTARA_X402_CDP_KEY_SECRET };
+    process.env.XYTARA_X402_CDP_KEY_ID = "11111111-2222-3333-4444-555555555555";
+    process.env.XYTARA_X402_CDP_KEY_SECRET = keySecret;
+    const cfg = loadPaymentConfig();
+    assert.ok(cfg.x402.cdp && cfg.x402.cdp.key_id === "11111111-2222-3333-4444-555555555555", "config must load CDP key id");
+    assert.strictEqual(cfg.x402.cdp.key_secret, keySecret, "config must load CDP key secret");
+
+    // 2. The client attaches a valid per-request Bearer that the mock CDP accepts.
+    const client = createFacilitatorClient({ url: baseUrl, cdp: cfg.x402.cdp, timeoutMs: 5000 });
+    const verify = await client.verify(PAYLOAD, REQS);
+    assert.strictEqual(verify.ok, true, "verify must succeed with a valid CDP Bearer");
+    assert.strictEqual(verify.json.isValid, true, "mock CDP must accept the token on /verify");
+    const settle = await client.settle(PAYLOAD, REQS);
+    assert.strictEqual(settle.ok, true, "settle must succeed with a valid CDP Bearer");
+    assert.strictEqual(settle.json.transaction, "0xcdpmocktx", "settle must return the mock tx");
+
+    // 3. Each request minted its own token (fresh nonce), signature valid, uri bound to the path.
+    assert.strictEqual(seen.length, 2, "mock must have seen two authenticated calls");
+    assert.ok(seen.every((e) => e.signatureValid), "every token signature must verify");
+    assert.notStrictEqual(seen[0].nonce, seen[1].nonce, "each request must mint a fresh token (distinct nonce)");
+    assert.ok(seen[0].claims.uri.endsWith("/verify") && seen[1].claims.uri.endsWith("/settle"), "uri claim must bind to each request path");
+
+    // 4. Without CDP creds, no Authorization header is sent (static-facilitator path unaffected).
+    const seen2 = [];
+    const mock2 = await startCdpMock(publicKey, seen2);
+    const plainClient = createFacilitatorClient({ url: `http://127.0.0.1:${mock2.port}`, timeoutMs: 5000 });
+    const plain = await plainClient.verify(PAYLOAD, REQS);
+    assert.strictEqual(plain.status, 401, "without CDP creds the mock sees no Bearer and rejects");
+    assert.strictEqual(seen2.length, 0, "no JWT should be minted when CDP is not configured");
+    await new Promise((r) => mock2.server.close(r));
+
+    if (prev.id === undefined) delete process.env.XYTARA_X402_CDP_KEY_ID; else process.env.XYTARA_X402_CDP_KEY_ID = prev.id;
+    if (prev.sec === undefined) delete process.env.XYTARA_X402_CDP_KEY_SECRET; else process.env.XYTARA_X402_CDP_KEY_SECRET = prev.sec;
+
+    console.log("xytara verify:cdp-facilitator passed");
+  } finally {
+    await new Promise((r) => mock.server.close(r));
+  }
+}
+
+main().catch((e) => { console.error(e && e.message ? e.message : e); process.exitCode = 1; });