@dexterai/x402 1.7.2 → 1.8.0

package/dist/react/index.js

@@ -1,6 +1,23 @@
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __esm = (fn, res) => function __init() {
-  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+// src/react/useX402Payment.ts
+import { useState, useCallback, useEffect, useMemo } from "react";
+
+// src/types.ts
+var SOLANA_MAINNET_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var BASE_MAINNET_NETWORK = "eip155:8453";
+var USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
+var X402Error = class _X402Error extends Error {
+  /** Error code for programmatic handling */
+  code;
+  /** Additional error details */
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "X402Error";
+    this.code = code;
+    this.details = details;
+    Object.setPrototypeOf(this, _X402Error.prototype);
+  }
 };
 
 // src/adapters/solana.ts
@@ -19,422 +36,406 @@ import {
   TOKEN_PROGRAM_ID,
   TOKEN_2022_PROGRAM_ID
 } from "@solana/spl-token";
+var SOLANA_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var SOLANA_DEVNET = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+var SOLANA_TESTNET = "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
+var DEFAULT_RPC_URLS = {
+  [SOLANA_MAINNET]: "https://api.dexter.cash/api/solana/rpc",
+  [SOLANA_DEVNET]: "https://api.devnet.solana.com",
+  [SOLANA_TESTNET]: "https://api.testnet.solana.com"
+};
+var DEFAULT_COMPUTE_UNIT_LIMIT = 12e3;
+var DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS = 1;
 function isSolanaWallet(wallet) {
   if (!wallet || typeof wallet !== "object") return false;
   const w = wallet;
   return "publicKey" in w && "signTransaction" in w && typeof w.signTransaction === "function";
 }
-function createSolanaAdapter(config) {
-  return new SolanaAdapter(config);
-}
-var SOLANA_MAINNET, SOLANA_DEVNET, SOLANA_TESTNET, DEFAULT_RPC_URLS, DEFAULT_COMPUTE_UNIT_LIMIT, DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS, SolanaAdapter;
-var init_solana = __esm({
-  "src/adapters/solana.ts"() {
-    "use strict";
-    SOLANA_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
-    SOLANA_DEVNET = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
-    SOLANA_TESTNET = "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
-    DEFAULT_RPC_URLS = {
-      [SOLANA_MAINNET]: "https://api.dexter.cash/api/solana/rpc",
-      [SOLANA_DEVNET]: "https://api.devnet.solana.com",
-      [SOLANA_TESTNET]: "https://api.testnet.solana.com"
+var SolanaAdapter = class {
+  name = "Solana";
+  networks = [SOLANA_MAINNET, SOLANA_DEVNET, SOLANA_TESTNET];
+  config;
+  log;
+  constructor(config = {}) {
+    this.config = config;
+    this.log = config.verbose ? console.log.bind(console, "[x402:solana]") : () => {
     };
-    DEFAULT_COMPUTE_UNIT_LIMIT = 12e3;
-    DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS = 1;
-    SolanaAdapter = class {
-      name = "Solana";
-      networks = [SOLANA_MAINNET, SOLANA_DEVNET, SOLANA_TESTNET];
-      config;
-      log;
-      constructor(config = {}) {
-        this.config = config;
-        this.log = config.verbose ? console.log.bind(console, "[x402:solana]") : () => {
-        };
-      }
-      canHandle(network) {
-        if (this.networks.includes(network)) return true;
-        if (network === "solana") return true;
-        if (network === "solana-devnet") return true;
-        if (network === "solana-testnet") return true;
-        if (network.startsWith("solana:")) return true;
-        return false;
-      }
-      getDefaultRpcUrl(network) {
-        if (this.config.rpcUrls?.[network]) {
-          return this.config.rpcUrls[network];
-        }
-        if (DEFAULT_RPC_URLS[network]) {
-          return DEFAULT_RPC_URLS[network];
-        }
-        if (network === "solana") return DEFAULT_RPC_URLS[SOLANA_MAINNET];
-        if (network === "solana-devnet") return DEFAULT_RPC_URLS[SOLANA_DEVNET];
-        if (network === "solana-testnet") return DEFAULT_RPC_URLS[SOLANA_TESTNET];
-        return DEFAULT_RPC_URLS[SOLANA_MAINNET];
-      }
-      getAddress(wallet) {
-        if (!isSolanaWallet(wallet)) return null;
-        return wallet.publicKey?.toBase58() ?? null;
-      }
-      isConnected(wallet) {
-        if (!isSolanaWallet(wallet)) return false;
-        return wallet.publicKey !== null;
-      }
-      async getBalance(accept, wallet, rpcUrl) {
-        if (!isSolanaWallet(wallet) || !wallet.publicKey) {
-          return 0;
-        }
-        const url = rpcUrl || this.getDefaultRpcUrl(accept.network);
-        const connection = new Connection(url, "confirmed");
-        const userPubkey = new PublicKey(wallet.publicKey.toBase58());
-        const mintPubkey = new PublicKey(accept.asset);
-        try {
-          const mintInfo = await connection.getAccountInfo(mintPubkey, "confirmed");
-          const programId = mintInfo?.owner.toBase58() === TOKEN_2022_PROGRAM_ID.toBase58() ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
-          const ata = await getAssociatedTokenAddress(
-            mintPubkey,
-            userPubkey,
-            false,
-            programId
-          );
-          const account = await getAccount(connection, ata, void 0, programId);
-          const decimals = accept.extra?.decimals ?? 6;
-          return Number(account.amount) / Math.pow(10, decimals);
-        } catch {
-          return 0;
-        }
-      }
-      async buildTransaction(accept, wallet, rpcUrl) {
-        if (!isSolanaWallet(wallet)) {
-          throw new Error("Invalid Solana wallet");
-        }
-        if (!wallet.publicKey) {
-          throw new Error("Wallet not connected");
-        }
-        const url = rpcUrl || this.getDefaultRpcUrl(accept.network);
-        const connection = new Connection(url, "confirmed");
-        const userPubkey = new PublicKey(wallet.publicKey.toBase58());
-        const { payTo, asset, extra } = accept;
-        const amount = accept.amount || accept.maxAmountRequired;
-        if (!amount) {
-          throw new Error("Missing amount in payment requirements");
-        }
-        if (!extra?.feePayer) {
-          throw new Error("Missing feePayer in payment requirements");
-        }
-        const feePayerPubkey = new PublicKey(extra.feePayer);
-        const mintPubkey = new PublicKey(asset);
-        const destinationPubkey = new PublicKey(payTo);
-        this.log("Building transaction:", {
-          from: userPubkey.toBase58(),
-          to: payTo,
-          amount,
-          asset,
-          feePayer: extra.feePayer
-        });
-        const instructions = [];
-        instructions.push(
-          ComputeBudgetProgram.setComputeUnitLimit({
-            units: DEFAULT_COMPUTE_UNIT_LIMIT
-          })
-        );
-        instructions.push(
-          ComputeBudgetProgram.setComputeUnitPrice({
-            microLamports: DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS
-          })
-        );
-        const mintInfo = await connection.getAccountInfo(mintPubkey, "confirmed");
-        if (!mintInfo) {
-          throw new Error(`Token mint ${asset} not found`);
-        }
-        const programId = mintInfo.owner.toBase58() === TOKEN_2022_PROGRAM_ID.toBase58() ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
-        const mint = await getMint(connection, mintPubkey, void 0, programId);
-        if (typeof extra?.decimals === "number" && mint.decimals !== extra.decimals) {
-          this.log(
-            `Decimals mismatch: requirements say ${extra.decimals}, mint says ${mint.decimals}`
-          );
-        }
-        const sourceAta = await getAssociatedTokenAddress(
-          mintPubkey,
-          userPubkey,
-          false,
-          programId
-        );
-        const destinationAta = await getAssociatedTokenAddress(
-          mintPubkey,
-          destinationPubkey,
-          false,
-          programId
-        );
-        const sourceAtaInfo = await connection.getAccountInfo(sourceAta, "confirmed");
-        if (!sourceAtaInfo) {
-          throw new Error(
-            `No token account found for ${asset}. Please ensure you have USDC in your wallet.`
-          );
-        }
-        const destAtaInfo = await connection.getAccountInfo(destinationAta, "confirmed");
-        if (!destAtaInfo) {
-          throw new Error(
-            `Seller token account not found. The seller (${payTo}) must have a USDC account.`
-          );
-        }
-        const amountBigInt = BigInt(amount);
-        instructions.push(
-          createTransferCheckedInstruction(
-            sourceAta,
-            mintPubkey,
-            destinationAta,
-            userPubkey,
-            amountBigInt,
-            mint.decimals,
-            [],
-            programId
-          )
-        );
-        const { blockhash } = await connection.getLatestBlockhash("confirmed");
-        const message = new TransactionMessage({
-          payerKey: feePayerPubkey,
-          recentBlockhash: blockhash,
-          instructions
-        }).compileToV0Message();
-        const transaction = new VersionedTransaction(message);
-        const signedTx = await wallet.signTransaction(transaction);
-        this.log("Transaction signed successfully");
-        return {
-          serialized: Buffer.from(signedTx.serialize()).toString("base64")
-        };
-      }
+  }
+  canHandle(network) {
+    if (this.networks.includes(network)) return true;
+    if (network === "solana") return true;
+    if (network === "solana-devnet") return true;
+    if (network === "solana-testnet") return true;
+    if (network.startsWith("solana:")) return true;
+    return false;
+  }
+  getDefaultRpcUrl(network) {
+    if (this.config.rpcUrls?.[network]) {
+      return this.config.rpcUrls[network];
+    }
+    if (DEFAULT_RPC_URLS[network]) {
+      return DEFAULT_RPC_URLS[network];
+    }
+    if (network === "solana") return DEFAULT_RPC_URLS[SOLANA_MAINNET];
+    if (network === "solana-devnet") return DEFAULT_RPC_URLS[SOLANA_DEVNET];
+    if (network === "solana-testnet") return DEFAULT_RPC_URLS[SOLANA_TESTNET];
+    return DEFAULT_RPC_URLS[SOLANA_MAINNET];
+  }
+  getAddress(wallet) {
+    if (!isSolanaWallet(wallet)) return null;
+    return wallet.publicKey?.toBase58() ?? null;
+  }
+  isConnected(wallet) {
+    if (!isSolanaWallet(wallet)) return false;
+    return wallet.publicKey !== null;
+  }
+  async getBalance(accept, wallet, rpcUrl) {
+    if (!isSolanaWallet(wallet) || !wallet.publicKey) {
+      return 0;
+    }
+    const url = rpcUrl || this.getDefaultRpcUrl(accept.network);
+    const connection = new Connection(url, "confirmed");
+    const userPubkey = new PublicKey(wallet.publicKey.toBase58());
+    const mintPubkey = new PublicKey(accept.asset);
+    try {
+      const mintInfo = await connection.getAccountInfo(mintPubkey, "confirmed");
+      const programId = mintInfo?.owner.toBase58() === TOKEN_2022_PROGRAM_ID.toBase58() ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
+      const ata = await getAssociatedTokenAddress(
+        mintPubkey,
+        userPubkey,
+        false,
+        programId
+      );
+      const account = await getAccount(connection, ata, void 0, programId);
+      const decimals = accept.extra?.decimals ?? 6;
+      return Number(account.amount) / Math.pow(10, decimals);
+    } catch {
+      return 0;
+    }
+  }
+  async buildTransaction(accept, wallet, rpcUrl) {
+    if (!isSolanaWallet(wallet)) {
+      throw new Error("Invalid Solana wallet");
+    }
+    if (!wallet.publicKey) {
+      throw new Error("Wallet not connected");
+    }
+    const url = rpcUrl || this.getDefaultRpcUrl(accept.network);
+    const connection = new Connection(url, "confirmed");
+    const userPubkey = new PublicKey(wallet.publicKey.toBase58());
+    const { payTo, asset, extra } = accept;
+    const amount = accept.amount || accept.maxAmountRequired;
+    if (!amount) {
+      throw new Error("Missing amount in payment requirements");
+    }
+    if (!extra?.feePayer) {
+      throw new Error("Missing feePayer in payment requirements");
+    }
+    const feePayerPubkey = new PublicKey(extra.feePayer);
+    const mintPubkey = new PublicKey(asset);
+    const destinationPubkey = new PublicKey(payTo);
+    this.log("Building transaction:", {
+      from: userPubkey.toBase58(),
+      to: payTo,
+      amount,
+      asset,
+      feePayer: extra.feePayer
+    });
+    const instructions = [];
+    instructions.push(
+      ComputeBudgetProgram.setComputeUnitLimit({
+        units: DEFAULT_COMPUTE_UNIT_LIMIT
+      })
+    );
+    instructions.push(
+      ComputeBudgetProgram.setComputeUnitPrice({
+        microLamports: DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS
+      })
+    );
+    const mintInfo = await connection.getAccountInfo(mintPubkey, "confirmed");
+    if (!mintInfo) {
+      throw new Error(`Token mint ${asset} not found`);
+    }
+    const programId = mintInfo.owner.toBase58() === TOKEN_2022_PROGRAM_ID.toBase58() ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
+    const mint = await getMint(connection, mintPubkey, void 0, programId);
+    if (typeof extra?.decimals === "number" && mint.decimals !== extra.decimals) {
+      this.log(
+        `Decimals mismatch: requirements say ${extra.decimals}, mint says ${mint.decimals}`
+      );
+    }
+    const sourceAta = await getAssociatedTokenAddress(
+      mintPubkey,
+      userPubkey,
+      false,
+      programId
+    );
+    const destinationAta = await getAssociatedTokenAddress(
+      mintPubkey,
+      destinationPubkey,
+      false,
+      programId
+    );
+    const sourceAtaInfo = await connection.getAccountInfo(sourceAta, "confirmed");
+    if (!sourceAtaInfo) {
+      throw new Error(
+        `No token account found for ${asset}. Please ensure you have USDC in your wallet.`
+      );
+    }
+    const destAtaInfo = await connection.getAccountInfo(destinationAta, "confirmed");
+    if (!destAtaInfo) {
+      throw new Error(
+        `Seller token account not found. The seller (${payTo}) must have a USDC account.`
+      );
+    }
+    const amountBigInt = BigInt(amount);
+    instructions.push(
+      createTransferCheckedInstruction(
+        sourceAta,
+        mintPubkey,
+        destinationAta,
+        userPubkey,
+        amountBigInt,
+        mint.decimals,
+        [],
+        programId
+      )
+    );
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    const message = new TransactionMessage({
+      payerKey: feePayerPubkey,
+      recentBlockhash: blockhash,
+      instructions
+    }).compileToV0Message();
+    const transaction = new VersionedTransaction(message);
+    const signedTx = await wallet.signTransaction(transaction);
+    this.log("Transaction signed successfully");
+    return {
+      serialized: Buffer.from(signedTx.serialize()).toString("base64")
     };
   }
-});
+};
+function createSolanaAdapter(config) {
+  return new SolanaAdapter(config);
+}
 
 // src/adapters/evm.ts
+var BASE_MAINNET = "eip155:8453";
+var BASE_SEPOLIA = "eip155:84532";
+var ARBITRUM_ONE = "eip155:42161";
+var POLYGON = "eip155:137";
+var OPTIMISM = "eip155:10";
+var AVALANCHE = "eip155:43114";
+var SKALE_BASE = "eip155:1187947933";
+var SKALE_BASE_SEPOLIA = "eip155:324705682";
+var ETHEREUM_MAINNET = "eip155:1";
+var CHAIN_IDS = {
+  [BASE_MAINNET]: 8453,
+  [BASE_SEPOLIA]: 84532,
+  [ARBITRUM_ONE]: 42161,
+  [POLYGON]: 137,
+  [OPTIMISM]: 10,
+  [AVALANCHE]: 43114,
+  [SKALE_BASE]: 1187947933,
+  [SKALE_BASE_SEPOLIA]: 324705682,
+  [ETHEREUM_MAINNET]: 1
+};
+var DEFAULT_RPC_URLS2 = {
+  [BASE_MAINNET]: "https://api.dexter.cash/api/base/rpc",
+  [BASE_SEPOLIA]: "https://sepolia.base.org",
+  [ARBITRUM_ONE]: "https://arb1.arbitrum.io/rpc",
+  [POLYGON]: "https://polygon-rpc.com",
+  [OPTIMISM]: "https://mainnet.optimism.io",
+  [AVALANCHE]: "https://api.avax.network/ext/bc/C/rpc",
+  [SKALE_BASE]: "https://skale-base.skalenodes.com/v1/base",
+  [SKALE_BASE_SEPOLIA]: "https://base-sepolia-testnet.skalenodes.com/v1/jubilant-horrible-ancha",
+  [ETHEREUM_MAINNET]: "https://eth.llamarpc.com"
+};
+var USDC_ADDRESSES = {
+  [BASE_MAINNET]: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  [BASE_SEPOLIA]: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  [ARBITRUM_ONE]: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  [POLYGON]: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+  [OPTIMISM]: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+  [AVALANCHE]: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+  [SKALE_BASE]: "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20",
+  [SKALE_BASE_SEPOLIA]: "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD",
+  [ETHEREUM_MAINNET]: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+};
 function isEvmWallet(wallet) {
   if (!wallet || typeof wallet !== "object") return false;
   const w = wallet;
   return "address" in w && typeof w.address === "string" && w.address.startsWith("0x");
 }
-function createEvmAdapter(config) {
-  return new EvmAdapter(config);
-}
-var BASE_MAINNET, BASE_SEPOLIA, ETHEREUM_MAINNET, ARBITRUM_ONE, CHAIN_IDS, DEFAULT_RPC_URLS2, USDC_ADDRESSES, EvmAdapter;
-var init_evm = __esm({
-  "src/adapters/evm.ts"() {
-    "use strict";
-    BASE_MAINNET = "eip155:8453";
-    BASE_SEPOLIA = "eip155:84532";
-    ETHEREUM_MAINNET = "eip155:1";
-    ARBITRUM_ONE = "eip155:42161";
-    CHAIN_IDS = {
-      [BASE_MAINNET]: 8453,
-      [BASE_SEPOLIA]: 84532,
-      [ETHEREUM_MAINNET]: 1,
-      [ARBITRUM_ONE]: 42161
+var EvmAdapter = class {
+  name = "EVM";
+  networks = [BASE_MAINNET, BASE_SEPOLIA, ETHEREUM_MAINNET, ARBITRUM_ONE];
+  config;
+  log;
+  constructor(config = {}) {
+    this.config = config;
+    this.log = config.verbose ? console.log.bind(console, "[x402:evm]") : () => {
     };
-    DEFAULT_RPC_URLS2 = {
-      [BASE_MAINNET]: "https://api.dexter.cash/api/base/rpc",
-      [BASE_SEPOLIA]: "https://sepolia.base.org",
-      [ETHEREUM_MAINNET]: "https://eth.llamarpc.com",
-      [ARBITRUM_ONE]: "https://arb1.arbitrum.io/rpc"
-    };
-    USDC_ADDRESSES = {
-      [BASE_MAINNET]: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      [ETHEREUM_MAINNET]: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
-      [ARBITRUM_ONE]: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
-    };
-    EvmAdapter = class {
-      name = "EVM";
-      networks = [BASE_MAINNET, BASE_SEPOLIA, ETHEREUM_MAINNET, ARBITRUM_ONE];
-      config;
-      log;
-      constructor(config = {}) {
-        this.config = config;
-        this.log = config.verbose ? console.log.bind(console, "[x402:evm]") : () => {
-        };
-      }
-      canHandle(network) {
-        if (this.networks.includes(network)) return true;
-        if (network === "base") return true;
-        if (network === "ethereum") return true;
-        if (network === "arbitrum") return true;
-        if (network.startsWith("eip155:")) return true;
-        return false;
-      }
-      getDefaultRpcUrl(network) {
-        if (this.config.rpcUrls?.[network]) {
-          return this.config.rpcUrls[network];
-        }
-        if (DEFAULT_RPC_URLS2[network]) {
-          return DEFAULT_RPC_URLS2[network];
-        }
-        if (network === "base") return DEFAULT_RPC_URLS2[BASE_MAINNET];
-        if (network === "ethereum") return DEFAULT_RPC_URLS2[ETHEREUM_MAINNET];
-        if (network === "arbitrum") return DEFAULT_RPC_URLS2[ARBITRUM_ONE];
-        return DEFAULT_RPC_URLS2[BASE_MAINNET];
-      }
-      getAddress(wallet) {
-        if (!isEvmWallet(wallet)) return null;
-        return wallet.address;
-      }
-      isConnected(wallet) {
-        if (!isEvmWallet(wallet)) return false;
-        return !!wallet.address;
-      }
-      getChainId(network) {
-        if (CHAIN_IDS[network]) return CHAIN_IDS[network];
-        if (network.startsWith("eip155:")) {
-          const chainIdStr = network.split(":")[1];
-          return parseInt(chainIdStr, 10);
-        }
-        if (network === "base") return 8453;
-        if (network === "ethereum") return 1;
-        if (network === "arbitrum") return 42161;
-        return 8453;
-      }
-      async getBalance(accept, wallet, rpcUrl) {
-        if (!isEvmWallet(wallet) || !wallet.address) {
-          return 0;
-        }
-        const url = rpcUrl || this.getDefaultRpcUrl(accept.network);
-        try {
-          const data = this.encodeBalanceOf(wallet.address);
-          const response = await fetch(url, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({
-              jsonrpc: "2.0",
-              id: 1,
-              method: "eth_call",
-              params: [
-                {
-                  to: accept.asset,
-                  data
-                },
-                "latest"
-              ]
-            })
-          });
-          const result = await response.json();
-          if (result.error || !result.result) {
-            return 0;
-          }
-          const balance = BigInt(result.result);
-          const decimals = accept.extra?.decimals ?? 6;
-          return Number(balance) / Math.pow(10, decimals);
-        } catch {
-          return 0;
-        }
-      }
-      encodeBalanceOf(address) {
-        const selector = "0x70a08231";
-        const paddedAddress = address.slice(2).toLowerCase().padStart(64, "0");
-        return selector + paddedAddress;
-      }
-      async buildTransaction(accept, wallet, _rpcUrl) {
-        if (!isEvmWallet(wallet)) {
-          throw new Error("Invalid EVM wallet");
-        }
-        if (!wallet.address) {
-          throw new Error("Wallet not connected");
-        }
-        const { payTo, asset, extra } = accept;
-        const amount = accept.amount || accept.maxAmountRequired;
-        if (!amount) {
-          throw new Error("Missing amount in payment requirements");
-        }
-        this.log("Building EVM transaction:", {
-          from: wallet.address,
-          to: payTo,
-          amount,
-          asset,
-          network: accept.network
-        });
-        const chainId = this.getChainId(accept.network);
-        const domain = {
-          name: extra?.name ?? "USD Coin",
-          version: extra?.version ?? "2",
-          chainId: BigInt(chainId),
-          verifyingContract: asset
-        };
-        const 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" }
+  }
+  canHandle(network) {
+    if (this.networks.includes(network)) return true;
+    if (network === "base") return true;
+    if (network === "ethereum") return true;
+    if (network === "arbitrum") return true;
+    if (network.startsWith("eip155:")) return true;
+    return false;
+  }
+  getDefaultRpcUrl(network) {
+    if (this.config.rpcUrls?.[network]) {
+      return this.config.rpcUrls[network];
+    }
+    if (DEFAULT_RPC_URLS2[network]) {
+      return DEFAULT_RPC_URLS2[network];
+    }
+    if (network === "base") return DEFAULT_RPC_URLS2[BASE_MAINNET];
+    if (network === "ethereum") return DEFAULT_RPC_URLS2[ETHEREUM_MAINNET];
+    if (network === "arbitrum") return DEFAULT_RPC_URLS2[ARBITRUM_ONE];
+    return DEFAULT_RPC_URLS2[BASE_MAINNET];
+  }
+  getAddress(wallet) {
+    if (!isEvmWallet(wallet)) return null;
+    return wallet.address;
+  }
+  isConnected(wallet) {
+    if (!isEvmWallet(wallet)) return false;
+    return !!wallet.address;
+  }
+  getChainId(network) {
+    if (CHAIN_IDS[network]) return CHAIN_IDS[network];
+    if (network.startsWith("eip155:")) {
+      const chainIdStr = network.split(":")[1];
+      return parseInt(chainIdStr, 10);
+    }
+    if (network === "base") return 8453;
+    if (network === "ethereum") return 1;
+    if (network === "arbitrum") return 42161;
+    return 8453;
+  }
+  async getBalance(accept, wallet, rpcUrl) {
+    if (!isEvmWallet(wallet) || !wallet.address) {
+      return 0;
+    }
+    const url = rpcUrl || this.getDefaultRpcUrl(accept.network);
+    try {
+      const data = this.encodeBalanceOf(wallet.address);
+      const response = await fetch(url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          id: 1,
+          method: "eth_call",
+          params: [
+            {
+              to: accept.asset,
+              data
+            },
+            "latest"
           ]
-        };
-        const nonce = "0x" + [...Array(32)].map(() => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")).join("");
-        const now = Math.floor(Date.now() / 1e3);
-        const authorization = {
-          from: wallet.address,
-          to: payTo,
-          value: amount,
-          // string
-          validAfter: String(now - 600),
-          // 10 minutes before (matching upstream)
-          validBefore: String(now + (accept.maxTimeoutSeconds || 60)),
-          nonce
-        };
-        const message = {
-          from: wallet.address,
-          to: payTo,
-          value: BigInt(amount),
-          validAfter: BigInt(now - 600),
-          validBefore: BigInt(now + (accept.maxTimeoutSeconds || 60)),
-          nonce
-        };
-        if (!wallet.signTypedData) {
-          throw new Error("Wallet does not support signTypedData (EIP-712)");
-        }
-        const signature = await wallet.signTypedData({
-          domain,
-          types,
-          primaryType: "TransferWithAuthorization",
-          message
-        });
-        this.log("EIP-712 signature obtained");
-        const payload = {
-          authorization,
-          signature
-        };
-        return {
-          serialized: JSON.stringify(payload),
-          signature
-        };
+        })
+      });
+      const result = await response.json();
+      if (result.error || !result.result) {
+        return 0;
       }
-    };
+      const balance = BigInt(result.result);
+      const decimals = accept.extra?.decimals ?? 6;
+      return Number(balance) / Math.pow(10, decimals);
+    } catch {
+      return 0;
+    }
   }
-});
-
-// src/react/useX402Payment.ts
-import { useState, useCallback, useEffect, useMemo } from "react";
-
-// src/types.ts
-var SOLANA_MAINNET_NETWORK = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
-var BASE_MAINNET_NETWORK = "eip155:8453";
-var USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
-var USDC_BASE = "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913";
-var X402Error = class _X402Error extends Error {
-  /** Error code for programmatic handling */
-  code;
-  /** Additional error details */
-  details;
-  constructor(code, message, details) {
-    super(message);
-    this.name = "X402Error";
-    this.code = code;
-    this.details = details;
-    Object.setPrototypeOf(this, _X402Error.prototype);
+  encodeBalanceOf(address) {
+    const selector = "0x70a08231";
+    const paddedAddress = address.slice(2).toLowerCase().padStart(64, "0");
+    return selector + paddedAddress;
+  }
+  async buildTransaction(accept, wallet, _rpcUrl) {
+    if (!isEvmWallet(wallet)) {
+      throw new Error("Invalid EVM wallet");
+    }
+    if (!wallet.address) {
+      throw new Error("Wallet not connected");
+    }
+    const { payTo, asset, extra } = accept;
+    const amount = accept.amount || accept.maxAmountRequired;
+    if (!amount) {
+      throw new Error("Missing amount in payment requirements");
+    }
+    this.log("Building EVM transaction:", {
+      from: wallet.address,
+      to: payTo,
+      amount,
+      asset,
+      network: accept.network
+    });
+    const chainId = this.getChainId(accept.network);
+    const domain = {
+      name: extra?.name ?? "USD Coin",
+      version: extra?.version ?? "2",
+      chainId: BigInt(chainId),
+      verifyingContract: asset
+    };
+    const 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" }
+      ]
+    };
+    const nonce = "0x" + [...Array(32)].map(() => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")).join("");
+    const now = Math.floor(Date.now() / 1e3);
+    const authorization = {
+      from: wallet.address,
+      to: payTo,
+      value: amount,
+      // string
+      validAfter: String(now - 600),
+      // 10 minutes before (matching upstream)
+      validBefore: String(now + (accept.maxTimeoutSeconds || 60)),
+      nonce
+    };
+    const message = {
+      from: wallet.address,
+      to: payTo,
+      value: BigInt(amount),
+      validAfter: BigInt(now - 600),
+      validBefore: BigInt(now + (accept.maxTimeoutSeconds || 60)),
+      nonce
+    };
+    if (!wallet.signTypedData) {
+      throw new Error("Wallet does not support signTypedData (EIP-712)");
+    }
+    const signature = await wallet.signTypedData({
+      domain,
+      types,
+      primaryType: "TransferWithAuthorization",
+      message
+    });
+    this.log("EIP-712 signature obtained");
+    const payload = {
+      authorization,
+      signature
+    };
+    return {
+      serialized: JSON.stringify(payload),
+      signature
+    };
   }
 };
-
-// src/adapters/index.ts
-init_solana();
-init_evm();
+function createEvmAdapter(config) {
+  return new EvmAdapter(config);
+}
 
 // src/client/x402-client.ts
+var receiptStore = /* @__PURE__ */ new WeakMap();
 function createX402Client(config) {
   const {
     adapters = [createSolanaAdapter({ verbose: config.verbose }), createEvmAdapter({ verbose: config.verbose })],
@@ -804,7 +805,8 @@ function createX402Client(config) {
     if (paymentResponseHeader) {
       try {
         const receipt = JSON.parse(atob(paymentResponseHeader));
-        retryResponse._x402 = receipt;
+        receiptStore.set(retryResponse, receipt);
+        retryResponse["_x402"] = receipt;
         if (receipt.extensions) {
           log("Settlement extensions:", Object.keys(receipt.extensions).join(", "));
         }