uvd-x402-sdk 2.5.0 → 2.10.0

package/dist/backend/index.js

@@ -0,0 +1,1722 @@
+'use strict';
+
+// src/types/index.ts
+var CAIP2_IDENTIFIERS = {
+  // EVM chains
+  base: "eip155:8453",
+  ethereum: "eip155:1",
+  polygon: "eip155:137",
+  arbitrum: "eip155:42161",
+  optimism: "eip155:10",
+  avalanche: "eip155:43114",
+  celo: "eip155:42220",
+  hyperevm: "eip155:999",
+  unichain: "eip155:130",
+  monad: "eip155:143",
+  // SVM chains
+  solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  fogo: "svm:fogo",
+  // Stellar
+  stellar: "stellar:pubnet",
+  // NEAR
+  near: "near:mainnet",
+  // Algorand
+  algorand: "algorand:mainnet",
+  "algorand-testnet": "algorand:testnet"
+};
+Object.fromEntries(
+  Object.entries(CAIP2_IDENTIFIERS).map(([k, v]) => [v, k])
+);
+
+// src/chains/index.ts
+var DEFAULT_FACILITATOR_URL = "https://facilitator.ultravioletadao.xyz";
+var SUPPORTED_CHAINS = {
+  // ============================================================================
+  // EVM CHAINS (10 networks)
+  // ============================================================================
+  base: {
+    chainId: 8453,
+    chainIdHex: "0x2105",
+    name: "base",
+    displayName: "Base",
+    networkType: "evm",
+    rpcUrl: "https://mainnet.base.org",
+    explorerUrl: "https://basescan.org",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    tokens: {
+      usdc: {
+        address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        decimals: 6,
+        name: "USD Coin",
+        version: "2"
+      },
+      eurc: {
+        address: "0x60a3E35Cc302bFA44Cb288Bc5a4F316Fdb1adb42",
+        decimals: 6,
+        name: "EURC",
+        version: "2"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  avalanche: {
+    chainId: 43114,
+    chainIdHex: "0xa86a",
+    name: "avalanche",
+    displayName: "Avalanche C-Chain",
+    networkType: "evm",
+    rpcUrl: "https://avalanche-c-chain-rpc.publicnode.com",
+    explorerUrl: "https://snowtrace.io",
+    nativeCurrency: {
+      name: "Avalanche",
+      symbol: "AVAX",
+      decimals: 18
+    },
+    usdc: {
+      address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    tokens: {
+      usdc: {
+        address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+        decimals: 6,
+        name: "USD Coin",
+        version: "2"
+      },
+      eurc: {
+        address: "0xC891EB4cbdEFf6e073e859e987815Ed1505c2ACD",
+        decimals: 6,
+        name: "EURC",
+        version: "2"
+      },
+      ausd: {
+        address: "0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a",
+        decimals: 6,
+        name: "Agora Dollar",
+        version: "1"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  ethereum: {
+    chainId: 1,
+    chainIdHex: "0x1",
+    name: "ethereum",
+    displayName: "Ethereum",
+    networkType: "evm",
+    rpcUrl: "https://eth.llamarpc.com",
+    explorerUrl: "https://etherscan.io",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    tokens: {
+      usdc: {
+        address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        decimals: 6,
+        name: "USD Coin",
+        version: "2"
+      },
+      eurc: {
+        address: "0x1aBaEA1f7C830bD89Acc67eC4af516284b1bC33c",
+        decimals: 6,
+        name: "Euro Coin",
+        version: "2"
+      },
+      ausd: {
+        address: "0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a",
+        decimals: 6,
+        name: "Agora Dollar",
+        version: "1"
+      },
+      pyusd: {
+        address: "0x6c3ea9036406852006290770BEdFcAbA0e23A0e8",
+        decimals: 6,
+        name: "PayPal USD",
+        version: "1"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  polygon: {
+    chainId: 137,
+    chainIdHex: "0x89",
+    name: "polygon",
+    displayName: "Polygon",
+    networkType: "evm",
+    rpcUrl: "https://polygon-rpc.com",
+    explorerUrl: "https://polygonscan.com",
+    nativeCurrency: {
+      name: "Polygon",
+      symbol: "POL",
+      decimals: 18
+    },
+    usdc: {
+      address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    tokens: {
+      usdc: {
+        address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+        decimals: 6,
+        name: "USD Coin",
+        version: "2"
+      },
+      ausd: {
+        address: "0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a",
+        decimals: 6,
+        name: "Agora Dollar",
+        version: "1"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  arbitrum: {
+    chainId: 42161,
+    chainIdHex: "0xa4b1",
+    name: "arbitrum",
+    displayName: "Arbitrum One",
+    networkType: "evm",
+    rpcUrl: "https://arb1.arbitrum.io/rpc",
+    explorerUrl: "https://arbiscan.io",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    tokens: {
+      usdc: {
+        address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+        decimals: 6,
+        name: "USD Coin",
+        version: "2"
+      },
+      ausd: {
+        address: "0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a",
+        decimals: 6,
+        name: "Agora Dollar",
+        version: "1"
+      },
+      usdt: {
+        address: "0xFd086bC7CD5C481DCC9C85ebE478A1C0b69FCbb9",
+        decimals: 6,
+        name: "USD\u20AE0",
+        version: "1"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  optimism: {
+    chainId: 10,
+    chainIdHex: "0xa",
+    name: "optimism",
+    displayName: "Optimism",
+    networkType: "evm",
+    rpcUrl: "https://mainnet.optimism.io",
+    explorerUrl: "https://optimistic.etherscan.io",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    tokens: {
+      usdc: {
+        address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+        decimals: 6,
+        name: "USD Coin",
+        version: "2"
+      },
+      usdt: {
+        address: "0x01bff41798a0bcf287b996046ca68b395dbc1071",
+        decimals: 6,
+        name: "USD\u20AE0",
+        version: "1"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  celo: {
+    chainId: 42220,
+    chainIdHex: "0xa4ec",
+    name: "celo",
+    displayName: "Celo",
+    networkType: "evm",
+    rpcUrl: "https://forno.celo.org",
+    explorerUrl: "https://celoscan.io",
+    nativeCurrency: {
+      name: "Celo",
+      symbol: "CELO",
+      decimals: 18
+    },
+    usdc: {
+      address: "0xcebA9300f2b948710d2653dD7B07f33A8B32118C",
+      decimals: 6,
+      name: "USDC",
+      // Celo uses "USDC" not "USD Coin" for EIP-712
+      version: "2"
+    },
+    tokens: {
+      usdc: {
+        address: "0xcebA9300f2b948710d2653dD7B07f33A8B32118C",
+        decimals: 6,
+        name: "USDC",
+        // Celo uses "USDC" not "USD Coin" for EIP-712
+        version: "2"
+      },
+      usdt: {
+        address: "0x48065fbBE25f71C9282ddf5e1cD6D6A887483D5e",
+        decimals: 6,
+        name: "Tether USD",
+        // Celo USDT uses "Tether USD" for EIP-712
+        version: "1"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  hyperevm: {
+    chainId: 999,
+    chainIdHex: "0x3e7",
+    name: "hyperevm",
+    displayName: "HyperEVM",
+    networkType: "evm",
+    rpcUrl: "https://rpc.hyperliquid.xyz/evm",
+    explorerUrl: "https://hyperevmscan.io",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+      decimals: 6,
+      name: "USDC",
+      // HyperEVM uses "USDC" not "USD Coin"
+      version: "2"
+    },
+    tokens: {
+      usdc: {
+        address: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+        decimals: 6,
+        name: "USDC",
+        // HyperEVM uses "USDC" not "USD Coin"
+        version: "2"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  unichain: {
+    chainId: 130,
+    chainIdHex: "0x82",
+    name: "unichain",
+    displayName: "Unichain",
+    networkType: "evm",
+    rpcUrl: "https://unichain-rpc.publicnode.com",
+    explorerUrl: "https://uniscan.xyz",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0x078d782b760474a361dda0af3839290b0ef57ad6",
+      decimals: 6,
+      name: "USDC",
+      // Unichain uses "USDC" not "USD Coin"
+      version: "2"
+    },
+    tokens: {
+      usdc: {
+        address: "0x078d782b760474a361dda0af3839290b0ef57ad6",
+        decimals: 6,
+        name: "USDC",
+        // Unichain uses "USDC" not "USD Coin"
+        version: "2"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  monad: {
+    chainId: 143,
+    chainIdHex: "0x8f",
+    name: "monad",
+    displayName: "Monad",
+    networkType: "evm",
+    rpcUrl: "https://rpc.monad.xyz",
+    explorerUrl: "https://monad.socialscan.io",
+    nativeCurrency: {
+      name: "Monad",
+      symbol: "MON",
+      decimals: 18
+    },
+    usdc: {
+      address: "0x754704bc059f8c67012fed69bc8a327a5aafb603",
+      decimals: 6,
+      name: "USDC",
+      // Monad uses "USDC" not "USD Coin"
+      version: "2"
+    },
+    tokens: {
+      usdc: {
+        address: "0x754704bc059f8c67012fed69bc8a327a5aafb603",
+        decimals: 6,
+        name: "USDC",
+        // Monad uses "USDC" not "USD Coin"
+        version: "2"
+      },
+      ausd: {
+        address: "0x00000000eFE302BEAA2b3e6e1b18d08D69a9012a",
+        decimals: 6,
+        name: "Agora Dollar",
+        version: "1"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  // ============================================================================
+  // SVM CHAINS (2 networks) - Solana Virtual Machine
+  // ============================================================================
+  solana: {
+    chainId: 0,
+    // Non-EVM
+    chainIdHex: "0x0",
+    name: "solana",
+    displayName: "Solana",
+    networkType: "svm",
+    rpcUrl: "https://api.mainnet-beta.solana.com",
+    explorerUrl: "https://solscan.io",
+    nativeCurrency: {
+      name: "Solana",
+      symbol: "SOL",
+      decimals: 9
+    },
+    usdc: {
+      address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+      // USDC SPL token mint
+      decimals: 6,
+      name: "USD Coin",
+      version: "1"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  fogo: {
+    chainId: 0,
+    // Non-EVM (SVM)
+    chainIdHex: "0x0",
+    name: "fogo",
+    displayName: "Fogo",
+    networkType: "svm",
+    rpcUrl: "https://rpc.fogo.nightly.app/",
+    explorerUrl: "https://explorer.fogo.nightly.app",
+    nativeCurrency: {
+      name: "Fogo",
+      symbol: "FOGO",
+      decimals: 9
+    },
+    usdc: {
+      address: "uSd2czE61Evaf76RNbq4KPpXnkiL3irdzgLFUMe3NoG",
+      // Fogo USDC mint
+      decimals: 6,
+      name: "USDC",
+      version: "1"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  // ============================================================================
+  // STELLAR (1 network)
+  // ============================================================================
+  stellar: {
+    chainId: 0,
+    // Non-EVM
+    chainIdHex: "0x0",
+    name: "stellar",
+    displayName: "Stellar",
+    networkType: "stellar",
+    rpcUrl: "https://horizon.stellar.org",
+    explorerUrl: "https://stellar.expert/explorer/public",
+    nativeCurrency: {
+      name: "Lumens",
+      symbol: "XLM",
+      decimals: 7
+      // Stellar uses 7 decimals (stroops)
+    },
+    usdc: {
+      address: "CCW67TSZV3SSS2HXMBQ5JFGCKJNXKZM7UQUWUZPUTHXSTZLEO7SJMI75",
+      // Soroban Asset Contract
+      decimals: 7,
+      // Stellar USDC uses 7 decimals
+      name: "USDC",
+      version: "1"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  // ============================================================================
+  // NEAR (1 network) - Uses NEP-366 meta-transactions
+  // ============================================================================
+  near: {
+    chainId: 0,
+    // Non-EVM
+    chainIdHex: "0x0",
+    name: "near",
+    displayName: "NEAR Protocol",
+    networkType: "near",
+    rpcUrl: "https://rpc.mainnet.near.org",
+    explorerUrl: "https://nearblocks.io",
+    nativeCurrency: {
+      name: "NEAR",
+      symbol: "NEAR",
+      decimals: 24
+      // NEAR uses 24 decimals (yoctoNEAR)
+    },
+    usdc: {
+      address: "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
+      // Native Circle USDC
+      decimals: 6,
+      name: "USDC",
+      version: "1"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+      // NEP-366 meta-transactions supported
+    }
+  },
+  // ============================================================================
+  // ALGORAND (2 networks) - Uses ASA transfers with atomic transaction groups
+  // ============================================================================
+  algorand: {
+    chainId: 0,
+    // Non-EVM (Algorand uses genesis hash for network identification)
+    chainIdHex: "0x0",
+    name: "algorand",
+    displayName: "Algorand",
+    networkType: "algorand",
+    rpcUrl: "https://mainnet-api.algonode.cloud",
+    explorerUrl: "https://allo.info",
+    nativeCurrency: {
+      name: "Algo",
+      symbol: "ALGO",
+      decimals: 6
+      // Algorand uses 6 decimals (microAlgos)
+    },
+    usdc: {
+      address: "31566704",
+      // USDC ASA ID on Algorand mainnet
+      decimals: 6,
+      name: "USDC",
+      version: "1"
+    },
+    tokens: {
+      usdc: {
+        address: "31566704",
+        // USDC ASA ID on Algorand mainnet
+        decimals: 6,
+        name: "USDC",
+        version: "1"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  "algorand-testnet": {
+    chainId: 0,
+    // Non-EVM
+    chainIdHex: "0x0",
+    name: "algorand-testnet",
+    displayName: "Algorand Testnet",
+    networkType: "algorand",
+    rpcUrl: "https://testnet-api.algonode.cloud",
+    explorerUrl: "https://testnet.allo.info",
+    nativeCurrency: {
+      name: "Algo",
+      symbol: "ALGO",
+      decimals: 6
+    },
+    usdc: {
+      address: "10458941",
+      // USDC ASA ID on Algorand testnet
+      decimals: 6,
+      name: "USDC",
+      version: "1"
+    },
+    tokens: {
+      usdc: {
+        address: "10458941",
+        // USDC ASA ID on Algorand testnet
+        decimals: 6,
+        name: "USDC",
+        version: "1"
+      }
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  }
+};
+function getChainByName(name) {
+  return SUPPORTED_CHAINS[name.toLowerCase()];
+}
+
+// src/utils/x402.ts
+function chainToCAIP2(chainName) {
+  const caip2 = CAIP2_IDENTIFIERS[chainName.toLowerCase()];
+  if (caip2) {
+    return caip2;
+  }
+  const chain = getChainByName(chainName);
+  if (chain) {
+    if (chain.networkType === "evm") {
+      return `eip155:${chain.chainId}`;
+    }
+    return `${chain.networkType}:${chainName}`;
+  }
+  return chainName;
+}
+function decodeX402Header(encoded) {
+  const json = atob(encoded);
+  return JSON.parse(json);
+}
+
+// src/backend/index.ts
+function parsePaymentHeader(headerValue) {
+  if (!headerValue) {
+    return null;
+  }
+  try {
+    return decodeX402Header(headerValue);
+  } catch {
+    return null;
+  }
+}
+function extractPaymentFromHeaders(headers) {
+  const normalizedHeaders = {};
+  for (const [key, value] of Object.entries(headers)) {
+    if (typeof value === "string") {
+      normalizedHeaders[key.toLowerCase()] = value;
+    } else if (Array.isArray(value) && value.length > 0) {
+      normalizedHeaders[key.toLowerCase()] = value[0];
+    }
+  }
+  const headerValue = normalizedHeaders["x-payment"] || normalizedHeaders["payment-signature"];
+  return parsePaymentHeader(headerValue);
+}
+function buildPaymentRequirements(options) {
+  const {
+    amount,
+    recipient,
+    resource,
+    chainName = "base",
+    description = "Payment for resource access",
+    mimeType = "application/json",
+    timeoutSeconds = 300,
+    x402Version = 1
+  } = options;
+  const chain = getChainByName(chainName);
+  if (!chain) {
+    throw new Error(`Unsupported chain: ${chainName}`);
+  }
+  const atomicAmount = Math.floor(
+    parseFloat(amount) * Math.pow(10, chain.usdc.decimals)
+  ).toString();
+  const network = x402Version === 2 ? chainToCAIP2(chainName) : chainName;
+  return {
+    scheme: "exact",
+    network,
+    maxAmountRequired: atomicAmount,
+    resource,
+    description,
+    mimeType,
+    payTo: recipient,
+    maxTimeoutSeconds: timeoutSeconds,
+    asset: chain.usdc.address
+  };
+}
+function buildVerifyRequest(paymentHeader, requirements) {
+  return {
+    x402Version: paymentHeader.x402Version,
+    paymentPayload: paymentHeader,
+    paymentRequirements: requirements
+  };
+}
+function buildSettleRequest(paymentHeader, requirements) {
+  return {
+    x402Version: paymentHeader.x402Version,
+    paymentPayload: paymentHeader,
+    paymentRequirements: requirements
+  };
+}
+var X402_CORS_HEADERS = {
+  "Access-Control-Allow-Headers": "Content-Type, X-PAYMENT, PAYMENT-SIGNATURE, Authorization",
+  "Access-Control-Expose-Headers": "X-PAYMENT-RESPONSE, PAYMENT-RESPONSE, PAYMENT-REQUIRED",
+  "Access-Control-Allow-Methods": "GET, POST, OPTIONS"
+};
+var X402_HEADER_NAMES = [
+  "X-PAYMENT",
+  "PAYMENT-SIGNATURE",
+  "X-PAYMENT-RESPONSE",
+  "PAYMENT-RESPONSE",
+  "PAYMENT-REQUIRED"
+];
+function getCorsHeaders(origin = "*") {
+  return {
+    "Access-Control-Allow-Origin": origin,
+    ...X402_CORS_HEADERS
+  };
+}
+var FacilitatorClient = class {
+  baseUrl;
+  timeout;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl || "https://facilitator.ultravioletadao.xyz";
+    this.timeout = options.timeout || 3e4;
+  }
+  /**
+   * Verify a payment with the facilitator
+   *
+   * Call this before providing the paid resource to validate the payment.
+   *
+   * @param paymentHeader - Parsed x402 payment header
+   * @param requirements - Payment requirements
+   * @returns Verification result
+   */
+  async verify(paymentHeader, requirements) {
+    const body = buildVerifyRequest(paymentHeader, requirements);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/verify`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          isValid: false,
+          invalidReason: `Facilitator error: ${response.status} - ${errorText}`
+        };
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      return {
+        isValid: false,
+        invalidReason: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Settle a payment with the facilitator
+   *
+   * Call this after providing the paid resource to execute the on-chain transfer.
+   *
+   * @param paymentHeader - Parsed x402 payment header
+   * @param requirements - Payment requirements
+   * @returns Settlement result with transaction hash
+   */
+  async settle(paymentHeader, requirements) {
+    const body = buildSettleRequest(paymentHeader, requirements);
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(`${this.baseUrl}/settle`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(body),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        return {
+          success: false,
+          error: `Facilitator error: ${response.status} - ${errorText}`
+        };
+      }
+      const result = await response.json();
+      return {
+        success: true,
+        transactionHash: result.transactionHash || result.transaction_hash,
+        network: result.network
+      };
+    } catch (error) {
+      clearTimeout(timeoutId);
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : "Unknown error"
+      };
+    }
+  }
+  /**
+   * Verify and settle atomically
+   *
+   * Convenience method that verifies first, then settles if valid.
+   * Use this for simple payment flows where you don't need custom logic between verify and settle.
+   *
+   * @param paymentHeader - Parsed x402 payment header
+   * @param requirements - Payment requirements
+   * @returns Combined result with verify and settle status
+   */
+  async verifyAndSettle(paymentHeader, requirements) {
+    const verifyResult = await this.verify(paymentHeader, requirements);
+    if (!verifyResult.isValid) {
+      return {
+        verified: false,
+        settled: false,
+        error: verifyResult.invalidReason
+      };
+    }
+    const settleResult = await this.settle(paymentHeader, requirements);
+    return {
+      verified: true,
+      settled: settleResult.success,
+      transactionHash: settleResult.transactionHash,
+      error: settleResult.error
+    };
+  }
+  /**
+   * Check if the facilitator is healthy
+   *
+   * @returns True if the facilitator is responding
+   */
+  async healthCheck() {
+    try {
+      const response = await fetch(`${this.baseUrl}/health`, {
+        method: "GET"
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+function create402Response(requirements, options = {}) {
+  const reqs = buildPaymentRequirements(requirements);
+  const body = {
+    x402Version: requirements.x402Version || 1,
+    ...reqs
+  };
+  if (options.accepts) {
+    body.accepts = options.accepts;
+  }
+  return {
+    status: 402,
+    headers: {
+      "Content-Type": "application/json",
+      ...X402_CORS_HEADERS
+    },
+    body
+  };
+}
+function createPaymentMiddleware(getRequirements, options = {}) {
+  const client = new FacilitatorClient(options);
+  return async (req, res, next) => {
+    const payment = extractPaymentFromHeaders(req.headers);
+    if (!payment) {
+      const reqOptions2 = getRequirements(req);
+      const { status, headers, body } = create402Response(reqOptions2);
+      res.status(status).set(headers).json(body);
+      return;
+    }
+    const reqOptions = getRequirements(req);
+    const requirements = buildPaymentRequirements(reqOptions);
+    const verifyResult = await client.verify(payment, requirements);
+    if (!verifyResult.isValid) {
+      res.status(402).json({
+        error: "Payment verification failed",
+        reason: verifyResult.invalidReason
+      });
+      return;
+    }
+    next();
+  };
+}
+var BazaarClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl || "https://bazaar.ultravioletadao.xyz";
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout || 3e4;
+  }
+  /**
+   * Discover x402-enabled resources
+   *
+   * @param options - Discovery filters
+   * @returns Paginated list of matching resources
+   *
+   * @example
+   * ```ts
+   * // Find AI APIs on Base with USDC under $0.10
+   * const results = await bazaar.discover({
+   *   category: 'ai',
+   *   network: 'base',
+   *   token: 'USDC',
+   *   maxPrice: '0.10',
+   * });
+   *
+   * for (const resource of results.resources) {
+   *   console.log(`${resource.name}: ${resource.url}`);
+   * }
+   * ```
+   */
+  async discover(options = {}) {
+    const params = new URLSearchParams();
+    if (options.category) params.set("category", options.category);
+    if (options.network) params.set("network", options.network);
+    if (options.token) params.set("token", options.token);
+    if (options.provider) params.set("provider", options.provider);
+    if (options.tags?.length) params.set("tags", options.tags.join(","));
+    if (options.query) params.set("query", options.query);
+    if (options.maxPrice) params.set("maxPrice", options.maxPrice);
+    if (options.page) params.set("page", options.page.toString());
+    if (options.limit) params.set("limit", options.limit.toString());
+    if (options.sortBy) params.set("sortBy", options.sortBy);
+    if (options.sortOrder) params.set("sortOrder", options.sortOrder);
+    const url = `${this.baseUrl}/resources${params.toString() ? `?${params}` : ""}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Accept": "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Bazaar API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Get a specific resource by ID
+   *
+   * @param resourceId - Resource ID
+   * @returns Resource details
+   */
+  async getResource(resourceId) {
+    const url = `${this.baseUrl}/resources/${encodeURIComponent(resourceId)}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Accept": "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Bazaar API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Get a resource by its URL
+   *
+   * @param resourceUrl - Resource URL
+   * @returns Resource details
+   */
+  async getResourceByUrl(resourceUrl) {
+    const url = `${this.baseUrl}/resources/by-url?url=${encodeURIComponent(resourceUrl)}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Accept": "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Bazaar API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Register a new resource in the Bazaar
+   *
+   * Requires API key authentication.
+   *
+   * @param options - Resource registration options
+   * @returns Registered resource
+   *
+   * @example
+   * ```ts
+   * const resource = await bazaar.register({
+   *   url: 'https://api.example.com/v1/generate',
+   *   name: 'Image Generator API',
+   *   description: 'Generate images with AI',
+   *   category: 'ai',
+   *   networks: ['base', 'ethereum', 'polygon'],
+   *   price: '0.05',
+   *   payTo: '0x1234...',
+   *   tags: ['ai', 'image', 'generator'],
+   * });
+   * ```
+   */
+  async register(options) {
+    if (!this.apiKey) {
+      throw new Error("API key required for resource registration");
+    }
+    const url = `${this.baseUrl}/resources`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify({
+          url: options.url,
+          name: options.name,
+          description: options.description,
+          category: options.category,
+          networks: options.networks,
+          tokens: options.tokens || ["USDC"],
+          price: options.price,
+          priceCurrency: options.priceCurrency || "USDC",
+          payTo: options.payTo,
+          mimeType: options.mimeType || "application/json",
+          outputSchema: options.outputSchema,
+          tags: options.tags
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Bazaar API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Update an existing resource
+   *
+   * Requires API key authentication. Only the owner can update.
+   *
+   * @param resourceId - Resource ID to update
+   * @param updates - Partial update options
+   * @returns Updated resource
+   */
+  async update(resourceId, updates) {
+    if (!this.apiKey) {
+      throw new Error("API key required for resource update");
+    }
+    const url = `${this.baseUrl}/resources/${encodeURIComponent(resourceId)}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "PATCH",
+        headers: {
+          "Content-Type": "application/json",
+          "Accept": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        body: JSON.stringify(updates),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Bazaar API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Delete a resource from the Bazaar
+   *
+   * Requires API key authentication. Only the owner can delete.
+   *
+   * @param resourceId - Resource ID to delete
+   */
+  async delete(resourceId) {
+    if (!this.apiKey) {
+      throw new Error("API key required for resource deletion");
+    }
+    const url = `${this.baseUrl}/resources/${encodeURIComponent(resourceId)}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "DELETE",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Bazaar API error: ${response.status} - ${errorText}`);
+      }
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Deactivate a resource (soft delete)
+   *
+   * Requires API key authentication. Only the owner can deactivate.
+   *
+   * @param resourceId - Resource ID to deactivate
+   * @returns Updated resource with isActive: false
+   */
+  async deactivate(resourceId) {
+    if (!this.apiKey) {
+      throw new Error("API key required for resource deactivation");
+    }
+    const url = `${this.baseUrl}/resources/${encodeURIComponent(resourceId)}/deactivate`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Bazaar API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Reactivate a deactivated resource
+   *
+   * Requires API key authentication. Only the owner can reactivate.
+   *
+   * @param resourceId - Resource ID to reactivate
+   * @returns Updated resource with isActive: true
+   */
+  async reactivate(resourceId) {
+    if (!this.apiKey) {
+      throw new Error("API key required for resource reactivation");
+    }
+    const url = `${this.baseUrl}/resources/${encodeURIComponent(resourceId)}/reactivate`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: {
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Bazaar API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * List all resources owned by the authenticated user
+   *
+   * Requires API key authentication.
+   *
+   * @param options - Pagination options
+   * @returns Paginated list of owned resources
+   */
+  async listMyResources(options = {}) {
+    if (!this.apiKey) {
+      throw new Error("API key required to list owned resources");
+    }
+    const params = new URLSearchParams();
+    if (options.page) params.set("page", options.page.toString());
+    if (options.limit) params.set("limit", options.limit.toString());
+    if (options.includeInactive) params.set("includeInactive", "true");
+    const url = `${this.baseUrl}/resources/mine${params.toString() ? `?${params}` : ""}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: {
+          "Accept": "application/json",
+          "Authorization": `Bearer ${this.apiKey}`
+        },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Bazaar API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Get Bazaar API health status
+   *
+   * @returns True if the Bazaar API is healthy
+   */
+  async healthCheck() {
+    try {
+      const response = await fetch(`${this.baseUrl}/health`, {
+        method: "GET"
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get Bazaar statistics
+   *
+   * @returns Global statistics about the Bazaar
+   */
+  async getStats() {
+    const url = `${this.baseUrl}/stats`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: { "Accept": "application/json" },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Bazaar API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+};
+var EscrowClient = class {
+  baseUrl;
+  apiKey;
+  timeout;
+  constructor(options = {}) {
+    this.baseUrl = options.baseUrl || "https://escrow.ultravioletadao.xyz";
+    this.apiKey = options.apiKey;
+    this.timeout = options.timeout || 3e4;
+  }
+  getHeaders(authenticated = false) {
+    const headers = {
+      "Content-Type": "application/json",
+      "Accept": "application/json"
+    };
+    if (authenticated && this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    return headers;
+  }
+  /**
+   * Create an escrow payment
+   *
+   * Holds the payment in escrow until released or refunded.
+   *
+   * @param options - Escrow creation options
+   * @returns Created escrow payment
+   */
+  async createEscrow(options) {
+    const url = `${this.baseUrl}/escrow`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.getHeaders(true),
+        body: JSON.stringify({
+          paymentHeader: options.paymentHeader,
+          paymentRequirements: options.requirements,
+          escrowDuration: options.escrowDuration || 86400,
+          releaseConditions: options.releaseConditions
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Escrow API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Get escrow payment by ID
+   *
+   * @param escrowId - Escrow payment ID
+   * @returns Escrow payment details
+   */
+  async getEscrow(escrowId) {
+    const url = `${this.baseUrl}/escrow/${encodeURIComponent(escrowId)}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: this.getHeaders(),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Escrow API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Release escrow funds to recipient
+   *
+   * Call this after service has been successfully provided.
+   *
+   * @param escrowId - Escrow payment ID
+   * @returns Updated escrow payment with transaction hash
+   */
+  async release(escrowId) {
+    const url = `${this.baseUrl}/escrow/${encodeURIComponent(escrowId)}/release`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.getHeaders(true),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Escrow API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Request a refund for an escrow payment
+   *
+   * Initiates a refund request that must be approved.
+   *
+   * @param options - Refund request options
+   * @returns Created refund request
+   */
+  async requestRefund(options) {
+    const url = `${this.baseUrl}/escrow/${encodeURIComponent(options.escrowId)}/refund`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.getHeaders(true),
+        body: JSON.stringify({
+          reason: options.reason,
+          amount: options.amount,
+          evidence: options.evidence
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Escrow API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Approve a refund request (for recipients)
+   *
+   * @param refundId - Refund request ID
+   * @param amount - Amount to approve (may be less than requested)
+   * @returns Updated refund request
+   */
+  async approveRefund(refundId, amount) {
+    const url = `${this.baseUrl}/refund/${encodeURIComponent(refundId)}/approve`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.getHeaders(true),
+        body: JSON.stringify({ amount }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Escrow API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Reject a refund request (for recipients)
+   *
+   * @param refundId - Refund request ID
+   * @param reason - Reason for rejection
+   * @returns Updated refund request
+   */
+  async rejectRefund(refundId, reason) {
+    const url = `${this.baseUrl}/refund/${encodeURIComponent(refundId)}/reject`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.getHeaders(true),
+        body: JSON.stringify({ reason }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Escrow API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Get refund request by ID
+   *
+   * @param refundId - Refund request ID
+   * @returns Refund request details
+   */
+  async getRefund(refundId) {
+    const url = `${this.baseUrl}/refund/${encodeURIComponent(refundId)}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: this.getHeaders(),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Escrow API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Open a dispute for an escrow payment
+   *
+   * Initiates arbitration when payer and recipient disagree.
+   *
+   * @param escrowId - Escrow payment ID
+   * @param reason - Reason for dispute
+   * @param evidence - Supporting evidence
+   * @returns Created dispute
+   */
+  async openDispute(escrowId, reason, evidence) {
+    const url = `${this.baseUrl}/escrow/${encodeURIComponent(escrowId)}/dispute`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.getHeaders(true),
+        body: JSON.stringify({ reason, evidence }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Escrow API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Submit evidence to a dispute
+   *
+   * @param disputeId - Dispute ID
+   * @param evidence - Evidence to submit
+   * @returns Updated dispute
+   */
+  async submitEvidence(disputeId, evidence) {
+    const url = `${this.baseUrl}/dispute/${encodeURIComponent(disputeId)}/evidence`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "POST",
+        headers: this.getHeaders(true),
+        body: JSON.stringify({ evidence }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Escrow API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Get dispute by ID
+   *
+   * @param disputeId - Dispute ID
+   * @returns Dispute details
+   */
+  async getDispute(disputeId) {
+    const url = `${this.baseUrl}/dispute/${encodeURIComponent(disputeId)}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: this.getHeaders(),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Escrow API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * List escrow payments (with filters)
+   *
+   * @param options - Filter and pagination options
+   * @returns Paginated list of escrow payments
+   */
+  async listEscrows(options = {}) {
+    const params = new URLSearchParams();
+    if (options.status) params.set("status", options.status);
+    if (options.payer) params.set("payer", options.payer);
+    if (options.recipient) params.set("recipient", options.recipient);
+    if (options.page) params.set("page", options.page.toString());
+    if (options.limit) params.set("limit", options.limit.toString());
+    const url = `${this.baseUrl}/escrow${params.toString() ? `?${params}` : ""}`;
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+    try {
+      const response = await fetch(url, {
+        method: "GET",
+        headers: this.getHeaders(true),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`Escrow API error: ${response.status} - ${errorText}`);
+      }
+      return await response.json();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  /**
+   * Check Escrow API health
+   *
+   * @returns True if healthy
+   */
+  async healthCheck() {
+    try {
+      const response = await fetch(`${this.baseUrl}/health`, {
+        method: "GET"
+      });
+      return response.ok;
+    } catch {
+      return false;
+    }
+  }
+};
+function canReleaseEscrow(escrow) {
+  if (escrow.status !== "held") {
+    return false;
+  }
+  if (new Date(escrow.expiresAt) < /* @__PURE__ */ new Date()) {
+    return false;
+  }
+  if (escrow.releaseConditions?.minHoldTime) {
+    const createdAt = new Date(escrow.createdAt);
+    const minReleaseTime = new Date(
+      createdAt.getTime() + escrow.releaseConditions.minHoldTime * 1e3
+    );
+    if (/* @__PURE__ */ new Date() < minReleaseTime) {
+      return false;
+    }
+  }
+  return true;
+}
+function canRefundEscrow(escrow) {
+  return escrow.status === "held" || escrow.status === "pending";
+}
+function isEscrowExpired(escrow) {
+  return new Date(escrow.expiresAt) < /* @__PURE__ */ new Date();
+}
+function escrowTimeRemaining(escrow) {
+  return new Date(escrow.expiresAt).getTime() - Date.now();
+}
+
+exports.BazaarClient = BazaarClient;
+exports.EscrowClient = EscrowClient;
+exports.FacilitatorClient = FacilitatorClient;
+exports.X402_CORS_HEADERS = X402_CORS_HEADERS;
+exports.X402_HEADER_NAMES = X402_HEADER_NAMES;
+exports.buildPaymentRequirements = buildPaymentRequirements;
+exports.buildSettleRequest = buildSettleRequest;
+exports.buildVerifyRequest = buildVerifyRequest;
+exports.canRefundEscrow = canRefundEscrow;
+exports.canReleaseEscrow = canReleaseEscrow;
+exports.create402Response = create402Response;
+exports.createPaymentMiddleware = createPaymentMiddleware;
+exports.escrowTimeRemaining = escrowTimeRemaining;
+exports.extractPaymentFromHeaders = extractPaymentFromHeaders;
+exports.getCorsHeaders = getCorsHeaders;
+exports.isEscrowExpired = isEscrowExpired;
+exports.parsePaymentHeader = parsePaymentHeader;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map