@elizaos/plugin-x402 2.0.0-alpha.1

package/typescript/dist/index.js

@@ -0,0 +1,1974 @@
+// actions/check-payment-history.ts
+import { logger } from "@elizaos/core";
+
+// utils.ts
+var ONE_DAY_MS = 24 * 60 * 60 * 1000;
+function formatUsd(baseUnits) {
+  const dollars = Number(baseUnits) / 1e6;
+  return `$${dollars.toFixed(2)}`;
+}
+function truncateAddress(address) {
+  if (address.length <= 10)
+    return address;
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
+}
+function usdToBaseUnits(usd) {
+  return BigInt(Math.round(usd * 1e6));
+}
+
+// actions/check-payment-history.ts
+var checkPaymentHistoryAction = {
+  name: "CHECK_PAYMENT_HISTORY",
+  description: "Check x402 payment history including spending summary and recent transactions. Use when asked about payment activity, spending, or earnings.",
+  similes: [
+    "check payments",
+    "payment history",
+    "spending summary",
+    "how much have I spent",
+    "payment transactions",
+    "show payments"
+  ],
+  parameters: [
+    {
+      name: "limit",
+      description: "Maximum number of recent transactions to show (default: 10)",
+      required: false,
+      schema: { type: "number" }
+    }
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("x402_payment");
+    return !!service && service.isActive();
+  },
+  handler: async (runtime, _message, _state, options, callback) => {
+    const service = runtime.getService("x402_payment");
+    if (!service || !service.isActive()) {
+      logger.warn("[x402] CHECK_PAYMENT_HISTORY: Service not available or inactive");
+      if (callback) {
+        await callback({
+          text: "Payment tracking is not active. The x402 payment service is not configured.",
+          actions: []
+        });
+      }
+      return { success: false, error: "x402 service not available" };
+    }
+    const params = options?.parameters;
+    const limit = typeof params?.limit === "number" ? params.limit : 10;
+    try {
+      const summary = await service.getSummary(ONE_DAY_MS);
+      const recentTxns = await service.getRecentTransactions(limit);
+      const lines = [];
+      const walletAddress = service.getWalletAddress();
+      const network = service.getNetwork();
+      lines.push(`**Payment Summary** (${network})`);
+      lines.push(`Wallet: ${walletAddress ? truncateAddress(walletAddress) : "N/A"}`);
+      lines.push("");
+      lines.push("**Last 24 Hours:**");
+      lines.push(`- Spent: ${formatUsd(summary.totalSpent)} (${summary.outgoingCount} transactions)`);
+      lines.push(`- Earned: ${formatUsd(summary.totalEarned)} (${summary.incomingCount} transactions)`);
+      const net = summary.totalEarned - summary.totalSpent;
+      const netDisplay = net < 0n ? `-${formatUsd(-net)}` : `+${formatUsd(net)}`;
+      lines.push(`- Net: ${netDisplay}`);
+      lines.push("");
+      lines.push(`Circuit Breaker: ${service.getCircuitBreakerState()}`);
+      lines.push("");
+      if (recentTxns.length > 0) {
+        lines.push(`**Recent Transactions** (last ${recentTxns.length}):`);
+        for (const txn of recentTxns) {
+          const direction = txn.direction === "outgoing" ? "SENT" : "RECV";
+          const counterpartyDisplay = truncateAddress(txn.counterparty);
+          const time = new Date(txn.createdAt).toLocaleString();
+          lines.push(`- [${direction}] ${formatUsd(txn.amount)} ${txn.direction === "outgoing" ? "to" : "from"} ${counterpartyDisplay} — ${txn.resource || "N/A"} (${time}) [${txn.status}]`);
+        }
+      } else {
+        lines.push("No recent transactions.");
+      }
+      const responseText = lines.join(`
+`);
+      if (callback) {
+        await callback({
+          text: responseText,
+          actions: []
+        });
+      }
+      return {
+        success: true,
+        text: responseText,
+        data: {
+          totalSpent: formatUsd(summary.totalSpent),
+          totalEarned: formatUsd(summary.totalEarned),
+          outgoingCount: summary.outgoingCount,
+          incomingCount: summary.incomingCount,
+          recentTransactionCount: recentTxns.length
+        }
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      logger.error(`[x402] CHECK_PAYMENT_HISTORY: Failed: ${errorMessage}`);
+      if (callback) {
+        await callback({
+          text: `Failed to retrieve payment history: ${errorMessage}`,
+          actions: []
+        });
+      }
+      return { success: false, error: errorMessage };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "user",
+        content: {
+          text: "How much have you spent today?"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "Let me check my payment history for today.",
+          actions: ["CHECK_PAYMENT_HISTORY"]
+        }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: {
+          text: "Show me your recent payment transactions"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "Here are my recent x402 payment transactions.",
+          actions: ["CHECK_PAYMENT_HISTORY"]
+        }
+      }
+    ]
+  ]
+};
+
+// actions/set-payment-policy.ts
+import { logger as logger2 } from "@elizaos/core";
+var setPaymentPolicyAction = {
+  name: "SET_PAYMENT_POLICY",
+  description: "Manage payment policies for the x402 payment service. Set per-transaction limits, daily spending limits, or block/allow specific recipient addresses.",
+  similes: [
+    "set payment policy",
+    "update payment limits",
+    "change spending limit",
+    "block recipient",
+    "allow recipient",
+    "set max payment",
+    "set daily limit",
+    "payment policy"
+  ],
+  parameters: [
+    {
+      name: "maxPerPaymentUsd",
+      description: "Maximum amount in USD for a single outgoing payment (e.g. 5.0 for $5.00)",
+      required: false,
+      schema: { type: "number" }
+    },
+    {
+      name: "maxDailyUsd",
+      description: "Maximum total USD spend per day (e.g. 50.0 for $50.00)",
+      required: false,
+      schema: { type: "number" }
+    },
+    {
+      name: "blockRecipient",
+      description: "Ethereum address to add to the blocklist (payments to this address will be rejected)",
+      required: false,
+      schema: { type: "string" }
+    },
+    {
+      name: "allowRecipient",
+      description: "Ethereum address to add to the allowlist (when allowlist is non-empty, only listed addresses can receive payments)",
+      required: false,
+      schema: { type: "string" }
+    }
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("x402_payment");
+    return !!service && service.isActive();
+  },
+  handler: async (runtime, _message, _state, options, callback) => {
+    const service = runtime.getService("x402_payment");
+    if (!service || !service.isActive()) {
+      logger2.warn("[x402] SET_PAYMENT_POLICY: Service not available or inactive");
+      if (callback) {
+        await callback({
+          text: "I'm unable to update payment policies right now. The x402 payment service is not configured or is inactive.",
+          actions: []
+        });
+      }
+      return { success: false, error: "x402 service not available" };
+    }
+    const rawParams = options?.parameters;
+    const maxPerPaymentUsd = rawParams?.maxPerPaymentUsd;
+    const maxDailyUsd = rawParams?.maxDailyUsd;
+    const blockRecipient = rawParams?.blockRecipient;
+    const allowRecipient = rawParams?.allowRecipient;
+    if (maxPerPaymentUsd === undefined && maxDailyUsd === undefined && !blockRecipient && !allowRecipient) {
+      if (callback) {
+        await callback({
+          text: "Please specify at least one policy change: maxPerPaymentUsd, maxDailyUsd, blockRecipient, or allowRecipient.",
+          actions: []
+        });
+      }
+      return { success: false, error: "No policy parameters provided" };
+    }
+    const changes = [];
+    try {
+      if (maxPerPaymentUsd !== undefined) {
+        if (maxPerPaymentUsd <= 0) {
+          if (callback) {
+            await callback({
+              text: "maxPerPaymentUsd must be a positive number.",
+              actions: []
+            });
+          }
+          return { success: false, error: "Invalid maxPerPaymentUsd" };
+        }
+        service.updatePolicy({
+          outgoing: {
+            maxPerTransaction: usdToBaseUnits(maxPerPaymentUsd)
+          }
+        });
+        changes.push(`Max per-payment limit set to $${maxPerPaymentUsd.toFixed(2)}`);
+        logger2.info(`[x402] SET_PAYMENT_POLICY: maxPerTransaction set to $${maxPerPaymentUsd}`);
+      }
+      if (maxDailyUsd !== undefined) {
+        if (maxDailyUsd <= 0) {
+          if (callback) {
+            await callback({
+              text: "maxDailyUsd must be a positive number.",
+              actions: []
+            });
+          }
+          return { success: false, error: "Invalid maxDailyUsd" };
+        }
+        service.updatePolicy({
+          outgoing: {
+            maxTotal: usdToBaseUnits(maxDailyUsd)
+          }
+        });
+        changes.push(`Daily spending limit set to $${maxDailyUsd.toFixed(2)}`);
+        logger2.info(`[x402] SET_PAYMENT_POLICY: maxTotal (daily) set to $${maxDailyUsd}`);
+      }
+      if (blockRecipient) {
+        service.updatePolicy({
+          outgoing: {
+            blockedRecipients: [blockRecipient]
+          }
+        });
+        changes.push(`Blocked recipient: ${blockRecipient}`);
+        logger2.info(`[x402] SET_PAYMENT_POLICY: blocked recipient ${blockRecipient}`);
+      }
+      if (allowRecipient) {
+        service.updatePolicy({
+          outgoing: {
+            allowedRecipients: [allowRecipient]
+          }
+        });
+        changes.push(`Added to allowlist: ${allowRecipient}`);
+        logger2.info(`[x402] SET_PAYMENT_POLICY: allowed recipient ${allowRecipient}`);
+      }
+      const summary = changes.join(`
+- `);
+      if (callback) {
+        await callback({
+          text: `Payment policy updated:
+- ${summary}`,
+          actions: []
+        });
+      }
+      return {
+        success: true,
+        text: `Payment policy updated: ${changes.join("; ")}`,
+        data: {
+          maxPerPaymentUsd: maxPerPaymentUsd ?? null,
+          maxDailyUsd: maxDailyUsd ?? null,
+          blockRecipient: blockRecipient ?? null,
+          allowRecipient: allowRecipient ?? null
+        }
+      };
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      logger2.error(`[x402] SET_PAYMENT_POLICY: Failed to update policy: ${errorMessage}`);
+      if (callback) {
+        await callback({
+          text: `Failed to update payment policy: ${errorMessage}`,
+          actions: []
+        });
+      }
+      return { success: false, error: errorMessage };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "user",
+        content: {
+          text: "Set the maximum payment per transaction to $5"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "I'll set the per-transaction limit to $5.00.",
+          actions: ["SET_PAYMENT_POLICY"]
+        }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: {
+          text: "Limit my daily spending to $50 and block payments to 0xDEAD...BEEF"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "I'll set the daily limit to $50 and block that address.",
+          actions: ["SET_PAYMENT_POLICY"]
+        }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: {
+          text: "Allow payments only to 0x1234567890abcdef1234567890abcdef12345678"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "Adding that address to the payment allowlist.",
+          actions: ["SET_PAYMENT_POLICY"]
+        }
+      }
+    ]
+  ]
+};
+
+// actions/pay-for-service.ts
+import { logger as logger3 } from "@elizaos/core";
+var payForServiceAction = {
+  name: "PAY_FOR_SERVICE",
+  description: "Make a request to an x402-protected URL, automatically paying if required. Use when you need to access a paid API or service that uses the x402 payment protocol.",
+  similes: [
+    "pay for service",
+    "x402 payment",
+    "make a paid request",
+    "access paid endpoint",
+    "pay and fetch"
+  ],
+  parameters: [
+    {
+      name: "url",
+      description: "The URL of the x402-protected service to access",
+      required: true,
+      schema: { type: "string" }
+    },
+    {
+      name: "method",
+      description: "HTTP method (GET, POST, etc.). Defaults to GET.",
+      required: false,
+      schema: {
+        type: "string",
+        enumValues: ["GET", "POST", "PUT", "DELETE"]
+      }
+    },
+    {
+      name: "body",
+      description: "Optional request body as a JSON string (for POST/PUT)",
+      required: false,
+      schema: { type: "string" }
+    }
+  ],
+  validate: async (runtime) => {
+    const service = runtime.getService("x402_payment");
+    return !!service && service.canMakePayments();
+  },
+  handler: async (runtime, message, _state, options, callback) => {
+    const service = runtime.getService("x402_payment");
+    if (!service || !service.canMakePayments()) {
+      logger3.warn("[x402] PAY_FOR_SERVICE: Service not available or inactive");
+      if (callback) {
+        await callback({
+          text: "I'm unable to make payments right now. The x402 payment service is not configured or is inactive.",
+          actions: []
+        });
+      }
+      return { success: false, error: "x402 service not available" };
+    }
+    const params = options?.parameters;
+    const url = params?.url ?? extractUrlFromMessage(message);
+    const method = params?.method ?? "GET";
+    const body = params?.body;
+    if (!url) {
+      logger3.warn("[x402] PAY_FOR_SERVICE: No URL provided");
+      if (callback) {
+        await callback({
+          text: "I need a URL to make the paid request. Please provide the URL of the service you want me to access.",
+          actions: []
+        });
+      }
+      return { success: false, error: "No URL provided" };
+    }
+    logger3.info(`[x402] PAY_FOR_SERVICE: Requesting ${method} ${url}`);
+    const payFetch = service.getFetchWithPayment();
+    try {
+      const init = { method };
+      if (body && (method === "POST" || method === "PUT")) {
+        init.body = body;
+        init.headers = { "Content-Type": "application/json" };
+      }
+      const response = await payFetch(url, init);
+      const contentType = response.headers.get("content-type") ?? "";
+      let responseText;
+      if (contentType.includes("application/json")) {
+        const json = await response.json();
+        responseText = JSON.stringify(json, null, 2);
+      } else {
+        responseText = await response.text();
+      }
+      const maxLen = 2000;
+      const truncated = responseText.length > maxLen ? `${responseText.slice(0, maxLen)}...
+[Truncated - ${responseText.length} total characters]` : responseText;
+      if (response.ok) {
+        logger3.info(`[x402] PAY_FOR_SERVICE: Success (${response.status}) from ${url}`);
+        if (callback) {
+          await callback({
+            text: `Successfully accessed ${url} (HTTP ${response.status}):
+
+${truncated}`,
+            actions: []
+          });
+        }
+        return {
+          success: true,
+          text: `Payment and request successful for ${url}`,
+          data: {
+            status: response.status,
+            url,
+            responsePreview: truncated
+          }
+        };
+      } else {
+        logger3.warn(`[x402] PAY_FOR_SERVICE: Request returned ${response.status} from ${url}`);
+        if (callback) {
+          await callback({
+            text: `Request to ${url} returned HTTP ${response.status}:
+
+${truncated}`,
+            actions: []
+          });
+        }
+        return {
+          success: false,
+          error: `HTTP ${response.status}`,
+          data: {
+            status: response.status,
+            url,
+            responsePreview: truncated
+          }
+        };
+      }
+    } catch (err) {
+      const errorMessage = err instanceof Error ? err.message : String(err);
+      logger3.error(`[x402] PAY_FOR_SERVICE: Request failed: ${errorMessage}`);
+      if (callback) {
+        await callback({
+          text: `Failed to access ${url}: ${errorMessage}`,
+          actions: []
+        });
+      }
+      return { success: false, error: errorMessage };
+    }
+  },
+  examples: [
+    [
+      {
+        name: "user",
+        content: {
+          text: "Can you fetch the data from https://api.example.com/premium/data? It's a paid API."
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "I'll access that paid API for you now.",
+          actions: ["PAY_FOR_SERVICE"]
+        }
+      }
+    ],
+    [
+      {
+        name: "user",
+        content: {
+          text: "Please make a paid request to https://weather.paid-api.com/forecast"
+        }
+      },
+      {
+        name: "assistant",
+        content: {
+          text: "Making a paid request to the weather API.",
+          actions: ["PAY_FOR_SERVICE"]
+        }
+      }
+    ]
+  ]
+};
+function extractUrlFromMessage(message) {
+  const text = typeof message.content === "string" ? message.content : message.content?.text;
+  if (!text)
+    return;
+  const urlRegex = /https?:\/\/[^\s<>"{}|\\^`[\]]+/g;
+  const matches = text.match(urlRegex);
+  return matches?.[0];
+}
+
+// providers/payment-balance.ts
+var paymentBalanceProvider = {
+  name: "x402_payment_status",
+  description: "Current x402 payment status including wallet, spending, and earning summary",
+  get: async (runtime, _message, _state) => {
+    const service = runtime.getService("x402_payment");
+    if (!service || !service.isActive()) {
+      return {
+        text: `[Payment Status]
+Payments: Inactive (no wallet configured)`,
+        values: {
+          x402Active: false
+        }
+      };
+    }
+    const walletAddress = service.getWalletAddress();
+    const network = service.getNetwork();
+    const summary = await service.getSummary(ONE_DAY_MS);
+    const netAmount = summary.totalEarned - summary.totalSpent;
+    const netDisplay = netAmount < 0n ? `-${formatUsd(-netAmount)}` : `+${formatUsd(netAmount)}`;
+    const statusLines = [
+      "[Payment Status]",
+      `Wallet: ${walletAddress ? truncateAddress(walletAddress) : "N/A"} (${network})`,
+      `24h Spent: ${formatUsd(summary.totalSpent)} (${summary.outgoingCount} txns)`,
+      `24h Earned: ${formatUsd(summary.totalEarned)} (${summary.incomingCount} txns)`,
+      `Net: ${netDisplay}`,
+      `Circuit Breaker: ${service.getCircuitBreakerState()}`
+    ];
+    return {
+      text: statusLines.join(`
+`),
+      values: {
+        x402Active: true,
+        x402Wallet: walletAddress ?? "",
+        x402Network: network,
+        x402TotalSpent: formatUsd(summary.totalSpent),
+        x402TotalEarned: formatUsd(summary.totalEarned),
+        x402OutgoingCount: summary.outgoingCount,
+        x402IncomingCount: summary.incomingCount
+      }
+    };
+  }
+};
+
+// networks.ts
+var NETWORK_REGISTRY = {
+  base: {
+    caip2: "eip155:8453",
+    chainId: 8453,
+    name: "Base",
+    usdcAddress: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    usdcDomainName: "USDC",
+    usdcPermitVersion: "2"
+  },
+  "base-sepolia": {
+    caip2: "eip155:84532",
+    chainId: 84532,
+    name: "Base Sepolia",
+    usdcAddress: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    usdcDomainName: "USDC",
+    usdcPermitVersion: "2"
+  },
+  ethereum: {
+    caip2: "eip155:1",
+    chainId: 1,
+    name: "Ethereum",
+    usdcAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    usdcDomainName: "USD Coin",
+    usdcPermitVersion: "2"
+  },
+  sepolia: {
+    caip2: "eip155:11155111",
+    chainId: 11155111,
+    name: "Sepolia",
+    usdcAddress: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    usdcDomainName: "USDC",
+    usdcPermitVersion: "2"
+  }
+};
+function resolveNetwork(key) {
+  const info = NETWORK_REGISTRY[key];
+  if (!info) {
+    const supported = Object.keys(NETWORK_REGISTRY).join(", ");
+    throw new Error(`Unknown network "${key}". Supported: ${supported}`);
+  }
+  return info;
+}
+function networkKeyFromCaip2(caip2) {
+  for (const [key, info] of Object.entries(NETWORK_REGISTRY)) {
+    if (info.caip2 === caip2) {
+      return key;
+    }
+  }
+  return;
+}
+
+// routes/agent-card.ts
+async function handleAgentCard(req, res, runtime) {
+  const service = runtime.getService("x402_payment");
+  if (!service || !service.isActive()) {
+    res.status(503).json({ error: "x402 service not active" });
+    return;
+  }
+  const walletAddress = service.getWalletAddress() ?? "";
+  const networkKey = service.getNetwork();
+  const facilitatorUrl = service.getFacilitatorUrl();
+  let caip2Network;
+  try {
+    const networkInfo = resolveNetwork(networkKey);
+    caip2Network = networkInfo.caip2;
+  } catch {
+    caip2Network = networkKey;
+  }
+  const character = runtime.character;
+  const agentName = character?.name ?? "ElizaOS Agent";
+  const agentDescription = (Array.isArray(character?.bio) ? character.bio[0] : character?.bio) ?? "An ElizaOS agent with x402 payment capabilities";
+  const configuredUrl = String(runtime.getSetting("X402_AGENT_URL") ?? "");
+  let agentUrl = configuredUrl;
+  if (!agentUrl && req.headers) {
+    const host = (Array.isArray(req.headers.host) ? req.headers.host[0] : req.headers.host) ?? "";
+    const proto = (Array.isArray(req.headers["x-forwarded-proto"]) ? req.headers["x-forwarded-proto"][0] : req.headers["x-forwarded-proto"]) ?? "https";
+    if (host) {
+      agentUrl = `${proto}://${host}`;
+    }
+  }
+  const skills = [];
+  const plugins = runtime.plugins ?? [];
+  for (const plugin of plugins) {
+    if (!plugin.routes)
+      continue;
+    for (const route of plugin.routes) {
+      const x402Config = "x402" in route ? route.x402 : undefined;
+      if (x402Config) {
+        skills.push({
+          name: ("name" in route ? route.name : undefined) ?? route.path,
+          description: x402Config.description ?? `Paid endpoint: ${route.path}`,
+          path: route.path,
+          price: x402Config.price,
+          network: x402Config.network
+        });
+      }
+    }
+  }
+  const card = {
+    protocolVersion: "1.0",
+    name: agentName,
+    description: agentDescription,
+    url: agentUrl,
+    capabilities: {
+      x402Payments: true
+    },
+    payments: [
+      {
+        method: "x402",
+        payee: walletAddress,
+        network: caip2Network,
+        facilitatorUrl
+      }
+    ],
+    skills
+  };
+  res.status(200).json(card);
+}
+var agentCardRoute = {
+  type: "GET",
+  path: "/.well-known/agent-card.json",
+  name: "x402-agent-card",
+  public: true,
+  handler: handleAgentCard
+};
+
+// services/x402-service.ts
+import { Service } from "@elizaos/core";
+import { logger as logger4 } from "@elizaos/core";
+
+// client/signer.ts
+import { privateKeyToAccount } from "viem/accounts";
+var PERMIT_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+
+class EvmPaymentSigner {
+  account;
+  network;
+  constructor(privateKey, network) {
+    const key = privateKey.startsWith("0x") ? privateKey : `0x${privateKey}`;
+    this.account = privateKeyToAccount(key);
+    this.network = network;
+  }
+  get address() {
+    return this.account.address;
+  }
+  get networkId() {
+    return resolveNetwork(this.network).caip2;
+  }
+  async signPermit(params) {
+    const networkInfo = resolveNetwork(this.network);
+    const domain = {
+      name: networkInfo.usdcDomainName,
+      version: networkInfo.usdcPermitVersion,
+      chainId: BigInt(networkInfo.chainId),
+      verifyingContract: networkInfo.usdcAddress
+    };
+    const message = {
+      owner: this.account.address,
+      spender: params.spender,
+      value: params.value,
+      nonce: params.nonce,
+      deadline: params.deadline
+    };
+    const signature = await this.account.signTypedData({
+      domain,
+      types: PERMIT_TYPES,
+      primaryType: "Permit",
+      message
+    });
+    const raw = signature.slice(2);
+    const r = `0x${raw.slice(0, 64)}`;
+    const s = `0x${raw.slice(64, 128)}`;
+    const v = parseInt(raw.slice(128, 130), 16);
+    return { v, r, s };
+  }
+  async buildPaymentHeader(requirement) {
+    const networkInfo = resolveNetwork(this.network);
+    const amount = BigInt(requirement.maxAmountRequired);
+    const tokenName = requirement.extra?.name ?? networkInfo.usdcDomainName;
+    const tokenVersion = requirement.extra?.version ?? networkInfo.usdcPermitVersion;
+    const nonce = BigInt(requirement.extra?.nonce ?? "0");
+    const deadline = BigInt(Math.floor(Date.now() / 1000) + requirement.maxTimeoutSeconds);
+    const spender = requirement.payTo;
+    const domain = {
+      name: tokenName,
+      version: tokenVersion,
+      chainId: BigInt(networkInfo.chainId),
+      verifyingContract: requirement.asset
+    };
+    const message = {
+      owner: this.account.address,
+      spender,
+      value: amount,
+      nonce,
+      deadline
+    };
+    const signature = await this.account.signTypedData({
+      domain,
+      types: PERMIT_TYPES,
+      primaryType: "Permit",
+      message
+    });
+    const payload = {
+      x402Version: 2,
+      accepted: {
+        scheme: "upto",
+        network: requirement.network,
+        asset: requirement.asset,
+        amount: requirement.maxAmountRequired,
+        payTo: requirement.payTo
+      },
+      payload: {
+        authorization: {
+          from: this.account.address,
+          to: requirement.payTo,
+          value: requirement.maxAmountRequired,
+          validBefore: deadline.toString(),
+          nonce: nonce.toString()
+        },
+        signature
+      }
+    };
+    const jsonString = JSON.stringify(payload);
+    return Buffer.from(jsonString).toString("base64");
+  }
+}
+
+// client/fetch-with-payment.ts
+function generateId() {
+  const timestamp = Date.now().toString(36);
+  const random = Math.random().toString(36).substring(2, 10);
+  return `x402_${timestamp}_${random}`;
+}
+function parsePaymentRequired(response) {
+  const headerValue = response.headers.get("payment-required") ?? response.headers.get("x-402") ?? response.headers.get("x-payment-required");
+  if (!headerValue) {
+    return null;
+  }
+  try {
+    const decoded = Buffer.from(headerValue, "base64").toString("utf-8");
+    return JSON.parse(decoded);
+  } catch {
+    try {
+      return JSON.parse(headerValue);
+    } catch {
+      return null;
+    }
+  }
+}
+function selectPaymentOption(accepts, signerNetworkId) {
+  const matching = accepts.find((a) => a.network === signerNetworkId);
+  return matching ?? null;
+}
+function createFetchWithPayment(options) {
+  const { signer, policyEngine, circuitBreaker, storage, logger: logger4 } = options;
+  return async function fetchWithPayment(input, init) {
+    const url = typeof input === "string" ? input : input instanceof URL ? input.toString() : input.url;
+    logger4.debug(`[x402] Making request to ${url}`);
+    const initialResponse = await fetch(input, init);
+    if (initialResponse.status !== 402) {
+      return initialResponse;
+    }
+    logger4.info(`[x402] Received 402 Payment Required from ${url}`);
+    const paymentRequired = parsePaymentRequired(initialResponse);
+    if (!paymentRequired) {
+      logger4.error("[x402] Could not parse payment requirement header from 402 response");
+      return initialResponse;
+    }
+    if (!paymentRequired.accepts || paymentRequired.accepts.length === 0) {
+      logger4.error("[x402] No payment options in 402 response");
+      return initialResponse;
+    }
+    const requirement = selectPaymentOption(paymentRequired.accepts, signer.networkId);
+    if (!requirement) {
+      logger4.error("[x402] No compatible payment option found");
+      return initialResponse;
+    }
+    const amount = BigInt(requirement.maxAmountRequired);
+    logger4.info(`[x402] Payment required: ${amount} to ${requirement.payTo} on ${requirement.network}`);
+    const policyResult = await policyEngine.evaluateOutgoing({
+      amount,
+      recipient: requirement.payTo,
+      resource: url
+    });
+    if (!policyResult.allowed) {
+      logger4.warn(`[x402] Payment blocked by policy: ${policyResult.reason}`);
+      return initialResponse;
+    }
+    const breakerResult = circuitBreaker.check(amount);
+    if (!breakerResult.allowed) {
+      logger4.warn(`[x402] Payment blocked by circuit breaker: ${breakerResult.reason}`);
+      return initialResponse;
+    }
+    let paymentHeader;
+    try {
+      paymentHeader = await signer.buildPaymentHeader(requirement);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger4.error(`[x402] Failed to sign payment: ${message}`);
+      circuitBreaker.recordFailure();
+      return initialResponse;
+    }
+    logger4.info("[x402] Retrying request with X-PAYMENT header");
+    const retryHeaders = new Headers(init?.headers);
+    retryHeaders.set("X-PAYMENT", paymentHeader);
+    const retryInit = {
+      ...init,
+      headers: retryHeaders
+    };
+    let retryResponse;
+    try {
+      retryResponse = await fetch(input, retryInit);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger4.error(`[x402] Retry request failed: ${message}`);
+      circuitBreaker.recordFailure();
+      return initialResponse;
+    }
+    const sessionId = retryResponse.headers.get("x-upto-session-id") ?? retryResponse.headers.get("X-PAYMENT-RESPONSE") ?? "";
+    const record = {
+      id: generateId(),
+      direction: "outgoing",
+      counterparty: requirement.payTo,
+      amount,
+      network: requirement.network,
+      txHash: sessionId,
+      resource: url,
+      status: retryResponse.ok ? "confirmed" : "failed",
+      createdAt: new Date().toISOString(),
+      metadata: {
+        scheme: requirement.scheme,
+        description: requirement.description
+      }
+    };
+    try {
+      await storage.recordPayment(record);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger4.error(`[x402] Failed to record payment: ${message}`);
+    }
+    if (retryResponse.ok) {
+      circuitBreaker.recordSuccess(amount);
+      logger4.info(`[x402] Payment successful: ${amount} to ${requirement.payTo}`);
+    } else {
+      circuitBreaker.recordFailure();
+      logger4.warn(`[x402] Payment request returned ${retryResponse.status} after payment`);
+    }
+    return retryResponse;
+  };
+}
+
+// policy/circuit-breaker.ts
+var DEFAULT_CONFIG = {
+  maxPaymentsPerMinute: 50,
+  anomalyMultiplier: 10,
+  cooldownMs: 60000,
+  recentWindowSize: 20
+};
+
+class CircuitBreaker {
+  state = "closed";
+  config;
+  recentTimestamps = [];
+  recentAmounts = [];
+  trippedAt = 0;
+  lastTripReason = "";
+  constructor(config) {
+    this.config = { ...DEFAULT_CONFIG, ...config };
+  }
+  check(amount) {
+    const now = Date.now();
+    if (this.state === "open") {
+      if (now - this.trippedAt >= this.config.cooldownMs) {
+        this.state = "half-open";
+      } else {
+        return {
+          allowed: false,
+          reason: `Circuit breaker is OPEN: ${this.lastTripReason}. Resets in ${Math.ceil((this.config.cooldownMs - (now - this.trippedAt)) / 1000)}s`
+        };
+      }
+    }
+    const oneMinuteAgo = now - 60000;
+    this.recentTimestamps = this.recentTimestamps.filter((t) => t > oneMinuteAgo);
+    if (this.recentTimestamps.length >= this.config.maxPaymentsPerMinute) {
+      this.trip(`Rate exceeded: ${this.recentTimestamps.length} payments in the last minute`);
+      return { allowed: false, reason: this.lastTripReason };
+    }
+    if (this.recentAmounts.length >= 3) {
+      const sum = this.recentAmounts.reduce((a, b) => a + b, 0n);
+      const avg = sum / BigInt(this.recentAmounts.length);
+      if (avg > 0n && amount > avg * BigInt(this.config.anomalyMultiplier)) {
+        this.trip(`Anomaly detected: payment of ${amount} is >${this.config.anomalyMultiplier}x the average of ${avg}`);
+        return { allowed: false, reason: this.lastTripReason };
+      }
+    }
+    return { allowed: true, reason: "" };
+  }
+  recordSuccess(amount) {
+    const now = Date.now();
+    this.recentTimestamps.push(now);
+    this.recentAmounts.push(amount);
+    if (this.recentAmounts.length > this.config.recentWindowSize) {
+      this.recentAmounts.shift();
+    }
+    if (this.state === "half-open") {
+      this.state = "closed";
+      this.lastTripReason = "";
+    }
+  }
+  recordFailure() {
+    if (this.state === "half-open") {
+      this.trip("Probe payment failed in half-open state");
+    }
+  }
+  getState() {
+    return this.state;
+  }
+  getTripReason() {
+    return this.lastTripReason;
+  }
+  reset() {
+    this.state = "closed";
+    this.lastTripReason = "";
+    this.trippedAt = 0;
+  }
+  trip(reason) {
+    this.state = "open";
+    this.trippedAt = Date.now();
+    this.lastTripReason = reason;
+  }
+}
+
+// policy/engine.ts
+var ALLOW = { allowed: true, reason: "" };
+function deny(reason) {
+  return { allowed: false, reason };
+}
+
+class PolicyEngine {
+  policy;
+  storage;
+  constructor(policy, storage) {
+    this.policy = policy;
+    this.storage = storage;
+  }
+  updatePolicy(partial) {
+    if (partial.outgoing) {
+      this.policy.outgoing = { ...this.policy.outgoing, ...partial.outgoing };
+    }
+    if (partial.incoming) {
+      this.policy.incoming = { ...this.policy.incoming, ...partial.incoming };
+    }
+  }
+  getPolicy() {
+    return {
+      outgoing: { ...this.policy.outgoing },
+      incoming: { ...this.policy.incoming }
+    };
+  }
+  async evaluateOutgoing(request) {
+    const limits = this.policy.outgoing;
+    if (request.amount > limits.maxPerTransaction) {
+      return deny(`Amount ${request.amount} exceeds per-transaction limit of ${limits.maxPerTransaction}`);
+    }
+    if (limits.blockedRecipients.length > 0) {
+      const normalized = request.recipient.toLowerCase();
+      if (limits.blockedRecipients.some((addr) => addr.toLowerCase() === normalized)) {
+        return deny(`Recipient ${request.recipient} is blocked`);
+      }
+    }
+    if (limits.allowedRecipients.length > 0) {
+      const normalized = request.recipient.toLowerCase();
+      if (!limits.allowedRecipients.some((addr) => addr.toLowerCase() === normalized)) {
+        return deny(`Recipient ${request.recipient} is not in the allow list`);
+      }
+    }
+    const currentTotal = await this.storage.getTotal("outgoing", limits.windowMs);
+    if (currentTotal + request.amount > limits.maxTotal) {
+      return deny(`Total spend would be ${currentTotal + request.amount}, exceeding window limit of ${limits.maxTotal}`);
+    }
+    const currentCount = await this.storage.getCount("outgoing", limits.windowMs);
+    if (currentCount >= limits.maxTransactions) {
+      return deny(`Transaction count ${currentCount} has reached the limit of ${limits.maxTransactions}`);
+    }
+    return ALLOW;
+  }
+  async evaluateIncoming(request) {
+    const limits = this.policy.incoming;
+    if (request.amount < limits.minPerTransaction) {
+      return deny(`Amount ${request.amount} is below minimum of ${limits.minPerTransaction}`);
+    }
+    if (limits.blockedSenders.length > 0) {
+      const normalized = request.sender.toLowerCase();
+      if (limits.blockedSenders.some((addr) => addr.toLowerCase() === normalized)) {
+        return deny(`Sender ${request.sender} is blocked`);
+      }
+    }
+    if (limits.allowedSenders.length > 0) {
+      const normalized = request.sender.toLowerCase();
+      if (!limits.allowedSenders.some((addr) => addr.toLowerCase() === normalized)) {
+        return deny(`Sender ${request.sender} is not in the allow list`);
+      }
+    }
+    return ALLOW;
+  }
+}
+
+// storage/memory.ts
+class MemoryPaymentStorage {
+  records = [];
+  async recordPayment(record) {
+    this.records.push({
+      ...record,
+      metadata: { ...record.metadata }
+    });
+  }
+  async getTotal(direction, windowMs, scope) {
+    const cutoff = windowMs ? new Date(Date.now() - windowMs).toISOString() : undefined;
+    let total = 0n;
+    for (const r of this.records) {
+      if (r.direction !== direction)
+        continue;
+      if (cutoff && r.createdAt < cutoff)
+        continue;
+      if (scope && r.counterparty !== scope)
+        continue;
+      if (r.status === "failed" || r.status === "refunded")
+        continue;
+      total += r.amount;
+    }
+    return total;
+  }
+  async getRecords(filters) {
+    let result = [...this.records];
+    if (filters) {
+      if (filters.direction) {
+        result = result.filter((r) => r.direction === filters.direction);
+      }
+      if (filters.counterparty) {
+        result = result.filter((r) => r.counterparty.toLowerCase() === filters.counterparty.toLowerCase());
+      }
+      if (filters.status) {
+        result = result.filter((r) => r.status === filters.status);
+      }
+      if (filters.network) {
+        result = result.filter((r) => r.network === filters.network);
+      }
+      if (filters.since) {
+        result = result.filter((r) => r.createdAt >= filters.since);
+      }
+      if (filters.until) {
+        result = result.filter((r) => r.createdAt <= filters.until);
+      }
+    }
+    result.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
+    const offset = filters?.offset ?? 0;
+    const limit = filters?.limit ?? result.length;
+    return result.slice(offset, offset + limit);
+  }
+  async getCount(direction, windowMs) {
+    const cutoff = windowMs ? new Date(Date.now() - windowMs).toISOString() : undefined;
+    let count = 0;
+    for (const r of this.records) {
+      if (r.direction !== direction)
+        continue;
+      if (cutoff && r.createdAt < cutoff)
+        continue;
+      if (r.status === "failed" || r.status === "refunded")
+        continue;
+      count++;
+    }
+    return count;
+  }
+  async clear() {
+    this.records = [];
+  }
+}
+
+// storage/sqlite.ts
+import Database from "better-sqlite3";
+
+class SqlitePaymentStorage {
+  db;
+  constructor(dbPath) {
+    this.db = new Database(dbPath);
+    this.db.pragma("journal_mode = WAL");
+    this.db.pragma("foreign_keys = ON");
+    this.initialize();
+  }
+  initialize() {
+    this.db.exec(`
+      CREATE TABLE IF NOT EXISTS x402_payments (
+        id TEXT PRIMARY KEY,
+        direction TEXT NOT NULL CHECK(direction IN ('outgoing', 'incoming')),
+        counterparty TEXT NOT NULL,
+        amount TEXT NOT NULL,
+        network TEXT NOT NULL,
+        tx_hash TEXT NOT NULL DEFAULT '',
+        resource TEXT NOT NULL DEFAULT '',
+        status TEXT NOT NULL DEFAULT 'pending',
+        created_at TEXT NOT NULL,
+        metadata TEXT NOT NULL DEFAULT '{}'
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_x402_direction ON x402_payments(direction);
+      CREATE INDEX IF NOT EXISTS idx_x402_created_at ON x402_payments(created_at);
+      CREATE INDEX IF NOT EXISTS idx_x402_counterparty ON x402_payments(counterparty);
+      CREATE INDEX IF NOT EXISTS idx_x402_status ON x402_payments(status);
+    `);
+  }
+  async recordPayment(record) {
+    const stmt = this.db.prepare(`
+      INSERT INTO x402_payments (id, direction, counterparty, amount, network, tx_hash, resource, status, created_at, metadata)
+      VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+    stmt.run(record.id, record.direction, record.counterparty, record.amount.toString(), record.network, record.txHash, record.resource, record.status, record.createdAt, JSON.stringify(record.metadata));
+  }
+  async getTotal(direction, windowMs, scope) {
+    let sql = "SELECT amount FROM x402_payments WHERE direction = ? AND status NOT IN ('failed', 'refunded')";
+    const params = [direction];
+    if (windowMs !== undefined) {
+      const cutoff = new Date(Date.now() - windowMs).toISOString();
+      sql += " AND created_at >= ?";
+      params.push(cutoff);
+    }
+    if (scope) {
+      sql += " AND counterparty = ?";
+      params.push(scope);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    let total = 0n;
+    for (const row of rows) {
+      total += BigInt(row.amount);
+    }
+    return total;
+  }
+  async getRecords(filters) {
+    let sql = "SELECT * FROM x402_payments WHERE 1=1";
+    const params = [];
+    if (filters) {
+      if (filters.direction) {
+        sql += " AND direction = ?";
+        params.push(filters.direction);
+      }
+      if (filters.counterparty) {
+        sql += " AND LOWER(counterparty) = LOWER(?)";
+        params.push(filters.counterparty);
+      }
+      if (filters.status) {
+        sql += " AND status = ?";
+        params.push(filters.status);
+      }
+      if (filters.network) {
+        sql += " AND network = ?";
+        params.push(filters.network);
+      }
+      if (filters.since) {
+        sql += " AND created_at >= ?";
+        params.push(filters.since);
+      }
+      if (filters.until) {
+        sql += " AND created_at <= ?";
+        params.push(filters.until);
+      }
+    }
+    sql += " ORDER BY created_at DESC";
+    if (filters?.limit !== undefined) {
+      sql += " LIMIT ?";
+      params.push(filters.limit);
+    }
+    if (filters?.offset !== undefined) {
+      sql += " OFFSET ?";
+      params.push(filters.offset);
+    }
+    const rows = this.db.prepare(sql).all(...params);
+    return rows.map((row) => this.rowToRecord(row));
+  }
+  async getCount(direction, windowMs) {
+    let sql = "SELECT COUNT(*) as cnt FROM x402_payments WHERE direction = ? AND status NOT IN ('failed', 'refunded')";
+    const params = [direction];
+    if (windowMs !== undefined) {
+      const cutoff = new Date(Date.now() - windowMs).toISOString();
+      sql += " AND created_at >= ?";
+      params.push(cutoff);
+    }
+    const row = this.db.prepare(sql).get(...params);
+    return row.cnt;
+  }
+  async clear() {
+    this.db.exec("DELETE FROM x402_payments");
+  }
+  close() {
+    this.db.close();
+  }
+  rowToRecord(row) {
+    let metadata = {};
+    try {
+      metadata = JSON.parse(row.metadata);
+    } catch {}
+    return {
+      id: row.id,
+      direction: row.direction,
+      counterparty: row.counterparty,
+      amount: BigInt(row.amount),
+      network: row.network,
+      txHash: row.tx_hash,
+      resource: row.resource,
+      status: row.status,
+      createdAt: row.created_at,
+      metadata
+    };
+  }
+}
+
+// services/x402-service.ts
+var DEFAULT_FACILITATOR_URL = "https://facilitator.daydreams.systems";
+var DEFAULTS = {
+  network: "base",
+  maxPaymentUsd: 1,
+  maxTotalUsd: 10
+};
+
+class X402Service extends Service {
+  static serviceType = "x402_payment";
+  capabilityDescription = "x402 HTTP payment protocol - send and receive crypto payments";
+  signer = null;
+  policyEngine = null;
+  circuitBreaker;
+  storage;
+  serviceConfig;
+  fetchWithPayment = null;
+  constructor(runtime) {
+    super(runtime);
+    this.circuitBreaker = new CircuitBreaker;
+    this.storage = new MemoryPaymentStorage;
+    this.serviceConfig = {
+      privateKey: "",
+      network: DEFAULTS.network,
+      payTo: "",
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      maxPaymentUsd: DEFAULTS.maxPaymentUsd,
+      maxTotalUsd: DEFAULTS.maxTotalUsd,
+      enabled: false
+    };
+  }
+  static async start(runtime) {
+    const service = new X402Service(runtime);
+    await service.initialize(runtime);
+    return service;
+  }
+  async initialize(runtime) {
+    this.runtime = runtime;
+    const privateKey = String(runtime.getSetting("X402_PRIVATE_KEY") ?? "");
+    const network = String(runtime.getSetting("X402_NETWORK") ?? DEFAULTS.network);
+    const payTo = String(runtime.getSetting("X402_PAY_TO") ?? "");
+    const facilitatorUrl = String(runtime.getSetting("X402_FACILITATOR_URL") ?? DEFAULT_FACILITATOR_URL);
+    const maxPaymentUsdRaw = runtime.getSetting("X402_MAX_PAYMENT_USD");
+    const maxPaymentUsd = maxPaymentUsdRaw !== null ? parseFloat(String(maxPaymentUsdRaw)) : DEFAULTS.maxPaymentUsd;
+    const maxTotalUsdRaw = runtime.getSetting("X402_MAX_TOTAL_USD");
+    const maxTotalUsd = maxTotalUsdRaw !== null ? parseFloat(String(maxTotalUsdRaw)) : DEFAULTS.maxTotalUsd;
+    const enabledSetting = runtime.getSetting("X402_ENABLED");
+    const enabled = String(enabledSetting) !== "false" && privateKey.length > 0;
+    this.serviceConfig = {
+      privateKey,
+      network,
+      payTo,
+      facilitatorUrl,
+      maxPaymentUsd: isNaN(maxPaymentUsd) ? DEFAULTS.maxPaymentUsd : maxPaymentUsd,
+      maxTotalUsd: isNaN(maxTotalUsd) ? DEFAULTS.maxTotalUsd : maxTotalUsd,
+      enabled
+    };
+    if (!enabled) {
+      logger4.info("[x402] Service inactive — no private key configured or explicitly disabled");
+      return;
+    }
+    try {
+      resolveNetwork(network);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger4.error(`[x402] Invalid network configuration: ${message}`);
+      this.serviceConfig.enabled = false;
+      return;
+    }
+    try {
+      this.signer = new EvmPaymentSigner(privateKey, network);
+      logger4.info(`[x402] Wallet initialized: ${this.signer.address} on ${network}`);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger4.error(`[x402] Failed to initialize signer: ${message}`);
+      this.serviceConfig.enabled = false;
+      return;
+    }
+    this.serviceConfig.privateKey = "";
+    const dbPath = String(runtime.getSetting("X402_DB_PATH") ?? "");
+    if (dbPath) {
+      try {
+        this.storage = new SqlitePaymentStorage(dbPath);
+        logger4.info(`[x402] Using SQLite storage at ${dbPath}`);
+      } catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        logger4.warn(`[x402] Failed to initialize SQLite storage: ${message}. Falling back to memory storage.`);
+        this.storage = new MemoryPaymentStorage;
+      }
+    } else {
+      logger4.info("[x402] Using in-memory storage (set X402_DB_PATH for persistence)");
+    }
+    const policy = {
+      outgoing: {
+        maxPerTransaction: usdToBaseUnits(this.serviceConfig.maxPaymentUsd),
+        maxTotal: usdToBaseUnits(this.serviceConfig.maxTotalUsd),
+        windowMs: ONE_DAY_MS,
+        maxTransactions: 1000,
+        allowedRecipients: [],
+        blockedRecipients: []
+      },
+      incoming: {
+        minPerTransaction: 0n,
+        allowedSenders: [],
+        blockedSenders: []
+      }
+    };
+    this.policyEngine = new PolicyEngine(policy, this.storage);
+    this.circuitBreaker = new CircuitBreaker;
+    this.fetchWithPayment = createFetchWithPayment({
+      signer: this.signer,
+      policyEngine: this.policyEngine,
+      circuitBreaker: this.circuitBreaker,
+      storage: this.storage,
+      logger: logger4
+    });
+    logger4.info(`[x402] Service active — max per-txn: $${this.serviceConfig.maxPaymentUsd}, max daily: $${this.serviceConfig.maxTotalUsd}`);
+  }
+  async stop() {
+    logger4.info("[x402] Service stopping");
+    this.signer = null;
+    this.fetchWithPayment = null;
+  }
+  getFetchWithPayment() {
+    if (!this.fetchWithPayment) {
+      return (input, init) => fetch(input, init);
+    }
+    return this.fetchWithPayment;
+  }
+  async getSummary(windowMs = ONE_DAY_MS) {
+    const [totalSpent, totalEarned, outgoingCount, incomingCount] = await Promise.all([
+      this.storage.getTotal("outgoing", windowMs),
+      this.storage.getTotal("incoming", windowMs),
+      this.storage.getCount("outgoing", windowMs),
+      this.storage.getCount("incoming", windowMs)
+    ]);
+    return {
+      totalSpent,
+      totalEarned,
+      outgoingCount,
+      incomingCount,
+      windowMs
+    };
+  }
+  async getRecentTransactions(limit = 20) {
+    return this.storage.getRecords({ limit });
+  }
+  isActive() {
+    return this.serviceConfig.enabled && this.signer !== null;
+  }
+  canMakePayments() {
+    return this.isActive() && this.fetchWithPayment !== null;
+  }
+  updatePolicy(policy) {
+    if (this.policyEngine) {
+      this.policyEngine.updatePolicy(policy);
+      logger4.info("[x402] Payment policy updated");
+    }
+  }
+  getWalletAddress() {
+    return this.signer?.address ?? null;
+  }
+  getNetwork() {
+    return this.serviceConfig.network;
+  }
+  getFacilitatorUrl() {
+    return this.serviceConfig.facilitatorUrl;
+  }
+  getPayToAddress() {
+    return this.serviceConfig.payTo;
+  }
+  getStorage() {
+    return this.storage;
+  }
+  getCircuitBreakerState() {
+    return this.circuitBreaker.getState();
+  }
+  resetCircuitBreaker() {
+    this.circuitBreaker.reset();
+    logger4.info("[x402] Circuit breaker reset");
+  }
+}
+// middleware/facilitator-client.ts
+function buildFacilitatorRequestBody(paymentProof, requirement) {
+  let paymentPayload;
+  try {
+    const decoded = Buffer.from(paymentProof, "base64").toString("utf-8");
+    paymentPayload = JSON.parse(decoded);
+  } catch {
+    try {
+      paymentPayload = JSON.parse(paymentProof);
+    } catch {
+      throw new Error("Payment proof is neither valid base64-encoded JSON nor direct JSON");
+    }
+  }
+  const paymentRequirements = {
+    scheme: requirement.scheme,
+    network: requirement.network,
+    asset: requirement.asset,
+    amount: requirement.maxAmountRequired,
+    payTo: requirement.payTo,
+    maxTimeoutSeconds: requirement.maxTimeoutSeconds,
+    extra: requirement.extra
+  };
+  return JSON.stringify({ paymentPayload, paymentRequirements });
+}
+async function verifyPaymentWithFacilitator(paymentProof, facilitatorUrl, requirement) {
+  const url = new URL("/verify", facilitatorUrl);
+  try {
+    const body = buildFacilitatorRequestBody(paymentProof, requirement);
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "unknown error");
+      return {
+        valid: false,
+        reason: `Facilitator returned ${response.status}: ${errorText}`
+      };
+    }
+    const result = await response.json();
+    return {
+      valid: result.isValid === true,
+      payer: result.payer,
+      reason: result.invalidReason
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      valid: false,
+      reason: `Facilitator request failed: ${message}`
+    };
+  }
+}
+async function settlePaymentWithFacilitator(paymentProof, facilitatorUrl, requirement) {
+  const url = new URL("/settle", facilitatorUrl);
+  try {
+    const body = buildFacilitatorRequestBody(paymentProof, requirement);
+    const response = await fetch(url.toString(), {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "unknown error");
+      return {
+        success: false,
+        reason: `Facilitator returned ${response.status}: ${errorText}`
+      };
+    }
+    const result = await response.json();
+    return {
+      success: result.success === true,
+      txHash: result.transaction,
+      reason: result.errorReason
+    };
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      success: false,
+      reason: `Facilitator request failed: ${message}`
+    };
+  }
+}
+
+// middleware/paywall.ts
+function createPaywallMiddleware(config, storage, onStorageError) {
+  const networkInfo = resolveNetwork(config.network);
+  const requirementTemplate = {
+    scheme: "upto",
+    network: networkInfo.caip2,
+    maxAmountRequired: config.amount.toString(),
+    resource: "",
+    description: config.description,
+    mimeType: config.mimeType,
+    payTo: config.payTo,
+    maxTimeoutSeconds: config.maxTimeoutSeconds,
+    asset: networkInfo.usdcAddress,
+    extra: {
+      name: networkInfo.usdcDomainName,
+      version: networkInfo.usdcPermitVersion
+    }
+  };
+  return async (req, res, next) => {
+    const paymentHeader = getHeader(req, "x-payment");
+    if (!paymentHeader) {
+      const resource = req.url ?? "/";
+      const requirement2 = { ...requirementTemplate, resource };
+      const paymentRequired = {
+        x402Version: 2,
+        accepts: [requirement2]
+      };
+      const encoded = Buffer.from(JSON.stringify(paymentRequired)).toString("base64");
+      res.setHeader("Payment-Required", encoded).setHeader("x-402", encoded).status(402).json({
+        error: "Payment Required",
+        message: config.description,
+        x402Version: 2
+      });
+      return;
+    }
+    const requirement = {
+      ...requirementTemplate,
+      resource: req.url ?? "/"
+    };
+    const verifyResult = await verifyPaymentWithFacilitator(paymentHeader, config.facilitatorUrl, requirement);
+    if (!verifyResult.valid) {
+      res.status(402).json({
+        error: "Payment Invalid",
+        reason: verifyResult.reason ?? "Payment verification failed"
+      });
+      return;
+    }
+    const settleResult = await settlePaymentWithFacilitator(paymentHeader, config.facilitatorUrl, requirement);
+    if (storage && verifyResult.payer) {
+      const id = `x402_in_${Date.now().toString(36)}_${Math.random().toString(36).substring(2, 8)}`;
+      await storage.recordPayment({
+        id,
+        direction: "incoming",
+        counterparty: verifyResult.payer,
+        amount: config.amount,
+        network: networkInfo.caip2,
+        txHash: settleResult.txHash ?? "",
+        resource: req.url ?? "/",
+        status: settleResult.success ? "confirmed" : "pending",
+        createdAt: new Date().toISOString(),
+        metadata: {}
+      }).catch((err) => {
+        if (onStorageError) {
+          onStorageError(err);
+        }
+      });
+    }
+    if (settleResult.txHash) {
+      res.setHeader("x-upto-session-id", settleResult.txHash);
+      res.setHeader("X-PAYMENT-RESPONSE", settleResult.txHash);
+    }
+    next();
+  };
+}
+function getHeader(req, name) {
+  const headers = req.headers;
+  const lowerName = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === lowerName) {
+      if (Array.isArray(value)) {
+        return value[0];
+      }
+      return value;
+    }
+  }
+  return;
+}
+// storage/postgres.ts
+import pg from "pg";
+var { Pool } = pg;
+
+class PostgresPaymentStorage {
+  pool;
+  agentId;
+  initialized;
+  constructor(connectionString, agentId) {
+    this.pool = new Pool({ connectionString });
+    this.agentId = agentId;
+    this.initialized = this.initialize();
+  }
+  async initialize() {
+    const client = await this.pool.connect();
+    try {
+      await client.query(`
+        CREATE TABLE IF NOT EXISTS x402_payments (
+          id TEXT PRIMARY KEY,
+          agent_id TEXT NOT NULL,
+          direction VARCHAR NOT NULL CHECK(direction IN ('outgoing', 'incoming')),
+          counterparty TEXT NOT NULL,
+          amount TEXT NOT NULL,
+          network TEXT NOT NULL,
+          tx_hash TEXT NOT NULL DEFAULT '',
+          resource TEXT NOT NULL DEFAULT '',
+          status TEXT NOT NULL DEFAULT 'pending',
+          created_at TEXT NOT NULL,
+          metadata JSONB NOT NULL DEFAULT '{}'
+        );
+        CREATE INDEX IF NOT EXISTS idx_x402_agent ON x402_payments(agent_id);
+        CREATE INDEX IF NOT EXISTS idx_x402_direction ON x402_payments(agent_id, direction, created_at);
+      `);
+    } finally {
+      client.release();
+    }
+  }
+  async ready() {
+    await this.initialized;
+  }
+  async recordPayment(record) {
+    await this.ready();
+    await this.pool.query(`INSERT INTO x402_payments (id, agent_id, direction, counterparty, amount, network, tx_hash, resource, status, created_at, metadata)
+       VALUES ($1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11)`, [
+      record.id,
+      this.agentId,
+      record.direction,
+      record.counterparty,
+      record.amount.toString(),
+      record.network,
+      record.txHash,
+      record.resource,
+      record.status,
+      record.createdAt,
+      JSON.stringify(record.metadata)
+    ]);
+  }
+  async getTotal(direction, windowMs, scope) {
+    await this.ready();
+    let sql = "SELECT amount FROM x402_payments WHERE agent_id = $1 AND direction = $2 AND status NOT IN ('failed', 'refunded')";
+    const params = [this.agentId, direction];
+    let paramIdx = 3;
+    if (windowMs !== undefined) {
+      const cutoff = new Date(Date.now() - windowMs).toISOString();
+      sql += ` AND created_at >= $${paramIdx}`;
+      params.push(cutoff);
+      paramIdx++;
+    }
+    if (scope) {
+      sql += ` AND counterparty = $${paramIdx}`;
+      params.push(scope);
+      paramIdx++;
+    }
+    const result = await this.pool.query(sql, params);
+    let total = 0n;
+    for (const row of result.rows) {
+      total += BigInt(row.amount);
+    }
+    return total;
+  }
+  async getRecords(filters) {
+    await this.ready();
+    let sql = "SELECT * FROM x402_payments WHERE agent_id = $1";
+    const params = [this.agentId];
+    let paramIdx = 2;
+    if (filters) {
+      if (filters.direction) {
+        sql += ` AND direction = $${paramIdx}`;
+        params.push(filters.direction);
+        paramIdx++;
+      }
+      if (filters.counterparty) {
+        sql += ` AND LOWER(counterparty) = LOWER($${paramIdx})`;
+        params.push(filters.counterparty);
+        paramIdx++;
+      }
+      if (filters.status) {
+        sql += ` AND status = $${paramIdx}`;
+        params.push(filters.status);
+        paramIdx++;
+      }
+      if (filters.network) {
+        sql += ` AND network = $${paramIdx}`;
+        params.push(filters.network);
+        paramIdx++;
+      }
+      if (filters.since) {
+        sql += ` AND created_at >= $${paramIdx}`;
+        params.push(filters.since);
+        paramIdx++;
+      }
+      if (filters.until) {
+        sql += ` AND created_at <= $${paramIdx}`;
+        params.push(filters.until);
+        paramIdx++;
+      }
+    }
+    sql += " ORDER BY created_at DESC";
+    if (filters?.limit !== undefined) {
+      sql += ` LIMIT $${paramIdx}`;
+      params.push(filters.limit);
+      paramIdx++;
+    }
+    if (filters?.offset !== undefined) {
+      sql += ` OFFSET $${paramIdx}`;
+      params.push(filters.offset);
+      paramIdx++;
+    }
+    const result = await this.pool.query(sql, params);
+    return result.rows.map((row) => this.rowToRecord(row));
+  }
+  async getCount(direction, windowMs) {
+    await this.ready();
+    let sql = "SELECT COUNT(*) as cnt FROM x402_payments WHERE agent_id = $1 AND direction = $2 AND status NOT IN ('failed', 'refunded')";
+    const params = [this.agentId, direction];
+    let paramIdx = 3;
+    if (windowMs !== undefined) {
+      const cutoff = new Date(Date.now() - windowMs).toISOString();
+      sql += ` AND created_at >= $${paramIdx}`;
+      params.push(cutoff);
+      paramIdx++;
+    }
+    const result = await this.pool.query(sql, params);
+    return parseInt(result.rows[0].cnt, 10);
+  }
+  async clear() {
+    await this.ready();
+    await this.pool.query("DELETE FROM x402_payments WHERE agent_id = $1", [
+      this.agentId
+    ]);
+  }
+  async close() {
+    await this.pool.end();
+  }
+  rowToRecord(row) {
+    let metadata = {};
+    try {
+      metadata = typeof row.metadata === "string" ? JSON.parse(row.metadata) : row.metadata;
+    } catch {}
+    return {
+      id: row.id,
+      direction: row.direction,
+      counterparty: row.counterparty,
+      amount: BigInt(row.amount),
+      network: row.network,
+      txHash: row.tx_hash,
+      resource: row.resource,
+      status: row.status,
+      createdAt: row.created_at,
+      metadata
+    };
+  }
+}
+
+// index.ts
+async function handleSummary(_req, res, runtime) {
+  const service = runtime.getService("x402_payment");
+  if (!service || !service.isActive()) {
+    res.status(503).json({ error: "x402 service not active" });
+    return;
+  }
+  const summary = await service.getSummary();
+  res.status(200).json({
+    wallet: service.getWalletAddress() ?? "",
+    network: service.getNetwork(),
+    totalSpent: formatUsd(summary.totalSpent),
+    totalSpentRaw: summary.totalSpent.toString(),
+    totalEarned: formatUsd(summary.totalEarned),
+    totalEarnedRaw: summary.totalEarned.toString(),
+    outgoingCount: summary.outgoingCount,
+    incomingCount: summary.incomingCount,
+    windowMs: summary.windowMs,
+    circuitBreaker: service.getCircuitBreakerState()
+  });
+}
+async function handleHistory(req, res, runtime) {
+  const service = runtime.getService("x402_payment");
+  if (!service || !service.isActive()) {
+    res.status(503).json({ error: "x402 service not active" });
+    return;
+  }
+  const limitStr = (Array.isArray(req.query?.limit) ? req.query.limit[0] : req.query?.limit) ?? "20";
+  const limit = Math.min(Math.max(parseInt(limitStr, 10) || 20, 1), 100);
+  const transactions = await service.getRecentTransactions(limit);
+  const serialized = transactions.map((txn) => ({
+    id: txn.id,
+    direction: txn.direction,
+    counterparty: txn.counterparty,
+    amount: txn.amount.toString(),
+    amountUsd: formatUsd(txn.amount),
+    network: txn.network,
+    txHash: txn.txHash,
+    resource: txn.resource,
+    status: txn.status,
+    createdAt: txn.createdAt,
+    metadata: txn.metadata
+  }));
+  res.status(200).json({ transactions: serialized, count: serialized.length });
+}
+async function handleExport(_req, res, runtime) {
+  const service = runtime.getService("x402_payment");
+  if (!service || !service.isActive()) {
+    res.status(503).json({ error: "x402 service not active" });
+    return;
+  }
+  const transactions = await service.getRecentTransactions(1e4);
+  const csvHeader = "id,direction,counterparty,amount_base_units,amount_usd,network,tx_hash,resource,status,created_at";
+  const csvRows = transactions.map((txn) => `${txn.id},${txn.direction},${txn.counterparty},${txn.amount.toString()},${formatUsd(txn.amount)},${txn.network},${txn.txHash},${escapeCSV(txn.resource)},${txn.status},${txn.createdAt}`);
+  const csv = [csvHeader, ...csvRows].join(`
+`);
+  if (res.setHeader) {
+    res.setHeader("Content-Type", "text/csv");
+    res.setHeader("Content-Disposition", `attachment; filename="x402-payments-${new Date().toISOString().slice(0, 10)}.csv"`);
+  }
+  res.send(csv);
+}
+function escapeCSV(value) {
+  if (value.includes(",") || value.includes('"') || value.includes(`
+`)) {
+    return `"${value.replace(/"/g, '""')}"`;
+  }
+  return value;
+}
+var x402Plugin = {
+  name: "x402",
+  description: "x402 HTTP payment protocol - send and receive crypto payments (USDC on EVM chains)",
+  config: {
+    X402_PRIVATE_KEY: null,
+    X402_NETWORK: null,
+    X402_PAY_TO: null,
+    X402_FACILITATOR_URL: null,
+    X402_MAX_PAYMENT_USD: null,
+    X402_MAX_TOTAL_USD: null,
+    X402_ENABLED: null
+  },
+  init: async (_config, _runtime) => {},
+  services: [X402Service],
+  actions: [payForServiceAction, checkPaymentHistoryAction, setPaymentPolicyAction],
+  providers: [paymentBalanceProvider],
+  routes: [
+    agentCardRoute,
+    {
+      type: "GET",
+      path: "/x402/summary",
+      name: "x402-summary",
+      public: false,
+      handler: handleSummary
+    },
+    {
+      type: "GET",
+      path: "/x402/history",
+      name: "x402-history",
+      public: false,
+      handler: handleHistory
+    },
+    {
+      type: "GET",
+      path: "/x402/export",
+      name: "x402-export",
+      public: false,
+      handler: handleExport
+    }
+  ]
+};
+var typescript_default = x402Plugin;
+export {
+  x402Plugin,
+  verifyPaymentWithFacilitator,
+  usdToBaseUnits,
+  truncateAddress,
+  settlePaymentWithFacilitator,
+  setPaymentPolicyAction,
+  resolveNetwork,
+  paymentBalanceProvider,
+  payForServiceAction,
+  networkKeyFromCaip2,
+  formatUsd,
+  typescript_default as default,
+  createPaywallMiddleware,
+  createFetchWithPayment,
+  checkPaymentHistoryAction,
+  agentCardRoute,
+  X402Service,
+  SqlitePaymentStorage,
+  PostgresPaymentStorage,
+  PolicyEngine,
+  ONE_DAY_MS,
+  NETWORK_REGISTRY,
+  MemoryPaymentStorage,
+  EvmPaymentSigner,
+  CircuitBreaker
+};
+
+//# debugId=8D689045A014B14A64756E2164756E21