@dexterai/x402 1.0.0

package/dist/react/index.js

@@ -0,0 +1,814 @@
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+
+// src/adapters/solana.ts
+import {
+  PublicKey,
+  Connection,
+  TransactionMessage,
+  VersionedTransaction,
+  ComputeBudgetProgram
+} from "@solana/web3.js";
+import {
+  getAssociatedTokenAddress,
+  getAccount,
+  createTransferCheckedInstruction,
+  getMint,
+  TOKEN_PROGRAM_ID,
+  TOKEN_2022_PROGRAM_ID
+} from "@solana/spl-token";
+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.mainnet-beta.solana.com",
+      [SOLANA_DEVNET]: "https://api.devnet.solana.com",
+      [SOLANA_TESTNET]: "https://api.testnet.solana.com"
+    };
+    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, amount, extra } = accept;
+        if (!extra?.feePayer) {
+          throw new Error("Missing feePayer in payment requirements");
+        }
+        if (typeof extra?.decimals !== "number") {
+          throw new Error("Missing decimals 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 (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")
+        };
+      }
+    };
+  }
+});
+
+// src/adapters/evm.ts
+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
+    };
+    DEFAULT_RPC_URLS2 = {
+      [BASE_MAINNET]: "https://mainnet.base.org",
+      [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, amount, extra } = accept;
+        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/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/index.ts
+init_solana();
+init_evm();
+
+// src/client/x402-client.ts
+function createX402Client(config) {
+  const {
+    adapters = [createSolanaAdapter({ verbose: config.verbose }), createEvmAdapter({ verbose: config.verbose })],
+    wallets: walletSet,
+    wallet: legacyWallet,
+    preferredNetwork,
+    rpcUrls = {},
+    maxAmountAtomic,
+    fetch: customFetch = globalThis.fetch,
+    verbose = false
+  } = config;
+  const log = verbose ? console.log.bind(console, "[x402]") : () => {
+  };
+  const wallets = walletSet || {};
+  if (legacyWallet && !wallets.solana && isSolanaWallet(legacyWallet)) {
+    wallets.solana = legacyWallet;
+  }
+  if (legacyWallet && !wallets.evm && isEvmWallet(legacyWallet)) {
+    wallets.evm = legacyWallet;
+  }
+  function findPaymentOption(accepts) {
+    const candidates = [];
+    for (const accept of accepts) {
+      const adapter = adapters.find((a) => a.canHandle(accept.network));
+      if (!adapter) continue;
+      let wallet;
+      if (adapter.name === "Solana") {
+        wallet = wallets.solana;
+      } else if (adapter.name === "EVM") {
+        wallet = wallets.evm;
+      }
+      if (wallet && adapter.isConnected(wallet)) {
+        candidates.push({ accept, adapter, wallet });
+      }
+    }
+    if (candidates.length === 0) {
+      return null;
+    }
+    if (preferredNetwork) {
+      const preferred = candidates.find((c) => c.accept.network === preferredNetwork);
+      if (preferred) return preferred;
+    }
+    return candidates[0];
+  }
+  function getRpcUrl(network, adapter) {
+    return rpcUrls[network] || adapter.getDefaultRpcUrl(network);
+  }
+  async function x402Fetch(input, init) {
+    log("Making request:", input);
+    const response = await customFetch(input, init);
+    if (response.status !== 402) {
+      return response;
+    }
+    log("Received 402 Payment Required");
+    const paymentRequiredHeader = response.headers.get("PAYMENT-REQUIRED");
+    if (!paymentRequiredHeader) {
+      throw new X402Error(
+        "missing_payment_required_header",
+        "Server returned 402 but no PAYMENT-REQUIRED header"
+      );
+    }
+    let requirements;
+    try {
+      const decoded = atob(paymentRequiredHeader);
+      requirements = JSON.parse(decoded);
+    } catch {
+      throw new X402Error(
+        "invalid_payment_required",
+        "Failed to decode PAYMENT-REQUIRED header"
+      );
+    }
+    log("Payment requirements:", requirements);
+    const match = findPaymentOption(requirements.accepts);
+    if (!match) {
+      const availableNetworks = requirements.accepts.map((a) => a.network).join(", ");
+      throw new X402Error(
+        "no_matching_payment_option",
+        `No connected wallet for any available network: ${availableNetworks}`
+      );
+    }
+    const { accept, adapter, wallet } = match;
+    log(`Using ${adapter.name} for ${accept.network}`);
+    if (adapter.name === "Solana" && !accept.extra?.feePayer) {
+      throw new X402Error(
+        "missing_fee_payer",
+        "Solana payment option missing feePayer in extra"
+      );
+    }
+    if (typeof accept.extra?.decimals !== "number") {
+      throw new X402Error(
+        "missing_decimals",
+        "Payment option missing decimals in extra"
+      );
+    }
+    if (maxAmountAtomic && BigInt(accept.amount) > BigInt(maxAmountAtomic)) {
+      throw new X402Error(
+        "amount_exceeds_max",
+        `Payment amount ${accept.amount} exceeds maximum ${maxAmountAtomic}`
+      );
+    }
+    log("Building transaction...");
+    const rpcUrl = getRpcUrl(accept.network, adapter);
+    const signedTx = await adapter.buildTransaction(accept, wallet, rpcUrl);
+    log("Transaction signed");
+    let payload;
+    if (adapter.name === "EVM") {
+      payload = JSON.parse(signedTx.serialized);
+    } else {
+      payload = { transaction: signedTx.serialized };
+    }
+    const paymentSignature = {
+      x402Version: 2,
+      resource: requirements.resource,
+      accepted: accept,
+      payload
+    };
+    const paymentSignatureHeader = btoa(JSON.stringify(paymentSignature));
+    log("Retrying request with payment...");
+    const retryResponse = await customFetch(input, {
+      ...init,
+      headers: {
+        ...init?.headers || {},
+        "PAYMENT-SIGNATURE": paymentSignatureHeader
+      }
+    });
+    log("Retry response status:", retryResponse.status);
+    if (retryResponse.status === 402) {
+      let reason = "unknown";
+      try {
+        const body = await retryResponse.clone().json();
+        reason = String(body.error || body.message || JSON.stringify(body));
+        log("Rejection reason:", reason);
+      } catch {
+      }
+      throw new X402Error(
+        "payment_rejected",
+        `Payment was rejected by the server: ${reason}`
+      );
+    }
+    return retryResponse;
+  }
+  return {
+    fetch: x402Fetch
+  };
+}
+
+// src/utils.ts
+function getChainFamily(network) {
+  if (network.startsWith("solana:") || network === "solana") {
+    return "solana";
+  }
+  if (network.startsWith("eip155:") || ["base", "ethereum", "arbitrum"].includes(network)) {
+    return "evm";
+  }
+  return "unknown";
+}
+function getChainName(network) {
+  const mapping = {
+    [SOLANA_MAINNET_NETWORK]: "Solana",
+    "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1": "Solana Devnet",
+    "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z": "Solana Testnet",
+    "solana": "Solana",
+    [BASE_MAINNET_NETWORK]: "Base",
+    "eip155:84532": "Base Sepolia",
+    "eip155:1": "Ethereum",
+    "eip155:42161": "Arbitrum One",
+    "base": "Base",
+    "ethereum": "Ethereum",
+    "arbitrum": "Arbitrum"
+  };
+  return mapping[network] || network;
+}
+function getExplorerUrl(txSignature, network) {
+  const family = getChainFamily(network);
+  if (family === "solana") {
+    const isDevnet = network.includes("devnet") || network === "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    if (isDevnet) {
+      return `https://solscan.io/tx/${txSignature}?cluster=devnet`;
+    }
+    return `https://www.orbmarkets.io/tx/${txSignature}`;
+  }
+  if (family === "evm") {
+    let chainId = "8453";
+    if (network.startsWith("eip155:")) {
+      chainId = network.split(":")[1];
+    } else if (network === "ethereum") {
+      chainId = "1";
+    } else if (network === "arbitrum") {
+      chainId = "42161";
+    }
+    switch (chainId) {
+      case "8453":
+        return `https://basescan.org/tx/${txSignature}`;
+      case "84532":
+        return `https://sepolia.basescan.org/tx/${txSignature}`;
+      case "1":
+        return `https://etherscan.io/tx/${txSignature}`;
+      case "42161":
+        return `https://arbiscan.io/tx/${txSignature}`;
+      default:
+        return `https://basescan.org/tx/${txSignature}`;
+    }
+  }
+  return `https://solscan.io/tx/${txSignature}`;
+}
+
+// src/react/useX402Payment.ts
+function useX402Payment(config) {
+  const {
+    wallets: walletSet,
+    wallet: legacyWallet,
+    preferredNetwork,
+    rpcUrls = {},
+    verbose = false
+  } = config;
+  const [isLoading, setIsLoading] = useState(false);
+  const [status, setStatus] = useState("idle");
+  const [error, setError] = useState(null);
+  const [transactionId, setTransactionId] = useState(null);
+  const [transactionNetwork, setTransactionNetwork] = useState(null);
+  const [balances, setBalances] = useState([]);
+  const log = useCallback((...args) => {
+    if (verbose) console.log("[useX402Payment]", ...args);
+  }, [verbose]);
+  const wallets = useMemo(() => {
+    const w = { ...walletSet };
+    if (legacyWallet && !w.solana && isSolanaWallet(legacyWallet)) {
+      w.solana = legacyWallet;
+    }
+    if (legacyWallet && !w.evm && isEvmWallet(legacyWallet)) {
+      w.evm = legacyWallet;
+    }
+    return w;
+  }, [walletSet, legacyWallet]);
+  const adapters = useMemo(() => [
+    createSolanaAdapter({ verbose, rpcUrls }),
+    createEvmAdapter({ verbose, rpcUrls })
+  ], [verbose, rpcUrls]);
+  const connectedChains = useMemo(() => ({
+    solana: wallets.solana ? isSolanaWallet(wallets.solana) && adapters[0].isConnected(wallets.solana) : false,
+    evm: wallets.evm ? isEvmWallet(wallets.evm) && adapters[1].isConnected(wallets.evm) : false
+  }), [wallets, adapters]);
+  const isAnyWalletConnected = connectedChains.solana || connectedChains.evm;
+  const refreshBalances = useCallback(async () => {
+    const newBalances = [];
+    if (connectedChains.solana && wallets.solana) {
+      try {
+        const solanaAdapter = adapters.find((a) => a.name === "Solana");
+        if (solanaAdapter) {
+          const accept = {
+            scheme: "exact",
+            network: SOLANA_MAINNET_NETWORK,
+            amount: "0",
+            asset: USDC_MINT,
+            payTo: "",
+            maxTimeoutSeconds: 60,
+            extra: { feePayer: "", decimals: 6 }
+          };
+          const balance = await solanaAdapter.getBalance(accept, wallets.solana);
+          newBalances.push({
+            network: SOLANA_MAINNET_NETWORK,
+            chainName: getChainName(SOLANA_MAINNET_NETWORK),
+            balance,
+            asset: "USDC"
+          });
+        }
+      } catch (e) {
+        log("Failed to fetch Solana balance:", e);
+      }
+    }
+    if (connectedChains.evm && wallets.evm) {
+      try {
+        const evmAdapter = adapters.find((a) => a.name === "EVM");
+        if (evmAdapter) {
+          const accept = {
+            scheme: "exact",
+            network: BASE_MAINNET_NETWORK,
+            amount: "0",
+            asset: USDC_BASE,
+            payTo: "",
+            maxTimeoutSeconds: 60,
+            extra: { feePayer: "", decimals: 6 }
+          };
+          const balance = await evmAdapter.getBalance(accept, wallets.evm);
+          newBalances.push({
+            network: BASE_MAINNET_NETWORK,
+            chainName: getChainName(BASE_MAINNET_NETWORK),
+            balance,
+            asset: "USDC"
+          });
+        }
+      } catch (e) {
+        log("Failed to fetch Base balance:", e);
+      }
+    }
+    setBalances(newBalances);
+  }, [connectedChains, wallets, adapters, log]);
+  useEffect(() => {
+    refreshBalances();
+    const interval = setInterval(refreshBalances, 3e4);
+    return () => clearInterval(interval);
+  }, [refreshBalances]);
+  const reset = useCallback(() => {
+    setIsLoading(false);
+    setStatus("idle");
+    setError(null);
+    setTransactionId(null);
+    setTransactionNetwork(null);
+  }, []);
+  const client = useMemo(() => createX402Client({
+    adapters,
+    wallets,
+    preferredNetwork,
+    rpcUrls,
+    verbose
+  }), [adapters, wallets, preferredNetwork, rpcUrls, verbose]);
+  const fetchWithPayment = useCallback(async (input, init) => {
+    setIsLoading(true);
+    setStatus("pending");
+    setError(null);
+    setTransactionId(null);
+    setTransactionNetwork(null);
+    if (!isAnyWalletConnected) {
+      const connError = new X402Error("wallet_not_connected", "No wallet connected");
+      setError(connError);
+      setStatus("error");
+      setIsLoading(false);
+      throw connError;
+    }
+    try {
+      const response = await client.fetch(input, init);
+      const paymentResponse = response.headers.get("PAYMENT-RESPONSE");
+      if (paymentResponse) {
+        try {
+          const decoded = JSON.parse(atob(paymentResponse));
+          if (decoded.transaction) {
+            setTransactionId(decoded.transaction);
+          }
+          if (decoded.network) {
+            setTransactionNetwork(decoded.network);
+          }
+        } catch {
+          log("Could not parse PAYMENT-RESPONSE header");
+        }
+      }
+      setStatus("success");
+      return response;
+    } catch (err) {
+      const error2 = err instanceof Error ? err : new Error(String(err));
+      setError(error2);
+      setStatus("error");
+      throw err;
+    } finally {
+      setIsLoading(false);
+      setTimeout(refreshBalances, 2e3);
+    }
+  }, [client, isAnyWalletConnected, log, refreshBalances]);
+  const transactionUrl = useMemo(() => {
+    if (!transactionId) return null;
+    const network = transactionNetwork || preferredNetwork || SOLANA_MAINNET_NETWORK;
+    return getExplorerUrl(transactionId, network);
+  }, [transactionId, transactionNetwork, preferredNetwork]);
+  return {
+    fetch: fetchWithPayment,
+    isLoading,
+    status,
+    error,
+    transactionId,
+    transactionNetwork,
+    transactionUrl,
+    balances,
+    connectedChains,
+    isAnyWalletConnected,
+    reset,
+    refreshBalances
+  };
+}
+export {
+  X402Error,
+  useX402Payment
+};
+//# sourceMappingURL=index.js.map