@circle-fin/x402-batching 2.0.3

package/dist/client/index.mjs

@@ -0,0 +1,1282 @@
+// src/client/BatchEvmScheme.ts
+import { getAddress } from "viem";
+
+// src/constants.ts
+var CIRCLE_BATCHING_NAME = "GatewayWalletBatched";
+var CIRCLE_BATCHING_VERSION = "1";
+var CIRCLE_BATCHING_SCHEME = "exact";
+
+// src/detection.ts
+function supportsBatching(requirements) {
+  const extra = requirements.extra;
+  if (!extra) {
+    return false;
+  }
+  return extra.name === CIRCLE_BATCHING_NAME && extra.version === CIRCLE_BATCHING_VERSION;
+}
+function getVerifyingContract(requirements) {
+  if (!supportsBatching(requirements)) {
+    return void 0;
+  }
+  const verifyingContract = requirements.extra?.verifyingContract;
+  if (typeof verifyingContract === "string") {
+    return verifyingContract;
+  }
+  return void 0;
+}
+
+// src/client/BatchEvmScheme.ts
+var authorizationTypes = {
+  TransferWithAuthorization: [
+    { 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 createNonce() {
+  const bytes = new Uint8Array(32);
+  crypto.getRandomValues(bytes);
+  return `0x${Array.from(bytes).map((b) => b.toString(16).padStart(2, "0")).join("")}`;
+}
+var BatchEvmScheme = class {
+  /**
+   * Creates a new BatchEvmScheme.
+   *
+   * @param signer - The EVM signer for signing payment authorizations
+   */
+  constructor(signer) {
+    this.signer = signer;
+  }
+  scheme = CIRCLE_BATCHING_SCHEME;
+  /**
+   * Creates a payment payload for Circle batching.
+   *
+   * @param x402Version - The x402 protocol version
+   * @param paymentRequirements - The payment requirements (must be a Circle batching option)
+   * @returns Promise resolving to the payment payload
+   * @throws Error if requirements are not a Circle batching option
+   */
+  async createPaymentPayload(x402Version, paymentRequirements) {
+    if (!supportsBatching(paymentRequirements)) {
+      throw new Error(
+        `BatchEvmScheme can only handle Circle batching options. Expected extra.name="${CIRCLE_BATCHING_NAME}" and extra.version="${CIRCLE_BATCHING_VERSION}"`
+      );
+    }
+    const verifyingContract = getVerifyingContract(paymentRequirements);
+    if (!verifyingContract) {
+      throw new Error(
+        "Circle batching option missing extra.verifyingContract (GatewayWallet address)"
+      );
+    }
+    const nonce = createNonce();
+    const now = Math.floor(Date.now() / 1e3);
+    const authorization = {
+      from: this.signer.address,
+      to: getAddress(paymentRequirements.payTo),
+      value: paymentRequirements.amount,
+      validAfter: (now - 600).toString(),
+      // 10 minutes before
+      validBefore: (now + paymentRequirements.maxTimeoutSeconds).toString(),
+      nonce
+    };
+    const signature = await this.signAuthorization(
+      authorization,
+      paymentRequirements,
+      verifyingContract
+    );
+    const payload = {
+      authorization,
+      signature
+    };
+    return {
+      x402Version,
+      payload
+    };
+  }
+  /**
+   * Sign the EIP-3009 authorization using EIP-712.
+   * Uses the GatewayWallet contract as verifyingContract instead of USDC.
+   */
+  async signAuthorization(authorization, requirements, verifyingContract) {
+    if (!requirements.network.startsWith("eip155:")) {
+      throw new Error(
+        `BatchEvmScheme: unsupported network format "${requirements.network}". Expected "eip155:<chainId>"`
+      );
+    }
+    const chainId = parseInt(requirements.network.split(":")[1]);
+    const domain = {
+      name: CIRCLE_BATCHING_NAME,
+      version: CIRCLE_BATCHING_VERSION,
+      chainId,
+      verifyingContract: getAddress(verifyingContract)
+    };
+    const message = {
+      from: getAddress(authorization.from),
+      to: getAddress(authorization.to),
+      value: BigInt(authorization.value),
+      validAfter: BigInt(authorization.validAfter),
+      validBefore: BigInt(authorization.validBefore),
+      nonce: authorization.nonce
+    };
+    return await this.signer.signTypedData({
+      domain,
+      types: authorizationTypes,
+      primaryType: "TransferWithAuthorization",
+      message
+    });
+  }
+};
+
+// src/client/CompositeEvmScheme.ts
+var CompositeEvmScheme = class {
+  constructor(batchScheme, fallbackScheme) {
+    this.batchScheme = batchScheme;
+    this.fallbackScheme = fallbackScheme;
+    if (fallbackScheme.scheme !== CIRCLE_BATCHING_SCHEME) {
+      throw new Error(
+        `CompositeEvmScheme: fallbackScheme.scheme must be "${CIRCLE_BATCHING_SCHEME}", got "${fallbackScheme.scheme}"`
+      );
+    }
+  }
+  scheme = CIRCLE_BATCHING_SCHEME;
+  async createPaymentPayload(x402Version, paymentRequirements) {
+    if (supportsBatching(paymentRequirements)) {
+      return this.batchScheme.createPaymentPayload(x402Version, paymentRequirements);
+    }
+    return this.fallbackScheme.createPaymentPayload(x402Version, paymentRequirements);
+  }
+};
+
+// src/client/register.ts
+function registerBatchScheme(client, config) {
+  const batchScheme = new BatchEvmScheme(config.signer);
+  const schemeToRegister = config.fallbackScheme ? new CompositeEvmScheme(batchScheme, config.fallbackScheme) : batchScheme;
+  const networks = config.networks ?? ["eip155:*"];
+  for (const network of networks) {
+    client.register(network, schemeToRegister);
+  }
+  return schemeToRegister;
+}
+
+// src/client/GatewayClient.ts
+import {
+  createPublicClient,
+  createWalletClient,
+  http,
+  parseUnits,
+  formatUnits,
+  pad,
+  zeroAddress,
+  maxUint256,
+  defineChain,
+  erc20Abi
+} from "viem";
+import { privateKeyToAccount } from "viem/accounts";
+import * as chains from "viem/chains";
+import { randomBytes } from "crypto";
+var sonicTestnet = defineChain({
+  id: 14601,
+  name: "Sonic Testnet",
+  nativeCurrency: { decimals: 18, name: "Sonic", symbol: "S" },
+  rpcUrls: {
+    default: { http: ["https://rpc.testnet.soniclabs.com"] }
+  },
+  blockExplorers: {
+    default: { name: "Sonic Testnet Explorer", url: "https://testnet.soniclabs.com/" }
+  },
+  testnet: true
+});
+var GATEWAY_API_TESTNET = "https://gateway-api-testnet.circle.com/v1";
+var GATEWAY_API_MAINNET = "https://gateway-api.circle.com/v1";
+var GATEWAY_MINTER_ABI = [
+  {
+    name: "gatewayMint",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "attestationPayload", type: "bytes" },
+      { name: "signature", type: "bytes" }
+    ],
+    outputs: []
+  }
+];
+var GATEWAY_WALLET_ABI = [
+  {
+    name: "deposit",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "value", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "depositFor",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "depositor", type: "address" },
+      { name: "value", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "totalBalance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "depositor", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "availableBalance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "depositor", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "withdrawingBalance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "depositor", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "withdrawableBalance",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "depositor", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "withdrawalDelay",
+    type: "function",
+    stateMutability: "view",
+    inputs: [],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "withdrawalBlock",
+    type: "function",
+    stateMutability: "view",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "depositor", type: "address" }
+    ],
+    outputs: [{ name: "", type: "uint256" }]
+  },
+  {
+    name: "initiateWithdrawal",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [
+      { name: "token", type: "address" },
+      { name: "value", type: "uint256" }
+    ],
+    outputs: []
+  },
+  {
+    name: "withdraw",
+    type: "function",
+    stateMutability: "nonpayable",
+    inputs: [{ name: "token", type: "address" }],
+    outputs: []
+  }
+];
+var GATEWAY_DOMAINS = {
+  // Testnet
+  arbitrumSepolia: 3,
+  arcTestnet: 26,
+  avalancheFuji: 1,
+  baseSepolia: 6,
+  sepolia: 0,
+  hyperEvmTestnet: 19,
+  optimismSepolia: 2,
+  polygonAmoy: 7,
+  seiAtlantic: 16,
+  sonicTestnet: 13,
+  unichainSepolia: 10,
+  worldChainSepolia: 14,
+  // Mainnet
+  arbitrum: 3,
+  avalanche: 1,
+  base: 6,
+  mainnet: 0,
+  hyperEvm: 19,
+  optimism: 2,
+  polygon: 7,
+  sei: 16,
+  sonic: 13,
+  unichain: 10,
+  worldChain: 14
+};
+var TESTNET_GATEWAY_WALLET = "0x0077777d7EBA4688BDeF3E311b846F25870A19B9";
+var TESTNET_GATEWAY_MINTER = "0x0022222ABE238Cc2C7Bb1f21003F0a260052475B";
+var MAINNET_GATEWAY_WALLET = "0x77777777Dcc4d5A8B6E418Fd04D8997ef11000eE";
+var MAINNET_GATEWAY_MINTER = "0x2222222d7164433c4C09B0b0D809a9b52C04C205";
+var CHAIN_CONFIGS = {
+  // Testnet chains
+  arbitrumSepolia: {
+    chain: chains.arbitrumSepolia,
+    domain: GATEWAY_DOMAINS.arbitrumSepolia,
+    usdc: "0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  arcTestnet: {
+    chain: chains.arcTestnet,
+    domain: GATEWAY_DOMAINS.arcTestnet,
+    usdc: "0x3600000000000000000000000000000000000000",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER,
+    rpcUrl: "https://rpc.testnet.arc.network"
+  },
+  avalancheFuji: {
+    chain: chains.avalancheFuji,
+    domain: GATEWAY_DOMAINS.avalancheFuji,
+    usdc: "0x5425890298aed601595a70AB815c96711a31Bc65",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  baseSepolia: {
+    chain: chains.baseSepolia,
+    domain: GATEWAY_DOMAINS.baseSepolia,
+    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER,
+    rpcUrl: "https://sepolia-preconf.base.org"
+  },
+  sepolia: {
+    chain: chains.sepolia,
+    domain: GATEWAY_DOMAINS.sepolia,
+    usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  hyperEvmTestnet: {
+    chain: chains.hyperliquidEvmTestnet,
+    domain: GATEWAY_DOMAINS.hyperEvmTestnet,
+    usdc: "0x2B3370eE501B4a559b57D449569354196457D8Ab",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  optimismSepolia: {
+    chain: chains.optimismSepolia,
+    domain: GATEWAY_DOMAINS.optimismSepolia,
+    usdc: "0x5fd84259d66Cd46123540766Be93DFE6D43130D7",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  polygonAmoy: {
+    chain: chains.polygonAmoy,
+    domain: GATEWAY_DOMAINS.polygonAmoy,
+    usdc: "0x41E94Eb019C0762f9Bfcf9Fb1E58725BfB0e7582",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  seiAtlantic: {
+    chain: chains.seiTestnet,
+    domain: GATEWAY_DOMAINS.seiAtlantic,
+    usdc: "0x4fCF1784B31630811181f670Aea7A7bEF803eaED",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  sonicTestnet: {
+    chain: sonicTestnet,
+    domain: GATEWAY_DOMAINS.sonicTestnet,
+    usdc: "0x0BA304580ee7c9a980CF72e55f5Ed2E9fd30Bc51",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  unichainSepolia: {
+    chain: chains.unichainSepolia,
+    domain: GATEWAY_DOMAINS.unichainSepolia,
+    usdc: "0x31d0220469e10c4E71834a79b1f276d740d3768F",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  worldChainSepolia: {
+    chain: chains.worldchainSepolia,
+    domain: GATEWAY_DOMAINS.worldChainSepolia,
+    usdc: "0x66145f38cBAC35Ca6F1Dfb4914dF98F1614aeA88",
+    gatewayWallet: TESTNET_GATEWAY_WALLET,
+    gatewayMinter: TESTNET_GATEWAY_MINTER
+  },
+  // Mainnet chains
+  arbitrum: {
+    chain: chains.arbitrum,
+    domain: GATEWAY_DOMAINS.arbitrum,
+    usdc: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  avalanche: {
+    chain: chains.avalanche,
+    domain: GATEWAY_DOMAINS.avalanche,
+    usdc: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  base: {
+    chain: chains.base,
+    domain: GATEWAY_DOMAINS.base,
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  mainnet: {
+    chain: chains.mainnet,
+    domain: GATEWAY_DOMAINS.mainnet,
+    usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  hyperEvm: {
+    chain: chains.hyperEvm,
+    domain: GATEWAY_DOMAINS.hyperEvm,
+    usdc: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  optimism: {
+    chain: chains.optimism,
+    domain: GATEWAY_DOMAINS.optimism,
+    usdc: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  polygon: {
+    chain: chains.polygon,
+    domain: GATEWAY_DOMAINS.polygon,
+    usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  sei: {
+    chain: chains.sei,
+    domain: GATEWAY_DOMAINS.sei,
+    usdc: "0xe15fC38F6D8c56aF07bbCBe3BAf5708A2Bf42392",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  sonic: {
+    chain: chains.sonic,
+    domain: GATEWAY_DOMAINS.sonic,
+    usdc: "0x29219dd400f2Bf60E5a23d13Be72B486D4038894",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  unichain: {
+    chain: chains.unichain,
+    domain: GATEWAY_DOMAINS.unichain,
+    usdc: "0x078D782b760474a361dDA0AF3839290b0EF57AD6",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  },
+  worldChain: {
+    chain: chains.worldchain,
+    domain: GATEWAY_DOMAINS.worldChain,
+    usdc: "0x79A02482A880bCe3F13E09da970dC34dB4cD24D1",
+    gatewayWallet: MAINNET_GATEWAY_WALLET,
+    gatewayMinter: MAINNET_GATEWAY_MINTER
+  }
+};
+var GatewayClient = class {
+  chainConfig;
+  account;
+  publicClient;
+  walletClient;
+  /**
+   * Creates a new GatewayClient.
+   *
+   * @param config - Configuration including chain and private key
+   */
+  constructor(config) {
+    const chainConfig = CHAIN_CONFIGS[config.chain];
+    if (!chainConfig) {
+      throw new Error(`Unsupported chain: ${config.chain}`);
+    }
+    this.chainConfig = chainConfig;
+    this.account = privateKeyToAccount(config.privateKey);
+    const rpcUrl = config.rpcUrl ?? chainConfig.rpcUrl;
+    const transport = rpcUrl ? http(rpcUrl) : http();
+    this.publicClient = createPublicClient({
+      chain: chainConfig.chain,
+      transport
+    });
+    this.walletClient = createWalletClient({
+      account: this.account,
+      chain: chainConfig.chain,
+      transport
+    });
+  }
+  /**
+   * Get the account address.
+   */
+  get address() {
+    return this.account.address;
+  }
+  /**
+   * Get the chain name.
+   */
+  get chainName() {
+    return this.chainConfig.chain.name;
+  }
+  /**
+   * Get the Gateway domain for this chain.
+   */
+  get domain() {
+    return this.chainConfig.domain;
+  }
+  /**
+   * Get the chain name key for this client.
+   */
+  getChainName() {
+    for (const [name, config] of Object.entries(CHAIN_CONFIGS)) {
+      if (config.domain === this.chainConfig.domain && config.chain.id === this.chainConfig.chain.id) {
+        return name;
+      }
+    }
+    throw new Error("Unknown chain configuration");
+  }
+  /**
+   * Get the USDC balance of the account (not in Gateway).
+   *
+   * @param address - Optional address to check (defaults to account address)
+   * @returns USDC balance in atomic units and formatted
+   */
+  async getUsdcBalance(address) {
+    const target = address ?? this.account.address;
+    const balance = await this.publicClient.readContract({
+      address: this.chainConfig.usdc,
+      abi: erc20Abi,
+      functionName: "balanceOf",
+      args: [target]
+    });
+    return {
+      balance,
+      formatted: formatUnits(balance, 6)
+    };
+  }
+  /**
+   * Get all balances (wallet + gateway) in one call.
+   *
+   * @param address - Optional address to check (defaults to account address)
+   * @returns All balances
+   */
+  async getBalances(address) {
+    const target = address ?? this.account.address;
+    const [wallet, gateway] = await Promise.all([
+      this.getUsdcBalance(target),
+      this.getGatewayBalance(target)
+    ]);
+    return {
+      wallet,
+      gateway
+    };
+  }
+  /**
+   * Get the Gateway balance for an address.
+   *
+   * @param address - Optional address to check (defaults to account address)
+   * @returns Gateway balance information
+   * @deprecated Use `getBalances()` instead for a unified view
+   */
+  async getBalance(address) {
+    return this.getGatewayBalance(address);
+  }
+  /**
+   * Get the Gateway balance for an address via Gateway API.
+   */
+  async getGatewayBalance(address) {
+    const target = address ?? this.account.address;
+    const apiBaseUrl = this.isTestnet() ? GATEWAY_API_TESTNET : GATEWAY_API_MAINNET;
+    const response = await fetch(`${apiBaseUrl}/balances`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        token: "USDC",
+        sources: [{ depositor: target, domain: this.chainConfig.domain }]
+      })
+    });
+    const data = await response.json();
+    if (!response.ok) {
+      throw new Error(
+        `Gateway API balance fetch failed: ${data.message ?? response.statusText}`
+      );
+    }
+    if (!data.balances || data.balances.length === 0) {
+      throw new Error("Gateway API returned no balances for the depositor.");
+    }
+    const balanceData = data.balances[0];
+    const available = parseUnits(balanceData.balance, 6);
+    const withdrawing = parseUnits(balanceData.withdrawing ?? "0", 6);
+    const withdrawable = parseUnits(balanceData.withdrawable ?? "0", 6);
+    const total = available + withdrawing;
+    return {
+      total,
+      available,
+      withdrawing,
+      withdrawable,
+      formattedTotal: formatUnits(total, 6),
+      formattedAvailable: formatUnits(available, 6),
+      formattedWithdrawing: formatUnits(withdrawing, 6),
+      formattedWithdrawable: formatUnits(withdrawable, 6)
+    };
+  }
+  /**
+   * Deposit USDC into the Gateway Wallet.
+   *
+   * This method first approves the Gateway Wallet contract to spend USDC,
+   * then deposits the specified amount.
+   *
+   * @param amount - Amount of USDC to deposit (as a decimal string, e.g., "10.5")
+   * @param options - Optional deposit options
+   * @returns Deposit result with transaction hashes
+   */
+  async deposit(amount, options) {
+    const depositAmount = parseUnits(amount, 6);
+    const approveAmount = parseUnits(options?.approveAmount ?? amount, 6);
+    const { balance } = await this.getUsdcBalance();
+    if (balance < depositAmount) {
+      throw new Error(
+        `Insufficient USDC balance. Have: ${formatUnits(balance, 6)}, Need: ${amount}`
+      );
+    }
+    let approvalTxHash;
+    if (!options?.skipApprovalCheck) {
+      const allowance = await this.publicClient.readContract({
+        address: this.chainConfig.usdc,
+        abi: erc20Abi,
+        functionName: "allowance",
+        args: [this.account.address, this.chainConfig.gatewayWallet]
+      });
+      if (allowance < depositAmount) {
+        approvalTxHash = await this.walletClient.writeContract({
+          address: this.chainConfig.usdc,
+          abi: erc20Abi,
+          functionName: "approve",
+          args: [this.chainConfig.gatewayWallet, approveAmount]
+        });
+        try {
+          await this.publicClient.waitForTransactionReceipt({ hash: approvalTxHash });
+        } catch (err) {
+          throw new Error(`Approval transaction failed: ${approvalTxHash}`, {
+            cause: err
+          });
+        }
+      }
+    }
+    const depositTxHash = await this.walletClient.writeContract({
+      address: this.chainConfig.gatewayWallet,
+      abi: GATEWAY_WALLET_ABI,
+      functionName: "deposit",
+      args: [this.chainConfig.usdc, depositAmount],
+      gas: 120000n
+    });
+    try {
+      await this.publicClient.waitForTransactionReceipt({ hash: depositTxHash });
+    } catch (err) {
+      throw new Error(`Deposit transaction failed: ${depositTxHash}`, {
+        cause: err
+      });
+    }
+    return {
+      approvalTxHash,
+      depositTxHash,
+      amount: depositAmount,
+      formattedAmount: amount,
+      depositor: this.account.address
+    };
+  }
+  /**
+   * Deposit USDC into the Gateway Wallet on behalf of another address.
+   *
+   * The resulting balance belongs to the specified depositor address,
+   * not the caller.
+   *
+   * @param amount - Amount of USDC to deposit (as a decimal string)
+   * @param depositor - Address that will own the resulting balance
+   * @param options - Optional deposit options
+   * @returns Deposit result with transaction hashes
+   */
+  async depositFor(amount, depositor, options) {
+    const depositAmount = parseUnits(amount, 6);
+    const approveAmount = parseUnits(options?.approveAmount ?? amount, 6);
+    const { balance } = await this.getUsdcBalance();
+    if (balance < depositAmount) {
+      throw new Error(
+        `Insufficient USDC balance. Have: ${formatUnits(balance, 6)}, Need: ${amount}`
+      );
+    }
+    let approvalTxHash;
+    if (!options?.skipApprovalCheck) {
+      const allowance = await this.publicClient.readContract({
+        address: this.chainConfig.usdc,
+        abi: erc20Abi,
+        functionName: "allowance",
+        args: [this.account.address, this.chainConfig.gatewayWallet]
+      });
+      if (allowance < depositAmount) {
+        approvalTxHash = await this.walletClient.writeContract({
+          address: this.chainConfig.usdc,
+          abi: erc20Abi,
+          functionName: "approve",
+          args: [this.chainConfig.gatewayWallet, approveAmount]
+        });
+        try {
+          await this.publicClient.waitForTransactionReceipt({ hash: approvalTxHash });
+        } catch (err) {
+          throw new Error(`Approval transaction failed: ${approvalTxHash}`, {
+            cause: err
+          });
+        }
+      }
+    }
+    const depositTxHash = await this.walletClient.writeContract({
+      address: this.chainConfig.gatewayWallet,
+      abi: GATEWAY_WALLET_ABI,
+      functionName: "depositFor",
+      args: [this.chainConfig.usdc, depositor, depositAmount],
+      gas: 120000n
+    });
+    try {
+      await this.publicClient.waitForTransactionReceipt({ hash: depositTxHash });
+    } catch (err) {
+      throw new Error(`Deposit transaction failed: ${depositTxHash}`, {
+        cause: err
+      });
+    }
+    return {
+      approvalTxHash,
+      depositTxHash,
+      amount: depositAmount,
+      formattedAmount: amount,
+      depositor
+    };
+  }
+  // ============================================================================
+  // PAYMENT (Pay for x402 resources)
+  // ============================================================================
+  /**
+   * Check if a URL supports Gateway batching before paying.
+   *
+   * @param url - The URL to check
+   * @returns Whether batching is supported and payment requirements
+   */
+  async supports(url) {
+    try {
+      const response = await fetch(url);
+      if (response.status !== 402) {
+        return { supported: false, error: "Resource does not require payment (not 402)" };
+      }
+      const paymentRequiredHeader = response.headers.get("PAYMENT-REQUIRED");
+      if (!paymentRequiredHeader) {
+        return {
+          supported: false,
+          error: "Missing PAYMENT-REQUIRED header in 402 response"
+        };
+      }
+      const data = JSON.parse(
+        Buffer.from(paymentRequiredHeader, "base64").toString("utf-8")
+      );
+      const accepts = data.accepts;
+      if (!accepts || accepts.length === 0) {
+        return { supported: false, error: "No payment options in 402 response" };
+      }
+      const expectedNetwork = `eip155:${this.chainConfig.chain.id}`;
+      const batchingOption = accepts.find((opt) => {
+        const extra = opt.extra;
+        return opt.network === expectedNetwork && extra?.name === "GatewayWalletBatched" && extra?.version === "1" && typeof extra?.verifyingContract === "string";
+      });
+      if (!batchingOption) {
+        return {
+          supported: false,
+          error: `No Gateway batching option available for network ${expectedNetwork} (${this.chainConfig.chain.name})`
+        };
+      }
+      return { supported: true, requirements: batchingOption };
+    } catch (error) {
+      return { supported: false, error: error.message };
+    }
+  }
+  /**
+   * Pay for an x402-protected resource.
+   *
+   * This method handles the full 402 payment flow automatically:
+   * 1. Makes initial request
+   * 2. If 402, finds Gateway batching option
+   * 3. Signs payment authorization
+   * 4. Retries with Payment-Signature header
+   *
+   * @param url - The URL to pay for
+   * @param options - Optional request options
+   * @returns The response data and payment info
+   *
+   * @example
+   * ```typescript
+   * const { data, amount } = await gateway.pay('https://api.example.com/resource');
+   * console.log('Paid', amount, 'USDC for:', data);
+   * ```
+   */
+  async pay(url, options) {
+    const method = options?.method ?? "GET";
+    const headers = {
+      "Content-Type": "application/json",
+      ...options?.headers
+    };
+    const serializedBody = options?.body !== void 0 ? typeof options.body === "string" ? options.body : JSON.stringify(options.body) : void 0;
+    const initialResponse = await fetch(url, {
+      method,
+      headers,
+      body: serializedBody
+    });
+    if (initialResponse.status !== 402) {
+      if (initialResponse.ok) {
+        const data2 = await initialResponse.json();
+        return {
+          data: data2,
+          amount: 0n,
+          formattedAmount: "0",
+          transaction: "",
+          status: initialResponse.status
+        };
+      }
+      throw new Error(`Request failed with status ${initialResponse.status}`);
+    }
+    const paymentRequiredHeader = initialResponse.headers.get("PAYMENT-REQUIRED");
+    if (!paymentRequiredHeader) {
+      throw new Error("Missing PAYMENT-REQUIRED header in 402 response");
+    }
+    const paymentRequired = JSON.parse(
+      Buffer.from(paymentRequiredHeader, "base64").toString("utf-8")
+    );
+    const accepts = paymentRequired.accepts;
+    if (!accepts || accepts.length === 0) {
+      throw new Error("No payment options in 402 response");
+    }
+    const expectedNetwork = `eip155:${this.chainConfig.chain.id}`;
+    const batchingOption = accepts.find((opt) => {
+      const extra = opt.extra;
+      return opt.network === expectedNetwork && extra?.name === "GatewayWalletBatched" && extra?.version === "1" && typeof extra?.verifyingContract === "string";
+    });
+    if (!batchingOption) {
+      throw new Error(
+        `No Gateway batching option available for network ${expectedNetwork} (${this.chainConfig.chain.name}). The seller may not support this chain. Use supports() to check first.`
+      );
+    }
+    const paymentPayload = await this.createPaymentPayload(
+      paymentRequired.x402Version ?? 2,
+      batchingOption
+    );
+    const paymentHeader = Buffer.from(
+      JSON.stringify({
+        ...paymentPayload,
+        resource: paymentRequired.resource,
+        accepted: batchingOption
+      })
+    ).toString("base64");
+    const paidResponse = await fetch(url, {
+      method,
+      headers: {
+        ...headers,
+        "Payment-Signature": paymentHeader
+      },
+      body: serializedBody
+    });
+    if (!paidResponse.ok) {
+      const error = await paidResponse.json().catch(() => ({}));
+      throw new Error(
+        `Payment failed: ${error.error || paidResponse.statusText}`
+      );
+    }
+    const data = await paidResponse.json();
+    const amount = BigInt(batchingOption.amount);
+    let transaction = "";
+    const paymentResponseHeader = paidResponse.headers.get("PAYMENT-RESPONSE");
+    if (paymentResponseHeader) {
+      const settleResponse = JSON.parse(
+        Buffer.from(paymentResponseHeader, "base64").toString("utf-8")
+      );
+      transaction = settleResponse.transaction ?? "";
+    }
+    return {
+      data,
+      amount,
+      formattedAmount: formatUnits(amount, 6),
+      transaction,
+      status: paidResponse.status
+    };
+  }
+  /**
+   * Create a payment payload for x402 (low-level).
+   */
+  async createPaymentPayload(x402Version, requirements) {
+    const extra = requirements.extra;
+    const verifyingContract = extra.verifyingContract;
+    const network = requirements.network;
+    const chainId = parseInt(network.split(":")[1]);
+    const nonce = `0x${randomBytes(32).toString("hex")}`;
+    const now = Math.floor(Date.now() / 1e3);
+    const authorization = {
+      from: this.account.address,
+      to: requirements.payTo,
+      value: requirements.amount,
+      validAfter: (now - 600).toString(),
+      validBefore: (now + requirements.maxTimeoutSeconds).toString(),
+      nonce
+    };
+    const signature = await this.account.signTypedData({
+      domain: {
+        name: "GatewayWalletBatched",
+        version: "1",
+        chainId,
+        verifyingContract
+      },
+      types: {
+        TransferWithAuthorization: [
+          { name: "from", type: "address" },
+          { name: "to", type: "address" },
+          { name: "value", type: "uint256" },
+          { name: "validAfter", type: "uint256" },
+          { name: "validBefore", type: "uint256" },
+          { name: "nonce", type: "bytes32" }
+        ]
+      },
+      primaryType: "TransferWithAuthorization",
+      message: {
+        from: authorization.from,
+        to: authorization.to,
+        value: BigInt(authorization.value),
+        validAfter: BigInt(authorization.validAfter),
+        validBefore: BigInt(authorization.validBefore),
+        nonce: authorization.nonce
+      }
+    });
+    return {
+      x402Version,
+      payload: { authorization, signature }
+    };
+  }
+  // ============================================================================
+  // WITHDRAW (Instant way to get USDC out)
+  // ============================================================================
+  /**
+   * Withdraw USDC from Gateway to your wallet.
+   *
+   * By default, withdraws to the same chain (instant, no 7-day delay).
+   * Optionally, withdraw to a different chain (requires gas on destination).
+   *
+   * @param amount - Amount of USDC to withdraw (as a decimal string)
+   * @param options - Optional withdrawal options
+   * @returns Withdrawal result with transaction hash
+   *
+   * @example
+   * ```typescript
+   * // Withdraw to same chain (instant!)
+   * await gateway.withdraw('50');
+   *
+   * // Withdraw to Base Sepolia (requires ETH on Base for gas)
+   * await gateway.withdraw('25', { chain: 'baseSepolia' });
+   * ```
+   */
+  async withdraw(amount, options) {
+    const destinationChainName = options?.chain ?? this.getChainName();
+    const destConfig = CHAIN_CONFIGS[destinationChainName];
+    if (!destConfig) {
+      throw new Error(`Unsupported destination chain: ${destinationChainName}`);
+    }
+    const withdrawAmount = parseUnits(amount, 6);
+    const recipient = options?.recipient ?? this.account.address;
+    const maxFee = parseUnits(options?.maxFee ?? "2.01", 6);
+    const balances = await this.getBalances();
+    if (balances.gateway.available < withdrawAmount) {
+      throw new Error(
+        `Insufficient available balance. Have: ${balances.gateway.formattedAvailable}, Need: ${amount}`
+      );
+    }
+    const burnIntent = this.createBurnIntent(
+      this.chainConfig,
+      destConfig,
+      withdrawAmount,
+      recipient,
+      maxFee
+    );
+    const signature = await this.account.signTypedData({
+      domain: { name: "GatewayWallet", version: "1" },
+      types: {
+        EIP712Domain: [
+          { name: "name", type: "string" },
+          { name: "version", type: "string" }
+        ],
+        TransferSpec: [
+          { name: "version", type: "uint32" },
+          { name: "sourceDomain", type: "uint32" },
+          { name: "destinationDomain", type: "uint32" },
+          { name: "sourceContract", type: "bytes32" },
+          { name: "destinationContract", type: "bytes32" },
+          { name: "sourceToken", type: "bytes32" },
+          { name: "destinationToken", type: "bytes32" },
+          { name: "sourceDepositor", type: "bytes32" },
+          { name: "destinationRecipient", type: "bytes32" },
+          { name: "sourceSigner", type: "bytes32" },
+          { name: "destinationCaller", type: "bytes32" },
+          { name: "value", type: "uint256" },
+          { name: "salt", type: "bytes32" },
+          { name: "hookData", type: "bytes" }
+        ],
+        BurnIntent: [
+          { name: "maxBlockHeight", type: "uint256" },
+          { name: "maxFee", type: "uint256" },
+          { name: "spec", type: "TransferSpec" }
+        ]
+      },
+      primaryType: "BurnIntent",
+      message: burnIntent
+    });
+    const apiUrl = this.isTestnet() ? GATEWAY_API_TESTNET : GATEWAY_API_MAINNET;
+    const response = await fetch(`${apiUrl}/transfer`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(
+        [{ burnIntent, signature }],
+        (_, v) => typeof v === "bigint" ? v.toString() : v
+      )
+    });
+    const result = await response.json();
+    if (result.success === false || result.error || !result.attestation || !result.signature) {
+      throw new Error(
+        `Gateway API error: ${result.message || result.error || JSON.stringify(result)}`
+      );
+    }
+    const destTransport = destConfig.rpcUrl ? http(destConfig.rpcUrl) : http();
+    const destWalletClient = createWalletClient({
+      account: this.account,
+      chain: destConfig.chain,
+      transport: destTransport
+    });
+    const destPublicClient = createPublicClient({
+      chain: destConfig.chain,
+      transport: destTransport
+    });
+    const mintTxHash = await destWalletClient.writeContract({
+      address: destConfig.gatewayMinter,
+      abi: GATEWAY_MINTER_ABI,
+      functionName: "gatewayMint",
+      args: [result.attestation, result.signature]
+    });
+    try {
+      await destPublicClient.waitForTransactionReceipt({ hash: mintTxHash });
+    } catch (err) {
+      throw new Error(`Mint transaction failed: ${mintTxHash}`, { cause: err });
+    }
+    return {
+      mintTxHash,
+      amount: withdrawAmount,
+      formattedAmount: amount,
+      sourceChain: this.chainConfig.chain.name,
+      destinationChain: destConfig.chain.name,
+      recipient
+    };
+  }
+  /**
+   * Transfer USDC to any supported chain (alias for withdraw with destination chain).
+   * @deprecated Use `withdraw({ chain })` instead
+   */
+  async transfer(amount, destinationChain, recipient) {
+    return this.withdraw(amount, { chain: destinationChain, recipient });
+  }
+  /**
+   * Create a burn intent for a transfer.
+   */
+  createBurnIntent(from, to, value, recipient, maxFee) {
+    const addressToBytes32 = (addr) => pad(addr.toLowerCase(), { size: 32 });
+    return {
+      maxBlockHeight: maxUint256,
+      maxFee,
+      spec: {
+        version: 1,
+        sourceDomain: from.domain,
+        destinationDomain: to.domain,
+        sourceContract: addressToBytes32(from.gatewayWallet),
+        destinationContract: addressToBytes32(to.gatewayMinter),
+        sourceToken: addressToBytes32(from.usdc),
+        destinationToken: addressToBytes32(to.usdc),
+        sourceDepositor: addressToBytes32(this.account.address),
+        destinationRecipient: addressToBytes32(recipient),
+        sourceSigner: addressToBytes32(this.account.address),
+        destinationCaller: addressToBytes32(zeroAddress),
+        value,
+        salt: `0x${randomBytes(32).toString("hex")}`,
+        hookData: "0x"
+      }
+    };
+  }
+  /**
+   * Check if this client is connected to a testnet.
+   */
+  isTestnet() {
+    const testnetChains = [
+      "arbitrumSepolia",
+      "arcTestnet",
+      "avalancheFuji",
+      "baseSepolia",
+      "sepolia",
+      "hyperEvmTestnet",
+      "seiAtlantic",
+      "sonicTestnet",
+      "worldChainSepolia"
+    ];
+    return testnetChains.some(
+      (name) => CHAIN_CONFIGS[name].domain === this.chainConfig.domain
+    );
+  }
+  // ============================================================================
+  // TRUSTLESS WITHDRAWAL (Emergency use only)
+  // ============================================================================
+  /**
+   * Get the trustless withdrawal delay in blocks (~7 days).
+   *
+   * NOTE: This is for the emergency trustless withdrawal flow only.
+   * For normal withdrawals, use `transfer()` to the same chain.
+   *
+   * @returns Number of blocks to wait after initiating trustless withdrawal
+   */
+  async getTrustlessWithdrawalDelay() {
+    return this.publicClient.readContract({
+      address: this.chainConfig.gatewayWallet,
+      abi: GATEWAY_WALLET_ABI,
+      functionName: "withdrawalDelay"
+    });
+  }
+  /**
+   * Get the block at which a pending trustless withdrawal becomes available.
+   *
+   * @param address - Optional address to check (defaults to account address)
+   * @returns Block number, or 0n if no pending withdrawal
+   */
+  async getTrustlessWithdrawalBlock(address) {
+    const target = address ?? this.account.address;
+    return this.publicClient.readContract({
+      address: this.chainConfig.gatewayWallet,
+      abi: GATEWAY_WALLET_ABI,
+      functionName: "withdrawalBlock",
+      args: [this.chainConfig.usdc, target]
+    });
+  }
+  /**
+   * Initiate a trustless withdrawal from the Gateway Wallet.
+   *
+   * ⚠️ **WARNING: This is for emergency use only!**
+   *
+   * Use this only when Circle's Gateway API is unavailable. For normal
+   * withdrawals, use `transfer()` to the same chain - it's instant.
+   *
+   * After calling this, you must wait ~7 days (`withdrawalDelay` blocks)
+   * before calling `completeTrustlessWithdrawal()`.
+   *
+   * @param amount - Amount of USDC to withdraw (as a decimal string)
+   * @returns Withdrawal initiation result
+   */
+  async initiateTrustlessWithdrawal(amount) {
+    const withdrawAmount = parseUnits(amount, 6);
+    const balance = await this.getBalance();
+    if (balance.available < withdrawAmount) {
+      throw new Error(
+        `Insufficient available balance. Have: ${balance.formattedAvailable}, Need: ${amount}`
+      );
+    }
+    const txHash = await this.walletClient.writeContract({
+      address: this.chainConfig.gatewayWallet,
+      abi: GATEWAY_WALLET_ABI,
+      functionName: "initiateWithdrawal",
+      args: [this.chainConfig.usdc, withdrawAmount],
+      gas: 100000n
+    });
+    try {
+      await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+    } catch (err) {
+      throw new Error(`Trustless withdrawal initiation failed: ${txHash}`, {
+        cause: err
+      });
+    }
+    const withdrawalBlock = await this.getTrustlessWithdrawalBlock();
+    return {
+      txHash,
+      amount: withdrawAmount,
+      formattedAmount: amount,
+      withdrawalBlock
+    };
+  }
+  /**
+   * Complete a trustless withdrawal after the ~7-day delay period.
+   *
+   * ⚠️ **WARNING: This is for emergency use only!**
+   *
+   * Use this only when Circle's Gateway API is unavailable. For normal
+   * withdrawals, use `transfer()` to the same chain - it's instant.
+   *
+   * @returns Withdrawal result
+   */
+  async completeTrustlessWithdrawal() {
+    const balance = await this.getBalance();
+    if (balance.withdrawable === 0n) {
+      const withdrawalBlock = await this.getTrustlessWithdrawalBlock();
+      const currentBlock = await this.publicClient.getBlockNumber();
+      if (withdrawalBlock > 0n && currentBlock < withdrawalBlock) {
+        throw new Error(
+          `Trustless withdrawal not yet available. Current block: ${currentBlock}, Available at: ${withdrawalBlock}`
+        );
+      }
+      throw new Error(
+        "No withdrawable balance. Call initiateTrustlessWithdrawal() first."
+      );
+    }
+    const withdrawAmount = balance.withdrawable;
+    const txHash = await this.walletClient.writeContract({
+      address: this.chainConfig.gatewayWallet,
+      abi: GATEWAY_WALLET_ABI,
+      functionName: "withdraw",
+      args: [this.chainConfig.usdc],
+      gas: 100000n
+    });
+    try {
+      await this.publicClient.waitForTransactionReceipt({ hash: txHash });
+    } catch (err) {
+      throw new Error(`Trustless withdrawal completion failed: ${txHash}`, {
+        cause: err
+      });
+    }
+    return {
+      txHash,
+      amount: withdrawAmount,
+      formattedAmount: formatUnits(withdrawAmount, 6)
+    };
+  }
+};
+export {
+  BatchEvmScheme,
+  CHAIN_CONFIGS,
+  CompositeEvmScheme,
+  GATEWAY_DOMAINS,
+  GatewayClient,
+  registerBatchScheme
+};
+//# sourceMappingURL=index.mjs.map