x402-trust-layer 5.1.0

package/dist/client/demo-alchemy-live.js

@@ -0,0 +1,226 @@
+/**
+ * Live Alchemy x402 + Trust Layer demo.
+ *
+ * Prerequisites:
+ *   EVM_PRIVATE_KEY — Base wallet with ~$3 USDC (not your PAY_TO_EVM receive wallet)
+ *   Optional: ALCHEMY_DEMO_ENTERPRISE=1 for mandate + compliance ledger steps
+ *
+ * Run: npm run demo:alchemy
+ */
+import dotenv from "dotenv";
+import { getWalletAddress } from "@alchemy/x402";
+import { wrapFetch } from "@dexterai/x402/client";
+import { CHAIN_IDS } from "../lib/chains.js";
+import { alchemyX402Pay } from "../lib/alchemy-x402-fetch.js";
+import { assertDemoPayerNotReceiveWallet, assertPayerKeys, buildWrapFetchOptions, } from "../lib/x402-client-options.js";
+dotenv.config();
+const TRUST_BASE = (process.env.TRUST_LAYER_BASE ?? "https://x402trustlayer.xyz").replace(/\/$/, "");
+const ALCHEMY_GATEWAY = "https://x402.alchemy.com/base-mainnet/v2";
+const ALCHEMY_HOST = "x402.alchemy.com";
+const AGENT_ID = process.env.ALCHEMY_DEMO_AGENT_ID ?? "alchemy-live-demo-1";
+const ENTERPRISE = process.env.ALCHEMY_DEMO_ENTERPRISE === "1" || process.argv.includes("--enterprise");
+const ESTIMATED_ALCHEMY_USDC = Number(process.env.ALCHEMY_DEMO_CREDIT_USDC ?? "1");
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+const costs = [];
+function logStep(n, title) {
+    console.log(`\n${"=".repeat(60)}`);
+    console.log(`STEP ${n}: ${title}`);
+    console.log("=".repeat(60));
+}
+function trackCost(step, usdc, note) {
+    costs.push({ step, usdc, note });
+    console.log(`  💰 ~$${usdc.toFixed(2)} USDC — ${note}`);
+}
+async function main() {
+    console.log("Alchemy x402 + Trust Layer — LIVE demo");
+    console.log(`Trust Layer: ${TRUST_BASE}`);
+    console.log(`Alchemy gateway: ${ALCHEMY_GATEWAY}`);
+    console.log(`Enterprise mode: ${ENTERPRISE ? "ON (mandate + ledger)" : "OFF"}`);
+    console.log("");
+    if (!process.env.EVM_PRIVATE_KEY?.trim()) {
+        throw new Error("EVM_PRIVATE_KEY is required for Alchemy SIWE + Base USDC payments");
+    }
+    assertPayerKeys();
+    await assertDemoPayerNotReceiveWallet();
+    const evmKey = process.env.EVM_PRIVATE_KEY.trim();
+    const walletAddress = getWalletAddress(evmKey);
+    console.log(`Payer wallet: ${walletAddress}`);
+    const trustFetch = wrapFetch(fetch, {
+        ...buildWrapFetchOptions({ verbose: process.env.X402_VERBOSE === "1" }),
+        preferredNetwork: CHAIN_IDS.base,
+    });
+    async function trustPost(path, body, priceUsdc, label) {
+        const res = await trustFetch(`${TRUST_BASE}${path}`, {
+            method: "POST",
+            headers: { "content-type": "application/json" },
+            body: JSON.stringify(body),
+        });
+        const text = await res.text();
+        let json;
+        try {
+            json = text ? JSON.parse(text) : null;
+        }
+        catch {
+            json = { raw: text.slice(0, 500) };
+        }
+        if (!res.ok) {
+            throw new Error(`${path} HTTP ${res.status}: ${text.slice(0, 400)}`);
+        }
+        trackCost(label, priceUsdc, path);
+        return json;
+    }
+    let mandateId;
+    if (ENTERPRISE) {
+        logStep(1, "Mandate compile (human intent → signed scope)");
+        const mandate = await trustPost("/api/mandate/compile", {
+            principal: "demo:cfo",
+            agentId: AGENT_ID,
+            intent: "Query Alchemy blockchain data via x402 gateway for agent demo",
+            maxPerTxUsdc: 2,
+            dailyCapUsdc: 20,
+            allowedMerchants: [ALCHEMY_HOST],
+            allowedCategories: ["blockchain-data"],
+            allowedRails: ["base-x402"],
+            ttlMinutes: 1440,
+        }, 0.08, "mandate compile");
+        const mandateRecord = mandate.mandate && typeof mandate.mandate === "object"
+            ? mandate.mandate
+            : null;
+        mandateId =
+            (typeof mandateRecord?.mandateId === "string" && mandateRecord.mandateId) ||
+                (typeof mandate.mandateId === "string" ? mandate.mandateId : undefined);
+        if (!mandateId) {
+            throw new Error("Mandate compile did not return mandateId — check /api/mandate/compile response");
+        }
+        console.log(JSON.stringify({ mandateId, verifyUrl: mandate.verifyUrl }, null, 2));
+        logStep(2, "Mandate verify (proposed payment in scope?)");
+        const verify = await trustPost("/api/mandate/verify", {
+            mandateId,
+            proposed: {
+                amountUsdc: ESTIMATED_ALCHEMY_USDC,
+                merchant: ALCHEMY_HOST,
+                category: "blockchain-data",
+                rail: "base-x402",
+            },
+        }, 0.02, "mandate verify");
+        console.log(JSON.stringify({ withinScope: verify.withinScope, reason: verify.reason, violations: verify.violations }, null, 2));
+        if (verify.withinScope === false) {
+            throw new Error(`Mandate verify failed: ${String(verify.reason)}`);
+        }
+    }
+    const guardStep = ENTERPRISE ? 3 : 1;
+    logStep(guardStep, "Trust Layer guard — allowed to pay Alchemy?");
+    const guard = await trustPost("/api/guard/pre-x402", {
+        agentId: AGENT_ID,
+        walletAddress,
+        targetUrl: ALCHEMY_GATEWAY,
+        estimatedCostUsdc: ESTIMATED_ALCHEMY_USDC,
+        network: CHAIN_IDS.base,
+        policy: {
+            dailyCapUsdc: 20,
+            perCallCapUsdc: 2,
+            allowedHosts: [ALCHEMY_HOST],
+        },
+    }, 0.05, "guard pre-x402");
+    console.log(JSON.stringify({
+        allowed: guard.allowed,
+        securityGrade: guard.securityGrade,
+        summary: guard.summary,
+        confidence: guard.confidence,
+    }, null, 2));
+    if (guard.allowed !== true) {
+        throw new Error(`Guard blocked: ${String(guard.summary)}`);
+    }
+    const alchemyStep = guardStep + 1;
+    logStep(alchemyStep, "Alchemy x402 call — SIWE auth + USDC payment");
+    console.log("  Calling eth_blockNumber via x402.alchemy.com …");
+    const alchemyBody = JSON.stringify({
+        jsonrpc: "2.0",
+        method: "eth_blockNumber",
+        params: [],
+        id: 1,
+    });
+    const alchemyResult = await alchemyX402Pay(ALCHEMY_GATEWAY, alchemyBody, evmKey);
+    if (!alchemyResult.ok) {
+        throw new Error(`Alchemy payment failed HTTP ${alchemyResult.status}: ${alchemyResult.body.slice(0, 400)}`);
+    }
+    trackCost("Alchemy gateway credit", ESTIMATED_ALCHEMY_USDC, "x402.alchemy.com (~$1 credit purchase)");
+    let alchemyJson;
+    try {
+        alchemyJson = alchemyResult.body ? JSON.parse(alchemyResult.body) : null;
+    }
+    catch {
+        alchemyJson = {
+            raw: alchemyResult.body.slice(0, 300),
+            note: "USDC payment settled; full RPC may need SIWE auth on follow-up calls",
+        };
+    }
+    const payment = alchemyResult.payment;
+    console.log(JSON.stringify({ alchemyResult: alchemyJson, payment }, null, 2));
+    const txHash = payment?.transaction ?? payment?.txHash;
+    if (!txHash) {
+        console.warn("  ⚠ No PAYMENT-RESPONSE tx hash — receipt verify may use synthetic probe values");
+    }
+    const receiptStep = alchemyStep + 1;
+    logStep(receiptStep, "Receipt verify — on-chain settlement proof");
+    const receipt = await trustPost("/api/receipt-auditor/verify", {
+        network: CHAIN_IDS.base,
+        expectedAmountUsdc: payment?.amountUsdc ?? ESTIMATED_ALCHEMY_USDC,
+        transactionHash: txHash ?? "0x0000000000000000000000000000000000000000000000000000000000000001",
+        settlement: {
+            transaction: txHash ?? "0x0000000000000000000000000000000000000000000000000000000000000001",
+            amountUsdc: payment?.amountUsdc ?? ESTIMATED_ALCHEMY_USDC,
+            network: CHAIN_IDS.base,
+            payer: payment?.payer ?? walletAddress,
+        },
+    }, 0.05, "receipt verify");
+    console.log(JSON.stringify({ valid: receipt.valid, onChainMatch: receipt.onChainMatch }, null, 2));
+    if (ENTERPRISE) {
+        logStep(receiptStep + 1, "Compliance ledger — CFO audit export");
+        const period = new Date().toISOString().slice(0, 7);
+        const ledger = await trustPost("/api/compliance/ledger", {
+            organizationId: "alchemy-demo-org",
+            period,
+            records: [
+                {
+                    merchant: ALCHEMY_HOST,
+                    endpoint: "eth_blockNumber",
+                    amountUsdc: payment?.amountUsdc ?? ESTIMATED_ALCHEMY_USDC,
+                    rail: "base-x402",
+                    network: CHAIN_IDS.base,
+                    category: "blockchain-data",
+                    agentId: AGENT_ID,
+                    transactionHash: txHash,
+                    mandateId,
+                    timestamp: new Date().toISOString(),
+                },
+            ],
+        }, 0.12, "compliance ledger");
+        console.log(JSON.stringify({
+            ledgerHash: ledger.ledgerHash,
+            totalSpendUsdc: ledger.totalSpendUsdc,
+            policyViolations: ledger.policyViolations,
+        }, null, 2));
+    }
+    console.log(`\n${"=".repeat(60)}`);
+    console.log("COST SUMMARY (approximate USDC spent from your wallet)");
+    console.log("=".repeat(60));
+    let total = 0;
+    for (const c of costs) {
+        total += c.usdc;
+        console.log(`  ${c.step.padEnd(28)} $${c.usdc.toFixed(2).padStart(6)}  ${c.note}`);
+    }
+    console.log(`  ${"TOTAL".padEnd(28)} $${total.toFixed(2).padStart(6)}`);
+    console.log("\n✅ Live demo complete.");
+    if (txHash && txHash !== "0x0000000000000000000000000000000000000000000000000000000000000001") {
+        console.log(`   Basescan: https://basescan.org/tx/${txHash}`);
+    }
+}
+main().catch((err) => {
+    console.error("\n❌ Demo failed:", err instanceof Error ? err.message : err);
+    console.error("\nFix checklist:");
+    console.error("  1. EVM_PRIVATE_KEY set (NOT same as PAY_TO_EVM)");
+    console.error("  2. Wallet has USDC on Base (~$3 for full demo)");
+    console.error("  3. npm install (includes @alchemy/x402)");
+    process.exit(1);
+});

package/dist/client/demo-tail.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/demo-tail.js

@@ -0,0 +1,100 @@
+/**
+ * Re-run only the orchestration routes that often fail after a long `npm run demo` burst.
+ * Usage: npm run demo:tail
+ */
+import dotenv from "dotenv";
+import { CHAIN_IDS } from "../lib/chains.js";
+import { assertDemoPayerNotReceiveWallet, assertPayerKeys, buildWrapFetchOptions, buildX402Fetch, } from "../lib/x402-client-options.js";
+dotenv.config();
+const BASE = CHAIN_IDS.base;
+const base = process.env.PUBLIC_BASE_URL ?? "https://x402trustlayer.xyz";
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+assertPayerKeys();
+await assertDemoPayerNotReceiveWallet();
+const x402Fetch = await buildX402Fetch(fetch, buildWrapFetchOptions({ verbose: process.env.X402_VERBOSE === "1" }));
+console.log(`Demo tail target: ${base}\nPreferred network: ${CHAIN_IDS.base}\n`);
+const PAYMENT_RETRY_MATCH = /settlement failed|payment was rejected|insufficient balance|verification failed|facilitator/i;
+async function post(path, body) {
+    const maxAttempts = Number(process.env.DEMO_PAYMENT_MAX_ATTEMPTS ?? 3);
+    for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+        try {
+            const res = await x402Fetch(`${base}${path}`, {
+                method: "POST",
+                headers: { "content-type": "application/json" },
+                body: JSON.stringify(body),
+            });
+            const text = await res.text();
+            console.log(`--- ${path} (${res.status}) ---`);
+            console.log(text.slice(0, 900) + (text.length > 900 ? "..." : ""));
+            console.log();
+            return res.ok;
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (PAYMENT_RETRY_MATCH.test(msg) && attempt < maxAttempts) {
+                const wait = Number(process.env.DEMO_PAYMENT_RETRY_MS ?? 6_000) * attempt;
+                console.warn(`retry ${attempt}/${maxAttempts - 1} in ${wait}ms:`, msg);
+                await sleep(wait);
+                continue;
+            }
+            console.error(`FAILED ${path}:`, msg, "\n");
+            return false;
+        }
+    }
+    return false;
+}
+const stepDelay = () => sleep(Number(process.env.DEMO_STEP_DELAY_MS ?? 4_000));
+let ok = 0;
+const routes = [
+    [
+        "/api/facilitator/failover",
+        {
+            targetUrl: "https://api.myceliasignal.com/oracle/price/eth/usd",
+            preferNetwork: BASE,
+            fastProbe: true,
+        },
+    ],
+    [
+        "/api/router/route",
+        {
+            query: "ETH USD spot price oracle",
+            maxPriceUsdc: 0.1,
+            preferNetwork: BASE,
+            skipProbes: true,
+        },
+    ],
+    ["/api/mpp/session-plan", { action: "estimate", expectedCalls: 50, avgPricePerCallUsdc: 0.03 }],
+    [
+        "/api/receipt-auditor/verify",
+        {
+            network: BASE,
+            expectedAmountUsdc: 0.05,
+            transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000001",
+            settlement: {
+                transaction: "0x0000000000000000000000000000000000000000000000000000000000000001",
+                amountUsdc: 0.05,
+                network: BASE,
+            },
+        },
+    ],
+    ["/api/settlement-graph/next", { lastEndpointPath: "/api/spend-governor/check", lastTopic: "budget policy" }],
+    ["/api/refund-arbiter/evaluate", { verificationScore: 82, endpointReachable: true }],
+    [
+        "/api/budget-allocator/run",
+        {
+            fleetId: "fleet-alpha",
+            poolRemainingUsdc: 2,
+            agents: [
+                { agentId: "a1", priority: 10, requestedUsdc: 0.5, dailyRemainingUsdc: 5 },
+                { agentId: "a2", priority: 5, requestedUsdc: 1, dailyRemainingUsdc: 3 },
+            ],
+        },
+    ],
+];
+for (const [path, body] of routes) {
+    if (await post(path, body))
+        ok++;
+    await stepDelay();
+}
+console.log(`Tail demo: ${ok}/${routes.length} paid OK`);
+process.exit(ok === routes.length ? 0 : 1);

package/dist/client/demo.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/client/demo.js

@@ -0,0 +1,293 @@
+/**
+ * Full pipeline demo — pays for each x402 endpoint on your deployed suite.
+ */
+import dotenv from "dotenv";
+import { CHAIN_IDS } from "../lib/chains.js";
+const BASE = CHAIN_IDS.base;
+import { assertDemoPayerNotReceiveWallet, assertPayerKeys, buildWrapFetchOptions, buildX402Fetch, } from "../lib/x402-client-options.js";
+dotenv.config();
+const base = process.env.PUBLIC_BASE_URL ?? "http://127.0.0.1:3402";
+try {
+    assertPayerKeys();
+    await assertDemoPayerNotReceiveWallet();
+}
+catch (err) {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+}
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+async function assertServerUp() {
+    const res = await fetch(`${base}/health`);
+    if (!res.ok)
+        throw new Error(`health ${res.status}`);
+    const body = (await res.json());
+    console.log(`Health OK — ${body.endpointCount ?? "?"} endpoints`);
+    console.log(`Demo target: ${base}\n`);
+}
+await assertServerUp();
+const wrapOpts = buildWrapFetchOptions({ verbose: process.env.X402_VERBOSE === "1" });
+const x402Fetch = await buildX402Fetch(fetch, wrapOpts);
+const solRpc = wrapOpts.rpcUrls?.[CHAIN_IDS.solana];
+if (solRpc) {
+    console.log(`Solana RPC: ${solRpc} (avoids Dexter proxy StructError on USDC mint)\n`);
+}
+if (wrapOpts.preferredNetwork) {
+    console.log(`Preferred payment network: ${wrapOpts.preferredNetwork}\n`);
+}
+const PAYMENT_RETRY_MATCH = /settlement failed|payment was rejected|insufficient balance|verification failed|facilitator/i;
+const PAYMENT_MAX_ATTEMPTS = Number(process.env.DEMO_PAYMENT_MAX_ATTEMPTS ?? 3);
+const PAYMENT_RETRY_BASE_MS = Number(process.env.DEMO_PAYMENT_RETRY_MS ?? 6_000);
+const stepDelay = (ms = Number(process.env.DEMO_STEP_DELAY_MS ?? 3_500)) => sleep(ms);
+async function paidFetch(path, init, label = path) {
+    for (let attempt = 1; attempt <= PAYMENT_MAX_ATTEMPTS; attempt++) {
+        try {
+            return await x402Fetch(`${base}${path}`, init);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            const retryable = PAYMENT_RETRY_MATCH.test(msg);
+            if (retryable && attempt < PAYMENT_MAX_ATTEMPTS) {
+                const wait = PAYMENT_RETRY_BASE_MS * attempt;
+                console.warn(`--- ${label} payment retry ${attempt}/${PAYMENT_MAX_ATTEMPTS - 1} in ${wait}ms ---`, msg);
+                await sleep(wait);
+                continue;
+            }
+            console.error(`--- ${label} FAILED ---`, msg);
+            if (retryable) {
+                console.error("  Hint: long demo runs can hit transient Dexter facilitator limits. Retry one route:");
+                console.error(`  npm run demo:tail   (or wait 30s and re-run)\n`);
+                console.error("  Check Base wallet: USDC for payments + small ETH for Permit2 gas. X402_VERBOSE=1 for payment trace.\n");
+            }
+            else if (msg.includes("verification failed")) {
+                console.error("  Hint: transient facilitator glitch — retry usually succeeds (X402_VERBOSE=1 on server/client).\n");
+            }
+            else {
+                console.error();
+            }
+            return null;
+        }
+    }
+    return null;
+}
+async function post(path, body) {
+    const res = await paidFetch(path, {
+        method: "POST",
+        headers: { "content-type": "application/json" },
+        body: JSON.stringify(body),
+    }, path);
+    if (!res)
+        return null;
+    const text = await res.text();
+    let parsed = null;
+    try {
+        parsed = text ? JSON.parse(text) : null;
+    }
+    catch {
+        parsed = null;
+    }
+    console.log(`--- ${path} (${res.status}) ---`);
+    if (path === "/api/seller/audition-coach" && parsed && typeof parsed === "object") {
+        const coach = parsed;
+        console.log(JSON.stringify({
+            coached: coach.coached,
+            allowed: coach.allowed,
+            hostScoreEstimate: coach.hostScoreEstimate,
+            routeAuditCount: Array.isArray(coach.routeAudits) ? coach.routeAudits.length : 0,
+            confidence: coach.confidence,
+            summary: coach.summary,
+        }, null, 2));
+    }
+    else {
+        console.log(text.slice(0, 1200) + (text.length > 1200 ? "..." : ""));
+    }
+    console.log();
+    return parsed;
+}
+console.log("=== marketplace killers ===\n");
+await post("/api/market/buy-advisor", {
+    intent: "ETH USD spot price oracle",
+    agentId: "demo-fleet-1",
+    walletAddress: "9c7tE587KpGYBjiNQrjw3nGvxQHhSYKU4Ba6WRgQsHkt",
+    policy: { dailyCapUsdc: 10, perCallCapUsdc: 1 },
+    maxPriceUsdc: 0.15,
+    expectedCalls: 10,
+});
+await sleep(2000);
+await post("/api/seller/audition-coach", {
+    origin: base,
+    maxRoutes: 24,
+});
+await sleep(2000);
+console.log("=== v3 primary entrypoints ===\n");
+await post("/api/x402/proxy", {
+    agentId: "demo-fleet-1",
+    walletAddress: "9c7tE587KpGYBjiNQrjw3nGvxQHhSYKU4Ba6WRgQsHkt",
+    targetUrl: "https://api.myceliasignal.com/oracle/price/eth/usd",
+    estimatedCostUsdc: 0.05,
+    policy: { dailyCapUsdc: 10, perCallCapUsdc: 1 },
+    issueAttestation: true,
+});
+await sleep(2000);
+await post("/api/mpp/session", {
+    action: "open",
+    expectedCalls: 30,
+    avgPricePerCallUsdc: 0.03,
+    chain: "solana",
+    agentId: "demo-fleet-1",
+});
+await sleep(2000);
+const attestationIssue = await post("/api/attestation/issue", {
+    agentId: "demo-fleet-1",
+    walletAddress: "9c7tE587KpGYBjiNQrjw3nGvxQHhSYKU4Ba6WRgQsHkt",
+    targetUrl: "https://api.myceliasignal.com/oracle/price/eth/usd",
+    estimatedCostUsdc: 0.03,
+    policy: { dailyCapUsdc: 10, perCallCapUsdc: 1 },
+});
+await sleep(2000);
+const issuedAttestationId = attestationIssue &&
+    typeof attestationIssue === "object" &&
+    "attestation" in attestationIssue &&
+    attestationIssue.attestation &&
+    typeof attestationIssue.attestation === "object" &&
+    "attestationId" in attestationIssue.attestation &&
+    typeof attestationIssue.attestation.attestationId === "string"
+    ? attestationIssue.attestation.attestationId
+    : null;
+if (!issuedAttestationId) {
+    console.warn("Attestation issue did not return attestationId — verify step may fail.\n");
+}
+await post("/api/attestation/verify", {
+    attestationId: issuedAttestationId ?? "att_verifier_probe_example",
+});
+await sleep(3500);
+const regRes = await paidFetch("/api/attestation/registry", { method: "GET" });
+if (regRes) {
+    console.log("--- /api/attestation/registry GET ---", regRes.status, (await regRes.text()).slice(0, 800), "\n");
+}
+await sleep(2000);
+await post("/api/guard/pre-x402", {
+    agentId: "demo-fleet-1",
+    walletAddress: "9c7tE587KpGYBjiNQrjw3nGvxQHhSYKU4Ba6WRgQsHkt",
+    targetUrl: "https://api.myceliasignal.com/oracle/price/eth/usd",
+    estimatedCostUsdc: 0.05,
+    network: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+    policy: { dailyCapUsdc: 10, perCallCapUsdc: 1, allowedHosts: ["myceliasignal.com"] },
+});
+await sleep(2000);
+await post("/api/pipeline/execute", {
+    agentId: "demo-fleet-1",
+    walletAddress: "9c7tE587KpGYBjiNQrjw3nGvxQHhSYKU4Ba6WRgQsHkt",
+    targetUrl: "https://api.myceliasignal.com/oracle/price/eth/usd",
+    estimatedCostUsdc: 0.05,
+    policy: { dailyCapUsdc: 10, perCallCapUsdc: 1 },
+    task: "ETH oracle with guard and routing under one dollar",
+    maxBudgetUsdc: 1,
+    marketplaceQuery: "ETH USD spot price oracle",
+    preferNetwork: "solana",
+});
+await sleep(2000);
+await post("/api/payment-intent/compile", {
+    task: "ETH price check with risk scan and audit trail, max budget $1",
+    maxBudgetUsdc: 1,
+    agentId: "demo-fleet-1",
+    externalCallEstimateUsdc: 0.05,
+});
+await stepDelay(5_000);
+await post("/api/spend-governor/check", {
+    agentId: "demo-fleet-1",
+    estimatedCostUsdc: 0.5,
+    policy: { dailyCapUsdc: 10, perCallCapUsdc: 1 },
+});
+await stepDelay();
+await post("/api/identity-gate/check", {
+    walletAddress: "9c7tE587KpGYBjiNQrjw3nGvxQHhSYKU4Ba6WRgQsHkt",
+});
+await stepDelay();
+await post("/api/risk-gate/scan", {
+    targetUrl: "https://x402trustlayer.xyz/health",
+});
+await stepDelay(8_000);
+await post("/api/facilitator/failover", {
+    targetUrl: "https://api.myceliasignal.com/oracle/price/eth/usd",
+    preferNetwork: BASE,
+    fastProbe: true,
+});
+await stepDelay();
+await post("/api/router/route", {
+    query: "ETH USD spot price oracle",
+    maxPriceUsdc: 0.1,
+    preferNetwork: BASE,
+    skipProbes: true,
+});
+await stepDelay();
+await post("/api/mpp/session-plan", {
+    action: "estimate",
+    expectedCalls: 50,
+    avgPricePerCallUsdc: 0.03,
+});
+await stepDelay();
+await post("/api/receipt-auditor/verify", {
+    network: BASE,
+    expectedAmountUsdc: 0.05,
+    transactionHash: "0x0000000000000000000000000000000000000000000000000000000000000001",
+    settlement: {
+        transaction: "0x0000000000000000000000000000000000000000000000000000000000000001",
+        amountUsdc: 0.05,
+        network: BASE,
+        payer: "0x742d35Cc6634C0532925a3b844Bc454e4438f44e",
+    },
+});
+await stepDelay();
+await post("/api/settlement-graph/next", {
+    lastEndpointPath: "/api/spend-governor/check",
+    lastTopic: "budget policy",
+});
+await stepDelay();
+await post("/api/refund-arbiter/evaluate", {
+    verificationScore: 82,
+    endpointReachable: true,
+});
+await stepDelay();
+await post("/api/budget-allocator/run", {
+    fleetId: "fleet-alpha",
+    poolRemainingUsdc: 2,
+    agents: [
+        { agentId: "a1", priority: 10, requestedUsdc: 0.5, dailyRemainingUsdc: 5 },
+        { agentId: "a2", priority: 5, requestedUsdc: 1, dailyRemainingUsdc: 3 },
+    ],
+});
+await sleep(1500);
+await post("/api/quality-monitor/probe", {
+    urls: [
+        "https://x402trustlayer.xyz/health",
+        "https://api.myceliasignal.com/oracle/price/eth/usd",
+    ],
+});
+await sleep(1500);
+await post("/api/evidence-locker/export", {
+    organizationId: "demo-org",
+    records: [
+        {
+            endpoint: "/api/spend-governor/check",
+            amountUsdc: 0.03,
+            network: "solana",
+            timestamp: new Date().toISOString(),
+        },
+    ],
+});
+await sleep(1500);
+const escrowRes = await paidFetch("/api/agent-escrow", {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify({
+        action: "create",
+        payerAgentId: "agent-a",
+        payeeAgentId: "agent-b",
+        amountUsdc: 0.1,
+        releaseCondition: "receipt-auditor valid:true",
+    }),
+}, "/api/agent-escrow create");
+if (escrowRes) {
+    console.log("--- /api/agent-escrow create ---", escrowRes.status, await escrowRes.text(), "\n");
+}
+console.log("Full pipeline demo complete.");