@agentokratia/x402-escrow 2.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Agentokratia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,159 @@
+# @agentokratia/x402-escrow
+
+Escrow payment scheme for the x402 protocol. Session-based payments for high-frequency APIs.
+
+## Features
+
+- **Session-based payments** - Sign once, make unlimited API calls
+- **Zero per-request gas** - Facilitator handles on-chain transactions
+- **100% reclaimable** - Withdraw unused funds anytime
+- **ERC-3009 gasless** - Users sign off-chain, no wallet transaction needed
+
+## Installation
+
+```bash
+npm install @agentokratia/x402-escrow
+```
+
+## Client Usage
+
+For apps and agents paying for APIs.
+
+### Simple (recommended)
+
+```typescript
+import { createEscrowFetch } from '@agentokratia/x402-escrow/client';
+
+const { fetch: escrowFetch, scheme, x402 } = createEscrowFetch(walletClient);
+
+// Payments handled automatically
+const response = await escrowFetch('https://api.example.com/premium');
+
+// Access sessions
+scheme.sessions.getAll();
+scheme.sessions.hasValid(receiverAddress, '10000');
+```
+
+### With hooks
+
+```typescript
+const { fetch: escrowFetch, x402 } = createEscrowFetch(walletClient);
+
+// Add hooks for user control
+x402.onBeforePaymentCreation(async (ctx) => {
+  console.log('About to pay:', ctx.paymentRequirements);
+});
+
+x402.onAfterPaymentCreation(async (ctx) => {
+  console.log('Payment created:', ctx.paymentPayload);
+});
+```
+
+### Advanced (manual setup)
+
+```typescript
+import { x402Client } from '@x402/core/client';
+import { wrapFetchWithPayment } from '@x402/fetch';
+import { EscrowScheme, withSessionExtraction } from '@agentokratia/x402-escrow/client';
+
+const escrowScheme = new EscrowScheme(walletClient);
+const x402 = new x402Client().register('eip155:84532', escrowScheme);
+const paidFetch = wrapFetchWithPayment(fetch, x402);
+const escrowFetch = withSessionExtraction(paidFetch, escrowScheme);
+```
+
+## Server Usage
+
+For APIs accepting payments. Config is auto-discovered from facilitator.
+
+### Express
+
+```typescript
+import { x402ResourceServer, HTTPFacilitatorClient } from '@x402/core/server';
+import { paymentMiddleware } from '@x402/express';
+import { EscrowScheme } from '@agentokratia/x402-escrow/server';
+
+const facilitator = new HTTPFacilitatorClient({
+  url: 'https://facilitator.agentokratia.com',
+  createAuthHeaders: async () => ({
+    verify: { Authorization: `Bearer ${process.env.X402_API_KEY}` },
+    settle: { Authorization: `Bearer ${process.env.X402_API_KEY}` },
+    supported: {},
+  }),
+});
+
+const server = new x402ResourceServer(facilitator).register('eip155:84532', new EscrowScheme());
+
+app.use(
+  paymentMiddleware(
+    {
+      'GET /api/premium': {
+        accepts: {
+          scheme: 'escrow',
+          price: '$0.01',
+          network: 'eip155:84532',
+          payTo: ownerAddress,
+        },
+      },
+    },
+    server
+  )
+);
+```
+
+### Next.js
+
+```typescript
+import { paymentProxy } from '@x402/next';
+import { EscrowScheme } from '@agentokratia/x402-escrow/server';
+
+const server = new x402ResourceServer(facilitator).register('eip155:84532', new EscrowScheme());
+
+export const proxy = paymentProxy(
+  {
+    '/api/premium': {
+      accepts: { scheme: 'escrow', network: 'eip155:84532', payTo: ownerAddress, price: '$0.01' },
+    },
+  },
+  server
+);
+```
+
+## How It Works
+
+```
+1. User signs ERC-3009 authorization (gasless)
+2. Facilitator deposits funds to escrow contract
+3. Session created with balance
+4. Each API call debits from session (no signature needed)
+5. User can reclaim unused funds anytime
+```
+
+## Networks
+
+| Network      | Chain ID | Escrow Contract                              |
+| ------------ | -------- | -------------------------------------------- |
+| Base Mainnet | 8453     | `0xbDEa0d1BCc5966192b070fDF62ab4eF5B4420Cff` |
+| Base Sepolia | 84532    | `0xbDEa0d1BCc5966192b070fDF62ab4eF5B4420Cff` |
+
+## API
+
+### Client
+
+| Export                                      | Description                                   |
+| ------------------------------------------- | --------------------------------------------- |
+| `createEscrowFetch(walletClient, options?)` | Creates fetch with automatic payment handling |
+| `EscrowScheme`                              | Core scheme class for x402Client              |
+| `withSessionExtraction(fetch, scheme)`      | Wrapper to extract sessions from responses    |
+| `withAxiosSessionExtraction(scheme)`        | Axios interceptor for session extraction      |
+
+### Server
+
+| Export                  | Description                          |
+| ----------------------- | ------------------------------------ |
+| `EscrowScheme`          | Server scheme for x402ResourceServer |
+| `HTTPFacilitatorClient` | Re-export from @x402/core            |
+
+## License
+
+MIT

package/dist/client/index.cjs

@@ -0,0 +1,524 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  BrowserLocalStorage: () => BrowserLocalStorage,
+  EscrowScheme: () => EscrowScheme,
+  InMemoryStorage: () => InMemoryStorage,
+  SessionManager: () => SessionManager,
+  X402_VERSION: () => X402_VERSION,
+  computeEscrowNonce: () => computeEscrowNonce,
+  createEscrowFetch: () => createEscrowFetch,
+  createStorage: () => createStorage,
+  signERC3009: () => signERC3009,
+  withAxiosSessionExtraction: () => withAxiosSessionExtraction,
+  withSessionExtraction: () => withSessionExtraction
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/client/session-wrapper.ts
+var import_viem3 = require("viem");
+var import_client = require("@x402/core/client");
+var import_fetch = require("@x402/fetch");
+
+// src/client/escrow.ts
+var import_viem2 = require("viem");
+
+// src/types.ts
+var X402_VERSION = 2;
+function fromBase64(str) {
+  try {
+    if (typeof atob !== "undefined") {
+      return decodeURIComponent(escape(atob(str)));
+    }
+    return Buffer.from(str, "base64").toString("utf-8");
+  } catch {
+    return Buffer.from(str, "base64").toString("utf-8");
+  }
+}
+function generateRequestId() {
+  if (typeof crypto !== "undefined" && crypto.randomUUID) {
+    return crypto.randomUUID();
+  }
+  return `${Date.now().toString(16)}-${Math.random().toString(16).slice(2)}`;
+}
+function generateRandomBytes(length) {
+  const bytes = new Uint8Array(length);
+  if (typeof crypto !== "undefined" && crypto.getRandomValues) {
+    crypto.getRandomValues(bytes);
+  } else {
+    for (let i = 0; i < length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+  }
+  return bytes;
+}
+
+// src/constants.ts
+var ZERO_ADDRESS = "0x0000000000000000000000000000000000000000";
+var DEFAULT_SESSION_DURATION = 3600;
+var DEFAULT_REFUND_WINDOW = 86400;
+
+// src/client/storage.ts
+var BaseStorage = class {
+  constructor() {
+    this.sessions = /* @__PURE__ */ new Map();
+  }
+  get(network, receiver) {
+    const now = Date.now() / 1e3;
+    for (const session of this.sessions.values()) {
+      if (session.network === network && session.receiver.toLowerCase() === receiver.toLowerCase() && session.authorizationExpiry > now) {
+        return session;
+      }
+    }
+    return null;
+  }
+  findBest(network, receiver, minAmount) {
+    const now = Date.now() / 1e3;
+    let best = null;
+    let bestBalance = 0n;
+    for (const session of this.sessions.values()) {
+      if (session.network === network && session.receiver.toLowerCase() === receiver.toLowerCase() && session.authorizationExpiry > now) {
+        const balance = BigInt(session.balance);
+        if (balance >= minAmount && balance > bestBalance) {
+          best = session;
+          bestBalance = balance;
+        }
+      }
+    }
+    return best;
+  }
+  set(session) {
+    this.sessions.set(session.sessionId, session);
+    this.onUpdate();
+  }
+  update(sessionId, balance) {
+    const session = this.sessions.get(sessionId);
+    if (session) {
+      this.sessions.set(sessionId, { ...session, balance });
+      this.onUpdate();
+    }
+  }
+  list() {
+    return Array.from(this.sessions.values());
+  }
+  remove(sessionId) {
+    this.sessions.delete(sessionId);
+    this.onUpdate();
+  }
+  /** Override in subclasses for persistence */
+  onUpdate() {
+  }
+};
+var InMemoryStorage = class extends BaseStorage {
+  // No persistence needed
+};
+var BrowserLocalStorage = class extends BaseStorage {
+  constructor(key = "x402-sessions") {
+    super();
+    this.key = key;
+    this.load();
+  }
+  onUpdate() {
+    this.save();
+  }
+  load() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      const data = localStorage.getItem(this.key);
+      if (data) {
+        const sessions = JSON.parse(data);
+        for (const s of sessions) this.sessions.set(s.sessionId, s);
+      }
+    } catch {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn("[x402] Failed to load sessions from localStorage");
+      }
+    }
+  }
+  save() {
+    if (typeof localStorage === "undefined") return;
+    try {
+      localStorage.setItem(this.key, JSON.stringify(Array.from(this.sessions.values())));
+    } catch {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn("[x402] Failed to save sessions to localStorage");
+      }
+    }
+  }
+};
+function createStorage(type, storageKey) {
+  return type === "localStorage" ? new BrowserLocalStorage(storageKey) : new InMemoryStorage();
+}
+
+// src/client/session-manager.ts
+var SessionManager = class {
+  constructor(network, options = {}) {
+    this.network = network;
+    this.storage = createStorage(options.storage ?? "memory", options.storageKey);
+  }
+  /**
+   * Store a session from escrow settlement response.
+   */
+  store(session) {
+    this.storage.set({ ...session, createdAt: Date.now() });
+  }
+  /**
+   * Get session for a specific receiver.
+   */
+  getForReceiver(receiver) {
+    return this.storage.get(this.network, receiver);
+  }
+  /**
+   * Find best session for receiver with minimum balance.
+   */
+  findBest(receiver, minAmount) {
+    return this.storage.findBest(this.network, receiver, minAmount);
+  }
+  /**
+   * Check if valid session exists for receiver.
+   */
+  hasValid(receiver, minAmount) {
+    const session = minAmount ? this.storage.findBest(this.network, receiver, BigInt(minAmount)) : this.storage.get(this.network, receiver);
+    return session !== null;
+  }
+  /**
+   * Update session balance after debit.
+   */
+  updateBalance(sessionId, newBalance) {
+    this.storage.update(sessionId, newBalance);
+  }
+  /**
+   * Get all stored sessions.
+   */
+  getAll() {
+    return this.storage.list();
+  }
+  /**
+   * Remove a specific session.
+   */
+  remove(sessionId) {
+    this.storage.remove(sessionId);
+  }
+  /**
+   * Clear all sessions.
+   */
+  clear() {
+    for (const session of this.storage.list()) {
+      this.storage.remove(session.sessionId);
+    }
+  }
+};
+
+// src/client/eip712.ts
+var import_viem = require("viem");
+var PAYMENT_INFO_TYPE = "PaymentInfo(address operator,address payer,address receiver,address token,uint120 maxAmount,uint48 preApprovalExpiry,uint48 authorizationExpiry,uint48 refundExpiry,uint16 minFeeBps,uint16 maxFeeBps,address feeReceiver,uint256 salt)";
+var PAYMENT_INFO_TYPEHASH = (0, import_viem.keccak256)((0, import_viem.toHex)(new TextEncoder().encode(PAYMENT_INFO_TYPE)));
+var PAYMENT_INFO_ABI_PARAMS = "bytes32, address, address, address, address, uint120, uint48, uint48, uint48, uint16, uint16, address, uint256";
+var NONCE_ABI_PARAMS = "uint256, address, bytes32";
+var ERC3009_TYPES = {
+  ReceiveWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function computeEscrowNonce(chainId, escrowContract, paymentInfo) {
+  const paymentInfoHash = (0, import_viem.keccak256)(
+    (0, import_viem.encodeAbiParameters)((0, import_viem.parseAbiParameters)(PAYMENT_INFO_ABI_PARAMS), [
+      PAYMENT_INFO_TYPEHASH,
+      paymentInfo.operator,
+      ZERO_ADDRESS,
+      // payer = 0 for payer-agnostic
+      paymentInfo.receiver,
+      paymentInfo.token,
+      paymentInfo.maxAmount,
+      paymentInfo.preApprovalExpiry,
+      paymentInfo.authorizationExpiry,
+      paymentInfo.refundExpiry,
+      paymentInfo.minFeeBps,
+      paymentInfo.maxFeeBps,
+      paymentInfo.feeReceiver,
+      paymentInfo.salt
+    ])
+  );
+  return (0, import_viem.keccak256)(
+    (0, import_viem.encodeAbiParameters)((0, import_viem.parseAbiParameters)(NONCE_ABI_PARAMS), [
+      BigInt(chainId),
+      escrowContract,
+      paymentInfoHash
+    ])
+  );
+}
+async function signERC3009(wallet, authorization, domain) {
+  if (!wallet.account) {
+    throw new Error("WalletClient must have an account");
+  }
+  return wallet.signTypedData({
+    account: wallet.account,
+    domain,
+    types: ERC3009_TYPES,
+    primaryType: "ReceiveWithAuthorization",
+    message: {
+      from: authorization.from,
+      to: authorization.to,
+      value: authorization.value,
+      validAfter: authorization.validAfter,
+      validBefore: authorization.validBefore,
+      nonce: authorization.nonce
+    }
+  });
+}
+
+// src/client/escrow.ts
+var EscrowScheme = class {
+  constructor(walletClient, options = {}) {
+    this.scheme = "escrow";
+    if (!walletClient.account) {
+      throw new Error("WalletClient must have an account");
+    }
+    if (!walletClient.chain) {
+      throw new Error("WalletClient must have a chain");
+    }
+    this.wallet = walletClient;
+    this.chainId = walletClient.chain.id;
+    this.network = `eip155:${walletClient.chain.id}`;
+    this.sessionDuration = options.sessionDuration ?? DEFAULT_SESSION_DURATION;
+    this.refundWindow = options.refundWindow ?? DEFAULT_REFUND_WINDOW;
+    this.customDepositAmount = options.depositAmount ? BigInt(options.depositAmount) : void 0;
+    this.sessions = new SessionManager(this.network, {
+      storage: options.storage,
+      storageKey: options.storageKey
+    });
+  }
+  get address() {
+    return this.wallet.account.address;
+  }
+  // ========== Payment Payload Creation ==========
+  /**
+   * Creates payment payload for escrow scheme.
+   * Auto-detects whether to create new session or use existing one.
+   */
+  async createPaymentPayload(x402Version, paymentRequirements) {
+    const receiver = (0, import_viem2.getAddress)(paymentRequirements.payTo);
+    const amount = BigInt(paymentRequirements.amount);
+    const existingSession = this.sessions.findBest(receiver, amount);
+    if (existingSession) {
+      return this.createUsagePayload(x402Version, existingSession, paymentRequirements.amount);
+    }
+    return this.createCreationPayload(x402Version, paymentRequirements);
+  }
+  // ========== Private: Payload Builders ==========
+  /**
+   * Session USAGE payload - uses existing session (no signature).
+   */
+  createUsagePayload(x402Version, session, amount) {
+    return {
+      x402Version,
+      payload: {
+        session: {
+          id: session.sessionId,
+          token: session.sessionToken
+        },
+        amount,
+        requestId: generateRequestId()
+      }
+    };
+  }
+  /**
+   * Session CREATION payload - requires wallet signature.
+   */
+  async createCreationPayload(x402Version, paymentRequirements) {
+    const extra = paymentRequirements.extra;
+    if (!extra.escrowContract || !extra.facilitator || !extra.tokenCollector) {
+      throw new Error("Missing required escrow configuration in payment requirements");
+    }
+    const escrowContract = (0, import_viem2.getAddress)(extra.escrowContract);
+    const facilitator = (0, import_viem2.getAddress)(extra.facilitator);
+    const tokenCollector = (0, import_viem2.getAddress)(extra.tokenCollector);
+    const receiver = (0, import_viem2.getAddress)(paymentRequirements.payTo);
+    const token = (0, import_viem2.getAddress)(paymentRequirements.asset);
+    const now = Math.floor(Date.now() / 1e3);
+    const salt = this.generateSalt();
+    const authorizationExpiry = now + this.sessionDuration;
+    const refundExpiry = authorizationExpiry + this.refundWindow;
+    const minDeposit = extra.minDeposit ? BigInt(extra.minDeposit) : BigInt(paymentRequirements.amount);
+    const maxDeposit = extra.maxDeposit ? BigInt(extra.maxDeposit) : minDeposit;
+    let amount;
+    if (this.customDepositAmount !== void 0) {
+      if (this.customDepositAmount < minDeposit) {
+        throw new Error(
+          `Deposit amount ${this.customDepositAmount} is below minimum ${minDeposit}`
+        );
+      }
+      if (this.customDepositAmount > maxDeposit) {
+        throw new Error(`Deposit amount ${this.customDepositAmount} exceeds maximum ${maxDeposit}`);
+      }
+      amount = this.customDepositAmount;
+    } else {
+      amount = maxDeposit;
+    }
+    const validAfter = 0n;
+    const validBefore = BigInt(authorizationExpiry);
+    const nonce = computeEscrowNonce(this.chainId, escrowContract, {
+      operator: facilitator,
+      payer: this.address,
+      receiver,
+      token,
+      maxAmount: amount,
+      preApprovalExpiry: authorizationExpiry,
+      authorizationExpiry,
+      refundExpiry,
+      minFeeBps: 0,
+      maxFeeBps: 0,
+      feeReceiver: ZERO_ADDRESS,
+      salt: BigInt(salt)
+    });
+    const domain = {
+      name: extra.name,
+      version: extra.version,
+      chainId: this.chainId,
+      verifyingContract: token
+    };
+    const signature = await signERC3009(
+      this.wallet,
+      { from: this.address, to: tokenCollector, value: amount, validAfter, validBefore, nonce },
+      domain
+    );
+    const payload = {
+      signature,
+      authorization: {
+        from: this.address,
+        to: tokenCollector,
+        value: amount.toString(),
+        validAfter: validAfter.toString(),
+        validBefore: validBefore.toString(),
+        nonce
+      },
+      sessionParams: {
+        salt,
+        authorizationExpiry,
+        refundExpiry
+      }
+    };
+    if (paymentRequirements.scheme === "escrow") {
+      payload.requestId = generateRequestId();
+    }
+    const accepted = {
+      scheme: paymentRequirements.scheme,
+      network: paymentRequirements.network,
+      asset: paymentRequirements.asset,
+      amount: paymentRequirements.amount,
+      payTo: paymentRequirements.payTo,
+      maxTimeoutSeconds: paymentRequirements.maxTimeoutSeconds,
+      extra: { ...paymentRequirements.extra, facilitator, escrowContract, tokenCollector }
+    };
+    return { x402Version, accepted, payload };
+  }
+  generateSalt() {
+    return (0, import_viem2.toHex)(generateRandomBytes(32));
+  }
+};
+
+// src/client/session-wrapper.ts
+function createEscrowFetch(walletClient, options) {
+  const scheme = new EscrowScheme(walletClient, options);
+  const x402 = new import_client.x402Client().register(scheme.network, scheme);
+  const baseFetch = options?.fetch ?? globalThis.fetch;
+  const paidFetch = (0, import_fetch.wrapFetchWithPayment)(baseFetch, x402);
+  return {
+    fetch: withSessionExtraction(paidFetch, scheme),
+    scheme,
+    x402
+    // Expose for adding hooks
+  };
+}
+function extractSession(getHeader, escrowScheme) {
+  const paymentResponseHeader = getHeader("PAYMENT-RESPONSE") || getHeader("payment-response");
+  if (!paymentResponseHeader) return;
+  try {
+    const data = JSON.parse(fromBase64(paymentResponseHeader));
+    if (!data.session?.id) return;
+    if (!data.session.token) {
+      if (data.session.balance !== void 0) {
+        escrowScheme.sessions.updateBalance(data.session.id, data.session.balance);
+      }
+      return;
+    }
+    const receiver = data.requirements?.payTo || data.receiver;
+    if (!receiver) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn("[x402] Session missing receiver - cannot store");
+      }
+      return;
+    }
+    if (!(0, import_viem3.isAddress)(receiver)) {
+      if (process.env.NODE_ENV !== "production") {
+        console.warn("[x402] Invalid receiver address in session:", receiver);
+      }
+      return;
+    }
+    escrowScheme.sessions.store({
+      sessionId: data.session.id,
+      sessionToken: data.session.token,
+      network: escrowScheme.network,
+      payer: escrowScheme.address,
+      receiver: (0, import_viem3.getAddress)(receiver),
+      balance: data.session.balance || "0",
+      authorizationExpiry: data.session.expiresAt || 0
+    });
+  } catch (error) {
+    if (process.env.NODE_ENV !== "production") {
+      console.warn("[x402] Failed to parse PAYMENT-RESPONSE:", error);
+    }
+  }
+}
+function withSessionExtraction(paidFetch, escrowScheme) {
+  return async (input, init) => {
+    const response = await paidFetch(input, init);
+    extractSession((name) => response.headers.get(name), escrowScheme);
+    return response;
+  };
+}
+function withAxiosSessionExtraction(escrowScheme) {
+  return (response) => {
+    extractSession((name) => response.headers[name.toLowerCase()], escrowScheme);
+    return response;
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BrowserLocalStorage,
+  EscrowScheme,
+  InMemoryStorage,
+  SessionManager,
+  X402_VERSION,
+  computeEscrowNonce,
+  createEscrowFetch,
+  createStorage,
+  signERC3009,
+  withAxiosSessionExtraction,
+  withSessionExtraction
+});
+//# sourceMappingURL=index.cjs.map