xytara 3.1.16 → 3.2.0

package/scripts/verify_commerce_bridge.js

@@ -1,177 +0,0 @@
-"use strict";
-
-// Verifies the generic external-commerce bridge (/v1/commerce/*): an upstream fiat front
-// mints internal units for a confirmed purchase, then prepares a delegated-spend
-// credential for the paying customer's agent. Covers: bearer fail-closed/forbidden,
-// grants mint the mapped units + are idempotent per event (no double-mint on retry),
-// unknown package -> 422, prepare-execution authorizes + issues a credential when funded
-// and refuses when under-funded, and state reports the balance.
-
-const assert = require("assert");
-const http = require("http");
-
-async function req(baseUrl, method, path, body, headers = {}) {
-  const res = await fetch(`${baseUrl}${path}`, {
-    method,
-    headers: { "content-type": "application/json", ...headers },
-    ...(body !== undefined ? { body: JSON.stringify(body) } : {})
-  });
-  let json = null;
-  try { json = await res.json(); } catch (_) { json = null; }
-  return { status: res.status, json };
-}
-
-async function main() {
-  const prev = {
-    token: process.env.XYTARA_COMMERCE_BRIDGE_BEARER_TOKEN,
-    packMap: process.env.XYTARA_COMMERCE_PACK_MAP_JSON
-  };
-  const TOKEN = "test-commerce-bridge-token";
-  process.env.XYTARA_COMMERCE_BRIDGE_BEARER_TOKEN = TOKEN;
-  process.env.XYTARA_COMMERCE_PACK_MAP_JSON = JSON.stringify({ pkg_starter: 100, pkg_pro: 500 });
-  const auth = { authorization: `Bearer ${TOKEN}` };
-
-  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 ACCOUNT = "acct_commerce_test";
-
-  try {
-    // 1. Auth mandatory: no bearer / wrong bearer -> 403.
-    let r = await req(baseUrl, "POST", "/v1/commerce/grants", { accountRef: ACCOUNT, packageRef: "pkg_starter", eventRef: "evt_1" });
-    assert.strictEqual(r.status, 403, "grants without bearer must 403");
-    r = await req(baseUrl, "POST", "/v1/commerce/grants", { accountRef: ACCOUNT, packageRef: "pkg_starter", eventRef: "evt_1" }, { authorization: "Bearer wrong" });
-    assert.strictEqual(r.status, 403, "grants with wrong bearer must 403");
-
-    // 2. Grant mints the mapped units; response carries the upstream-read fields.
-    r = await req(baseUrl, "POST", "/v1/commerce/grants", { accountRef: ACCOUNT, packageRef: "pkg_starter", purchaseRef: "ord_1", providerRef: "txn_1", eventRef: "evt_1", orderType: "one_time", metadata: { checkoutSurface: "public_checkout" } }, auth);
-    assert.strictEqual(r.status, 200, "grant must 200");
-    assert.strictEqual(r.json.ok, true, "grant ok");
-    assert.strictEqual(r.json.units, 100, "mapped units minted");
-    assert.ok(typeof r.json.grantId === "string" && r.json.grantId.length > 0, "grantId returned");
-    assert.strictEqual(r.json.hiddenAccountRef, ACCOUNT, "hiddenAccountRef echoed");
-
-    // 3. State reflects the balance.
-    r = await req(baseUrl, "GET", `/v1/commerce/state?accountRef=${ACCOUNT}`, undefined, auth);
-    assert.strictEqual(r.status, 200, "state 200");
-    assert.strictEqual(r.json.availableUnits, 100, "balance = 100 after grant");
-
-    // 4. Idempotent per event: a webhook retry (same eventRef) must NOT double-mint.
-    r = await req(baseUrl, "POST", "/v1/commerce/grants", { accountRef: ACCOUNT, packageRef: "pkg_starter", purchaseRef: "ord_1", providerRef: "txn_1", eventRef: "evt_1" }, auth);
-    assert.strictEqual(r.status, 200, "replayed grant still 200");
-    const afterReplay = (await req(baseUrl, "GET", `/v1/commerce/state?accountRef=${ACCOUNT}`, undefined, auth)).json.availableUnits;
-    assert.strictEqual(afterReplay, 100, "replay must not double-mint (still 100)");
-
-    // 5. Unknown package -> 422.
-    r = await req(baseUrl, "POST", "/v1/commerce/grants", { accountRef: ACCOUNT, packageRef: "pkg_does_not_exist", eventRef: "evt_2" }, auth);
-    assert.strictEqual(r.status, 422, "unknown package must 422");
-    assert.strictEqual(r.json.reason, "unknown_package", "422 reason");
-
-    // 6. prepare-execution authorizes + issues a BOUND delegated-spend credential.
-    r = await req(baseUrl, "POST", "/v1/commerce/prepare-execution", { accountRef: ACCOUNT, featureRef: "doc.analyze", quotedUnits: 40 }, auth);
-    assert.strictEqual(r.status, 200, "prepare 200");
-    assert.strictEqual(r.json.authorized, true, "authorized when funded");
-    assert.ok(typeof r.json.spendAuthorityRef === "string" && r.json.spendAuthorityRef.length > 0, "spendAuthorityRef (binding) issued");
-    assert.ok(typeof r.json.spendAuthorityToken === "string" && r.json.spendAuthorityToken.length > 0, "agent-presentable token issued");
-    assert.strictEqual(r.json.boundUnits, 40, "credential is BOUND to the quote (not the whole balance)");
-    assert.ok(typeof r.json.validUntil === "string", "validUntil set");
-    assert.ok(Array.isArray(r.json.capabilitySummary) && r.json.capabilitySummary.includes("doc.analyze"), "capability summarized");
-
-    // 6b. A positive quote is required (an unbounded authorization is never issued).
-    r = await req(baseUrl, "POST", "/v1/commerce/prepare-execution", { accountRef: ACCOUNT, featureRef: "doc.analyze" }, auth);
-    assert.strictEqual(r.json.authorized, false, "no quote -> not authorized");
-    assert.strictEqual(r.json.authorityDecision, "quoted_units_required", "quote-required decision");
-
-    // 6c. A malformed agent key REFUSES rather than silently downgrading to bearer-only.
-    r = await req(baseUrl, "POST", "/v1/commerce/prepare-execution", { accountRef: ACCOUNT, featureRef: "doc.analyze", quotedUnits: 10, delegatedSpend: { agent_public_key: "not-a-real-key" } }, auth);
-    assert.strictEqual(r.json.authorized, false, "invalid agent key -> refuse");
-    assert.strictEqual(r.json.authorityDecision, "invalid_agent_key", "invalid_agent_key decision");
-
-    // 7. prepare-execution refuses when the quote exceeds the balance.
-    r = await req(baseUrl, "POST", "/v1/commerce/prepare-execution", { accountRef: ACCOUNT, featureRef: "doc.analyze", quotedUnits: 999999 }, auth);
-    assert.strictEqual(r.status, 200, "under-funded prepare still 200 (soft decision)");
-    assert.strictEqual(r.json.authorized, false, "not authorized when under-funded");
-    assert.strictEqual(r.json.authorityDecision, "insufficient_units", "decision surfaced");
-    assert.strictEqual(r.json.spendAuthorityRef, null, "no credential issued when refused");
-
-    // 8. account_ref required.
-    r = await req(baseUrl, "POST", "/v1/commerce/grants", { packageRef: "pkg_starter", eventRef: "evt_3" }, auth);
-    assert.strictEqual(r.status, 400, "missing accountRef must 400");
-    assert.strictEqual(r.json.reason, "account_ref_required", "400 reason");
-
-    // 8b. A SHARED eventRef across two accounts must NOT collide (each account minted).
-    const ACCOUNT_B = "acct_commerce_test_B";
-    await req(baseUrl, "POST", "/v1/commerce/grants", { accountRef: ACCOUNT, packageRef: "pkg_pro", eventRef: "shared_evt" }, auth);
-    await req(baseUrl, "POST", "/v1/commerce/grants", { accountRef: ACCOUNT_B, packageRef: "pkg_pro", eventRef: "shared_evt" }, auth);
-    const balB = (await req(baseUrl, "GET", `/v1/commerce/state?accountRef=${ACCOUNT_B}`, undefined, auth)).json.availableUnits;
-    assert.strictEqual(balB, 500, "account B minted its own units despite sharing eventRef with A (no grant_id collision)");
-
-    // 9. ENFORCEMENT: a credential bounded to a quote must actually be bounded at SPEND
-    //    time on the consume route, and cannot target another account.
-    const prep = await req(baseUrl, "POST", "/v1/commerce/prepare-execution", { accountRef: ACCOUNT, featureRef: "doc.analyze", quotedUnits: 40 }, auth);
-    const spendToken = prep.json.spendAuthorityToken;
-    assert.ok(spendToken && spendToken.startsWith("xytara_spend_"), "prepare issued a delegated spend token");
-    const spendAuth = { authorization: `Bearer ${spendToken}` };
-
-    // 9a. Over-quota spend is REJECTED (the quote is enforced, not just echoed).
-    let sp = await req(baseUrl, "POST", "/v1/economics/rails/credits/consume", { account_id: ACCOUNT, units: 50, task_ref: "doc.analyze" }, spendAuth);
-    assert.strictEqual(sp.status, 403, "consuming > quoted units must be rejected (bound enforced on consume)");
-    assert.strictEqual(sp.json.reason, "authority_consequence_bound_exceeded", "bound-exceeded reason");
-
-    // 9b. Targeting ANOTHER account with this credential is REJECTED (account pinned).
-    sp = await req(baseUrl, "POST", "/v1/economics/rails/credits/consume", { account_id: ACCOUNT_B, units: 10, task_ref: "doc.analyze" }, spendAuth);
-    assert.strictEqual(sp.status, 403, "a credential for account A cannot spend account B");
-    assert.strictEqual(sp.json.reason, "delegated_account_mismatch", "account-mismatch reason");
-
-    // 9c. A within-quote spend on the OWN account SUCCEEDS.
-    sp = await req(baseUrl, "POST", "/v1/economics/rails/credits/consume", { account_id: ACCOUNT, units: 30, task_ref: "doc.analyze" }, spendAuth);
-    assert.strictEqual(sp.status, 200, `within-quote spend must succeed (got ${sp.status}: ${JSON.stringify(sp.json).slice(0,160)})`);
-
-    // 10. SETTLE: trusted server-side consumption via the commerce bearer (the upstream
-    //     seam burns units after executing paid work; no delegated token involved).
-    const ACCOUNT_S = "acct_commerce_settle";
-    await req(baseUrl, "POST", "/v1/commerce/grants", { accountRef: ACCOUNT_S, packageRef: "pkg_pro", eventRef: "evt_settle" }, auth); // +500
-    // 10a. Settle requires the commerce bearer.
-    r = await req(baseUrl, "POST", "/v1/commerce/settle", { accountRef: ACCOUNT_S, units: 10 });
-    assert.strictEqual(r.status, 403, "settle without bearer must 403");
-    // 10b. account_ref + a positive unit count are required.
-    r = await req(baseUrl, "POST", "/v1/commerce/settle", { units: 10 }, auth);
-    assert.strictEqual(r.status, 400, "settle without accountRef must 400");
-    assert.strictEqual(r.json.reason, "account_ref_required", "settle 400 reason");
-    r = await req(baseUrl, "POST", "/v1/commerce/settle", { accountRef: ACCOUNT_S, units: 0 }, auth);
-    assert.strictEqual(r.status, 400, "settle without positive units must 400");
-    assert.strictEqual(r.json.reason, "units_required", "settle units reason");
-    // 10c. Over-balance settle is refused (balance is the hard cap).
-    r = await req(baseUrl, "POST", "/v1/commerce/settle", { accountRef: ACCOUNT_S, units: 999999, taskRef: "doc.analyze" }, auth);
-    assert.strictEqual(r.status, 409, "over-balance settle must 409");
-    assert.strictEqual(r.json.reason, "insufficient_credits", "settle insufficient reason");
-    // 10d. Within-balance settle burns units and returns the credit_spend/usage_meter shape.
-    r = await req(baseUrl, "POST", "/v1/commerce/settle", { accountRef: ACCOUNT_S, units: 200, taskRef: "doc.analyze", transactionRef: "txn_settle_1" }, auth);
-    assert.strictEqual(r.status, 200, `within-balance settle must 200 (got ${r.status}: ${JSON.stringify(r.json).slice(0,160)})`);
-    assert.strictEqual(r.json.ok, true, "settle ok");
-    assert.ok(r.json.credit_spend && typeof r.json.credit_spend.credit_spend_id === "string", "settle returns credit_spend");
-    assert.ok(typeof r.json.credit_spend.usage_meter_id === "string", "settle returns usage_meter_id");
-    const afterSettle = (await req(baseUrl, "GET", `/v1/commerce/state?accountRef=${ACCOUNT_S}`, undefined, auth)).json.availableUnits;
-    assert.strictEqual(afterSettle, 300, "settle burned 200 of 500 (300 left)");
-
-    // 9. Fail-closed when the bridge token is unset.
-    delete process.env.XYTARA_COMMERCE_BRIDGE_BEARER_TOKEN;
-    r = await req(baseUrl, "POST", "/v1/commerce/grants", { accountRef: ACCOUNT, packageRef: "pkg_starter", eventRef: "evt_4" }, auth);
-    assert.strictEqual(r.status, 403, "unset token must fail closed (403)");
-    assert.strictEqual(r.json.reason, "commerce_bridge_auth_not_configured", "fail-closed reason");
-
-    console.log("xytara verify:commerce-bridge passed");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-    const restore = (k, v) => { if (v === undefined) delete process.env[k]; else process.env[k] = v; };
-    restore("XYTARA_COMMERCE_BRIDGE_BEARER_TOKEN", prev.token);
-    restore("XYTARA_COMMERCE_PACK_MAP_JSON", prev.packMap);
-  }
-}
-
-main().catch((error) => {
-  console.error(error && error.message ? error.message : error);
-  process.exitCode = 1;
-});

package/scripts/verify_control_plane_contracts.js

@@ -1,34 +0,0 @@
-"use strict";
-
-const assert = require("assert");
-const {
-  summarizeAdapterCertificationContractPack,
-  summarizeTrustPortabilityBoundaryContractPack,
-  summarizeSignedAuditProvenanceContractPack
-} = require("../index.js");
-
-function main() {
-  const adapterCertification = summarizeAdapterCertificationContractPack();
-  const trustPortabilityBoundary = summarizeTrustPortabilityBoundaryContractPack();
-  const signedAuditProvenance = summarizeSignedAuditProvenanceContractPack();
-
-  assert.strictEqual(adapterCertification.ok, true, "adapter certification summary failed");
-  assert.strictEqual(adapterCertification.certification_state_count >= 5, true, "adapter certification state count mismatch");
-  assert.strictEqual(adapterCertification.certification_front_count >= 8, true, "adapter certification front count mismatch");
-  assert.strictEqual(adapterCertification.required_test_category_count >= 8, true, "adapter certification test category count mismatch");
-
-  assert.strictEqual(trustPortabilityBoundary.ok, true, "trust portability boundary summary failed");
-  assert.strictEqual(trustPortabilityBoundary.portable_axis_count >= 4, true, "trust portability axis count mismatch");
-  assert.strictEqual(trustPortabilityBoundary.non_claim_count >= 5, true, "trust portability non-claim count mismatch");
-  assert.strictEqual(trustPortabilityBoundary.evidence_requirement_count >= 5, true, "trust portability evidence requirement count mismatch");
-
-  assert.strictEqual(signedAuditProvenance.ok, true, "signed audit provenance summary failed");
-  assert.strictEqual(signedAuditProvenance.evidence_surface_count >= 6, true, "signed audit provenance surface count mismatch");
-  assert.strictEqual(signedAuditProvenance.required_field_count >= 7, true, "signed audit provenance required field count mismatch");
-  assert.strictEqual(signedAuditProvenance.export_rule_count >= 4, true, "signed audit provenance export rule count mismatch");
-
-  console.log("xytara verify:control-plane-contracts passed");
-}
-
-main();
-

package/scripts/verify_control_plane_routes.js

@@ -1,70 +0,0 @@
-"use strict";
-
-const assert = require("assert");
-const { createServer } = require("../server.js");
-
-async function getJson(baseUrl, route) {
-  const response = await fetch(`${baseUrl}${route}`);
-  return {
-    status: response.status,
-    json: await response.json()
-  };
-}
-
-async function main() {
-  const server = createServer();
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const address = server.address();
-  const baseUrl = `http://127.0.0.1:${address.port}`;
-
-  try {
-    const adapterCertification = await getJson(baseUrl, "/v1/adapter-certification");
-    assert.strictEqual(adapterCertification.status, 200, "adapter certification route failed");
-    assert.strictEqual(adapterCertification.json.category, "naxytra-adapter-certification-contract", "adapter certification category mismatch");
-    assert.strictEqual(adapterCertification.json.certification_fronts.length >= 8, true, "adapter certification front count mismatch");
-
-    const adapterCertificationSummary = await getJson(baseUrl, "/v1/adapter-certification/summary");
-    assert.strictEqual(adapterCertificationSummary.status, 200, "adapter certification summary route failed");
-    assert.strictEqual(adapterCertificationSummary.json.certification_state_count >= 5, true, "adapter certification summary count mismatch");
-
-    const adapterCertificationDetail = await getJson(baseUrl, "/v1/adapter-certification/protocol_front");
-    assert.strictEqual(adapterCertificationDetail.status, 200, "adapter certification detail route failed");
-    assert.strictEqual(adapterCertificationDetail.json.front.front_id, "protocol_front", "adapter certification detail mismatch");
-
-    const trustBoundary = await getJson(baseUrl, "/v1/trust-portability-boundary");
-    assert.strictEqual(trustBoundary.status, 200, "trust portability boundary route failed");
-    assert.strictEqual(trustBoundary.json.category, "naxytra-trust-portability-boundary-contract", "trust portability boundary category mismatch");
-    assert.strictEqual(trustBoundary.json.portable_axes.length >= 4, true, "trust portability boundary axis count mismatch");
-
-    const trustBoundarySummary = await getJson(baseUrl, "/v1/trust-portability-boundary/summary");
-    assert.strictEqual(trustBoundarySummary.status, 200, "trust portability boundary summary route failed");
-    assert.strictEqual(trustBoundarySummary.json.portable_axis_count >= 4, true, "trust portability boundary summary count mismatch");
-
-    const trustBoundaryDetail = await getJson(baseUrl, "/v1/trust-portability-boundary/agent_identity_portability");
-    assert.strictEqual(trustBoundaryDetail.status, 200, "trust portability boundary detail route failed");
-    assert.strictEqual(trustBoundaryDetail.json.axis.axis_id, "agent_identity_portability", "trust portability boundary detail mismatch");
-
-    const signedAudit = await getJson(baseUrl, "/v1/signed-audit-provenance");
-    assert.strictEqual(signedAudit.status, 200, "signed audit provenance route failed");
-    assert.strictEqual(signedAudit.json.category, "naxytra-signed-audit-provenance-contract", "signed audit provenance category mismatch");
-    assert.strictEqual(signedAudit.json.evidence_surfaces.length >= 6, true, "signed audit provenance evidence surface count mismatch");
-
-    const signedAuditSummary = await getJson(baseUrl, "/v1/signed-audit-provenance/summary");
-    assert.strictEqual(signedAuditSummary.status, 200, "signed audit provenance summary route failed");
-    assert.strictEqual(signedAuditSummary.json.evidence_surface_count >= 6, true, "signed audit provenance summary count mismatch");
-
-    const signedAuditDetail = await getJson(baseUrl, "/v1/signed-audit-provenance/release_provenance");
-    assert.strictEqual(signedAuditDetail.status, 200, "signed audit provenance detail route failed");
-    assert.strictEqual(signedAuditDetail.json.surface.surface_id, "release_provenance", "signed audit provenance detail mismatch");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-  }
-
-  console.log("xytara verify:control-plane-routes passed");
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});
-

package/scripts/verify_delivery_summary.js

@@ -1,112 +0,0 @@
-"use strict";
-
-const assert = require("assert");
-const { createServer } = require("../server");
-const {
-  buildDeliverySummaryPack,
-  summarizeDeliveryState
-} = require("../lib/delivery_summary_contract");
-
-async function getJson(baseUrl, routePath) {
-  const response = await fetch(`${baseUrl}${routePath}`);
-  return {
-    status: response.status,
-    json: await response.json()
-  };
-}
-
-async function main() {
-  const summary = summarizeDeliveryState({
-    deliveries: new Map([
-      [
-        "delivery_1",
-        {
-          delivery_id: "delivery_1",
-          status: "delivered",
-          callback_url: "https://agent.example/callbacks/demo",
-          callback_delivery: {
-            status: "delivered",
-            signature_mode: "hmac_sha256"
-          }
-        }
-      ],
-      [
-        "delivery_2",
-        {
-          delivery_id: "delivery_2",
-          status: "pending_delivery",
-          callback_url: null,
-          callback_delivery: null
-        }
-      ],
-      [
-        "delivery_3",
-        {
-          delivery_id: "delivery_3",
-          status: "delivered",
-          callback_url: "https://agent.example/callbacks/retry",
-          callback_delivery: {
-            status: "retrying",
-            signature_mode: "hmac_sha256"
-          }
-        }
-      ]
-    ])
-  });
-  const pack = buildDeliverySummaryPack({
-    deliveries: new Map([
-      [
-        "delivery_1",
-        {
-          delivery_id: "delivery_1",
-          status: "delivered",
-          callback_url: "https://agent.example/callbacks/demo",
-          callback_delivery: {
-            status: "delivered",
-            signature_mode: "hmac_sha256"
-          }
-        }
-      ]
-    ])
-  });
-
-  assert.strictEqual(pack.ok, true, "delivery summary pack should be ok");
-  assert.strictEqual(summary.delivery_count, 3, "delivery count mismatch");
-  assert.strictEqual(summary.callback_delivery_count, 2, "callback delivery count mismatch");
-  assert.strictEqual(summary.delivered_delivery_count, 2, "delivered count mismatch");
-  assert.strictEqual(summary.retrying_callback_delivery_count, 1, "retrying callback count mismatch");
-  assert.strictEqual(summary.signed_callback_delivery_count, 2, "signed callback count mismatch");
-
-  const server = createServer();
-  await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
-  const address = server.address();
-  const baseUrl = `http://127.0.0.1:${address.port}`;
-
-  try {
-    const response = await getJson(baseUrl, "/v1/deliveries/summary");
-    assert.strictEqual(response.status, 200, "delivery summary route failed");
-    assert.strictEqual(response.json.ok, true, "delivery summary ok missing");
-    assert.strictEqual(response.json.delivery_count >= 0, true, "delivery summary count missing");
-    assert.strictEqual(typeof response.json.callback_delivery_enabled, "boolean", "delivery summary callback posture missing");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-  }
-
-  console.log(JSON.stringify({
-    ok: true,
-    product: "xytara",
-    category: "machine-commerce-delivery-summary-verification",
-    verification_version: "xytara-delivery-summary-verification-v1",
-    delivery_count: summary.delivery_count,
-    callback_delivery_count: summary.callback_delivery_count,
-    delivered_delivery_count: summary.delivered_delivery_count,
-    retrying_callback_delivery_count: summary.retrying_callback_delivery_count,
-    signed_callback_delivery_count: summary.signed_callback_delivery_count,
-    boundary: "callback_delivery_posture_should_be_publicly_inspectable_and_counted"
-  }, null, 2));
-}
-
-main().catch((error) => {
-  console.error(error);
-  process.exit(1);
-});

package/scripts/verify_examples.js

@@ -1,19 +0,0 @@
-"use strict";
-
-const { spawnSync } = require("child_process");
-const path = require("path");
-
-function runExample(scriptPath) {
-  const result = spawnSync(process.execPath, [scriptPath], {
-    stdio: "inherit"
-  });
-  if (result.status !== 0) {
-    process.exit(result.status || 1);
-  }
-}
-
-runExample(path.join(__dirname, "..", "examples", "quickstart.js"));
-runExample(path.join(__dirname, "..", "examples", "export_carried_handoff.js"));
-runExample(path.join(__dirname, "..", "examples", "partner_launch_walkthrough.js"));
-runExample(path.join(__dirname, "..", "examples", "funded_runtime_walkthrough.js"));
-runExample(path.join(__dirname, "..", "examples", "adapter_review_walkthrough.js"));

package/scripts/verify_execution_dedupe.js

@@ -1,189 +0,0 @@
-"use strict";
-
-// Verifies the deferred-x402 execution dedupe guard:
-//   - two CONCURRENT commands carrying the SAME signed authorization (same EIP-3009
-//     nonce) against a slow executor result in exactly ONE execution and ONE settle;
-//     the duplicate is rejected 409 payment_authorization_in_progress and not charged;
-//   - a later command with a DIFFERENT authorization is not blocked;
-//   - unit level: the guard is a no-op for non-deferred verifications, fails open when
-//     the store is missing, rejects an in-flight duplicate, frees the slot on release,
-//     and prunes entries past their TTL.
-//
-// No real network or chain is used.
-
-const assert = require("assert");
-const http = require("http");
-const { claimDeferredExecution, releaseDeferredExecution, deferredAuthorizationKey } = require("../lib/execution_dedupe");
-
-const ACCEPTS = [
-  {
-    scheme: "exact",
-    network: "eip155:84532",
-    asset: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
-    amount: "1000",
-    payTo: "0x7cd2E0Ed2721319B20FAac4109774d030833F84D",
-    extra: { name: "USDC", version: "2" },
-    maxTimeoutSeconds: 60
-  }
-];
-
-function startMockServer() {
-  const calls = { verify: 0, settle: 0, execSlow: 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; return reply({ success: true, transaction: "0xmocktx", network: "eip155:84532", payer: "0x1111111111111111111111111111111111111111" }); }
-      if (req.method === "POST" && req.url === "/exec-slow") {
-        calls.execSlow += 1;
-        return setTimeout(() => reply({ ok: true, status: "completed", output: { value: "slow-ok" } }), 350);
-      }
-      if (req.method === "POST" && req.url === "/exec-fail") {
-        calls.execFail = (calls.execFail || 0) + 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(nonceHex) {
-  const accepted = ACCEPTS[0];
-  return Buffer.from(JSON.stringify({
-    x402Version: 2,
-    accepted,
-    payload: {
-      signature: "ok",
-      authorization: {
-        from: "0x1111111111111111111111111111111111111111",
-        to: accepted.payTo,
-        value: accepted.amount,
-        validAfter: "0",
-        validBefore: String(Math.floor(Date.now() / 1000) + 600),
-        nonce: nonceHex
-      }
-    }
-  }), "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, receipt: res.headers.get("payment-response") };
-}
-
-function runUnitChecks() {
-  // No-op for a non-deferred verification.
-  assert.deepStrictEqual(claimDeferredExecution({ inFlightPaymentAuthorizations: new Map() }, { ok: true }), { ok: true, key: null }, "non-deferred must be a no-op claim");
-  // Key derivation.
-  const verification = { deferred_settlement: { protocol: "x402_facilitator", authorization: { paymentPayload: { payload: { authorization: { from: "0xABC", nonce: "0xDEAD" } } } } } };
-  assert.strictEqual(deferredAuthorizationKey(verification), "x402:0xabc:0xdead", "key must be lowercased from:nonce");
-  // Fail open with no store.
-  assert.deepStrictEqual(claimDeferredExecution({}, verification), { ok: true, key: null }, "missing store must fail open");
-  // In-flight duplicate rejected, then freed on release.
-  const state = { inFlightPaymentAuthorizations: new Map() };
-  const first = claimDeferredExecution(state, verification);
-  assert.strictEqual(first.ok, true, "first claim must succeed");
-  const dup = claimDeferredExecution(state, verification);
-  assert.strictEqual(dup.ok, false, "second concurrent claim must be rejected");
-  assert.strictEqual(dup.status, 409, "duplicate must be 409");
-  assert.strictEqual(dup.reason, "payment_authorization_in_progress", "duplicate reason");
-  releaseDeferredExecution(state, first.key);
-  assert.strictEqual(claimDeferredExecution(state, verification).ok, true, "claim must succeed again after release");
-  // TTL prune: an expired entry is forgotten on the next claim.
-  const stale = { inFlightPaymentAuthorizations: new Map([["x402:0xabc:0xdead", { status: "in_flight", expires_at: Date.now() - 1 }]]) };
-  assert.strictEqual(claimDeferredExecution(stale, verification).ok, true, "an expired slot must be pruned and re-claimable");
-  console.log("  ok: unit checks (no-op, key, fail-open, duplicate, release, ttl-prune)");
-}
-
-async function main() {
-  runUnitChecks();
-
-  const mock = await startMockServer();
-  const mockBase = `http://127.0.0.1:${mock.port}`;
-  const prev = {
-    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_slow", task_ref: "exec.slow", endpoint_url: `${mockBase}/exec-slow` },
-    { 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}`;
-  const execBody = { account_id: "acct_dedupe", command: "slow exec", task_ref: "exec.slow", body: { subject_id: "s-1" } };
-
-  try {
-    // Two concurrent requests sharing ONE authorization (same nonce) -> one wins, one 409.
-    const sharedNonce = `0x${"ab".repeat(32)}`;
-    const [a, b] = await Promise.all([
-      post(baseUrl, "/x402/commands/execute", execBody, { "payment-signature": paymentHeader(sharedNonce) }),
-      post(baseUrl, "/x402/commands/execute", execBody, { "payment-signature": paymentHeader(sharedNonce) })
-    ]);
-    const statuses = [a.status, b.status].sort();
-    assert.deepStrictEqual(statuses, [200, 409], `exactly one must win and one must 409, got ${statuses}`);
-    const winner = a.status === 200 ? a : b;
-    const loser = a.status === 409 ? a : b;
-    assert.strictEqual(loser.json.reason, "payment_authorization_in_progress", "the duplicate must report in_progress");
-    assert.strictEqual(loser.json.payment_settled, false, "the rejected duplicate must not be charged");
-    assert.strictEqual(loser.receipt, null, "the rejected duplicate must carry no receipt");
-    assert.strictEqual(typeof winner.receipt, "string", "the winner must carry a settlement receipt");
-    assert.strictEqual(mock.calls.execSlow, 1, "the external target must have executed exactly once");
-    assert.strictEqual(mock.calls.settle, 1, "settlement must have happened exactly once");
-
-    // A different authorization (fresh nonce) is not blocked.
-    const other = await post(baseUrl, "/x402/commands/execute", execBody, { "payment-signature": paymentHeader(`0x${"cd".repeat(32)}`) });
-    assert.strictEqual(other.status, 200, "a distinct authorization must not be blocked");
-    assert.strictEqual(mock.calls.execSlow, 2, "the distinct authorization must execute");
-
-    console.log("  ok: concurrent same-authorization -> one execution, one settle, duplicate 409");
-
-    // Slot is released on a FAILED call, so a legitimate retry (even reusing the same
-    // still-unspent nonce) is not wrongly 409'd. Two SEQUENTIAL same-nonce calls to a
-    // failing executor must BOTH reach execution and neither be charged.
-    const failNonce = `0x${"ef".repeat(32)}`;
-    const failBody = { account_id: "acct_dedupe", command: "failing exec", task_ref: "exec.fail", body: { subject_id: "s-2" } };
-    const f1 = await post(baseUrl, "/x402/commands/execute", failBody, { "payment-signature": paymentHeader(failNonce) });
-    const f2 = await post(baseUrl, "/x402/commands/execute", failBody, { "payment-signature": paymentHeader(failNonce) });
-    assert.strictEqual(f1.status, 502, "first failing call must 502 (not 409)");
-    assert.strictEqual(f2.status, 502, "retry after failure must reach execution, not be blocked as a duplicate");
-    assert.strictEqual(f1.json.payment_settled, false, "failed call must not be charged");
-    assert.strictEqual(f2.json.payment_settled, false, "retry must not be charged");
-    assert.strictEqual(mock.calls.execFail, 2, "both failing attempts must have executed (slot released each time)");
-    console.log("  ok: failed call releases the slot -> retry not blocked, nothing charged");
-
-    console.log("xytara verify:execution-dedupe passed");
-  } finally {
-    await new Promise((resolve) => server.close(resolve));
-    await new Promise((resolve) => mock.server.close(resolve));
-    const restore = (k, v) => { if (v === undefined) delete process.env[k]; else process.env[k] = v; };
-    restore("XYTARA_PAYMENT_VERIFICATION_MODE", prev.mode);
-    restore("XYTARA_X402_ACCEPTS_JSON", prev.accepts);
-    restore("XYTARA_X402_FACILITATOR_URL", prev.facUrl);
-    restore("XYTARA_EXECUTION_TARGETS_JSON", prev.targets);
-  }
-}
-
-main().catch((error) => {
-  console.error(error && error.message ? error.message : error);
-  process.exitCode = 1;
-});