uvd-x402-sdk 2.0.1

package/dist/react/index.js

@@ -0,0 +1,1218 @@
+'use strict';
+
+var react = require('react');
+var ethers = require('ethers');
+var jsxRuntime = require('react/jsx-runtime');
+
+// src/react/index.tsx
+
+// src/types/index.ts
+var CAIP2_IDENTIFIERS = {
+  // EVM chains
+  base: "eip155:8453",
+  ethereum: "eip155:1",
+  polygon: "eip155:137",
+  arbitrum: "eip155:42161",
+  optimism: "eip155:10",
+  avalanche: "eip155:43114",
+  celo: "eip155:42220",
+  hyperevm: "eip155:999",
+  unichain: "eip155:130",
+  monad: "eip155:143",
+  bsc: "eip155:56",
+  // SVM chains
+  solana: "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp",
+  fogo: "svm:fogo",
+  // Stellar
+  stellar: "stellar:pubnet",
+  // NEAR
+  near: "near:mainnet"
+};
+Object.fromEntries(
+  Object.entries(CAIP2_IDENTIFIERS).map(([k, v]) => [v, k])
+);
+var DEFAULT_CONFIG = {
+  facilitatorUrl: "https://facilitator.ultravioletadao.xyz",
+  defaultChain: "base",
+  autoConnect: false,
+  debug: false,
+  x402Version: "auto"
+};
+var X402Error = class _X402Error extends Error {
+  code;
+  details;
+  constructor(message, code, details) {
+    super(message);
+    this.name = "X402Error";
+    this.code = code;
+    this.details = details;
+    if (Error.captureStackTrace) {
+      Error.captureStackTrace(this, _X402Error);
+    }
+  }
+};
+
+// src/chains/index.ts
+var DEFAULT_FACILITATOR_URL = "https://facilitator.ultravioletadao.xyz";
+var SUPPORTED_CHAINS = {
+  // ============================================================================
+  // EVM CHAINS (11 networks)
+  // ============================================================================
+  base: {
+    chainId: 8453,
+    chainIdHex: "0x2105",
+    name: "base",
+    displayName: "Base",
+    networkType: "evm",
+    rpcUrl: "https://mainnet.base.org",
+    explorerUrl: "https://basescan.org",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  avalanche: {
+    chainId: 43114,
+    chainIdHex: "0xa86a",
+    name: "avalanche",
+    displayName: "Avalanche C-Chain",
+    networkType: "evm",
+    rpcUrl: "https://avalanche-c-chain-rpc.publicnode.com",
+    explorerUrl: "https://snowtrace.io",
+    nativeCurrency: {
+      name: "Avalanche",
+      symbol: "AVAX",
+      decimals: 18
+    },
+    usdc: {
+      address: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  ethereum: {
+    chainId: 1,
+    chainIdHex: "0x1",
+    name: "ethereum",
+    displayName: "Ethereum",
+    networkType: "evm",
+    rpcUrl: "https://eth.llamarpc.com",
+    explorerUrl: "https://etherscan.io",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  polygon: {
+    chainId: 137,
+    chainIdHex: "0x89",
+    name: "polygon",
+    displayName: "Polygon",
+    networkType: "evm",
+    rpcUrl: "https://polygon-rpc.com",
+    explorerUrl: "https://polygonscan.com",
+    nativeCurrency: {
+      name: "Polygon",
+      symbol: "POL",
+      decimals: 18
+    },
+    usdc: {
+      address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  arbitrum: {
+    chainId: 42161,
+    chainIdHex: "0xa4b1",
+    name: "arbitrum",
+    displayName: "Arbitrum One",
+    networkType: "evm",
+    rpcUrl: "https://arb1.arbitrum.io/rpc",
+    explorerUrl: "https://arbiscan.io",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  optimism: {
+    chainId: 10,
+    chainIdHex: "0xa",
+    name: "optimism",
+    displayName: "Optimism",
+    networkType: "evm",
+    rpcUrl: "https://mainnet.optimism.io",
+    explorerUrl: "https://optimistic.etherscan.io",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+      decimals: 6,
+      name: "USD Coin",
+      version: "2"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  celo: {
+    chainId: 42220,
+    chainIdHex: "0xa4ec",
+    name: "celo",
+    displayName: "Celo",
+    networkType: "evm",
+    rpcUrl: "https://forno.celo.org",
+    explorerUrl: "https://celoscan.io",
+    nativeCurrency: {
+      name: "Celo",
+      symbol: "CELO",
+      decimals: 18
+    },
+    usdc: {
+      address: "0xcebA9300f2b948710d2653dD7B07f33A8B32118C",
+      decimals: 6,
+      name: "USDC",
+      // Celo uses "USDC" not "USD Coin" for EIP-712
+      version: "2"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  hyperevm: {
+    chainId: 999,
+    chainIdHex: "0x3e7",
+    name: "hyperevm",
+    displayName: "HyperEVM",
+    networkType: "evm",
+    rpcUrl: "https://rpc.hyperliquid.xyz/evm",
+    explorerUrl: "https://hyperevmscan.io",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0xb88339CB7199b77E23DB6E890353E22632Ba630f",
+      decimals: 6,
+      name: "USDC",
+      // HyperEVM uses "USDC" not "USD Coin"
+      version: "2"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  unichain: {
+    chainId: 130,
+    chainIdHex: "0x82",
+    name: "unichain",
+    displayName: "Unichain",
+    networkType: "evm",
+    rpcUrl: "https://unichain-rpc.publicnode.com",
+    explorerUrl: "https://uniscan.xyz",
+    nativeCurrency: {
+      name: "Ethereum",
+      symbol: "ETH",
+      decimals: 18
+    },
+    usdc: {
+      address: "0x078d782b760474a361dda0af3839290b0ef57ad6",
+      decimals: 6,
+      name: "USDC",
+      // Unichain uses "USDC" not "USD Coin"
+      version: "2"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  monad: {
+    chainId: 143,
+    chainIdHex: "0x8f",
+    name: "monad",
+    displayName: "Monad",
+    networkType: "evm",
+    rpcUrl: "https://rpc.monad.xyz",
+    explorerUrl: "https://monad.socialscan.io",
+    nativeCurrency: {
+      name: "Monad",
+      symbol: "MON",
+      decimals: 18
+    },
+    usdc: {
+      address: "0x754704bc059f8c67012fed69bc8a327a5aafb603",
+      decimals: 6,
+      name: "USDC",
+      // Monad uses "USDC" not "USD Coin"
+      version: "2"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  // BSC disabled: USDC doesn't support ERC-3009 transferWithAuthorization
+  bsc: {
+    chainId: 56,
+    chainIdHex: "0x38",
+    name: "bsc",
+    displayName: "BNB Smart Chain",
+    networkType: "evm",
+    rpcUrl: "https://binance.llamarpc.com",
+    explorerUrl: "https://bscscan.com",
+    nativeCurrency: {
+      name: "Binance Coin",
+      symbol: "BNB",
+      decimals: 18
+    },
+    usdc: {
+      address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+      decimals: 18,
+      // BSC USDC uses 18 decimals
+      name: "USD Coin",
+      version: "2"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: false
+      // Disabled: BSC USDC doesn't support ERC-3009
+    }
+  },
+  // ============================================================================
+  // SVM CHAINS (2 networks) - Solana Virtual Machine
+  // ============================================================================
+  solana: {
+    chainId: 0,
+    // Non-EVM
+    chainIdHex: "0x0",
+    name: "solana",
+    displayName: "Solana",
+    networkType: "svm",
+    rpcUrl: "https://api.mainnet-beta.solana.com",
+    explorerUrl: "https://solscan.io",
+    nativeCurrency: {
+      name: "Solana",
+      symbol: "SOL",
+      decimals: 9
+    },
+    usdc: {
+      address: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+      // USDC SPL token mint
+      decimals: 6,
+      name: "USD Coin",
+      version: "1"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  fogo: {
+    chainId: 0,
+    // Non-EVM (SVM)
+    chainIdHex: "0x0",
+    name: "fogo",
+    displayName: "Fogo",
+    networkType: "svm",
+    rpcUrl: "https://rpc.fogo.nightly.app/",
+    explorerUrl: "https://explorer.fogo.nightly.app",
+    nativeCurrency: {
+      name: "Fogo",
+      symbol: "FOGO",
+      decimals: 9
+    },
+    usdc: {
+      address: "uSd2czE61Evaf76RNbq4KPpXnkiL3irdzgLFUMe3NoG",
+      // Fogo USDC mint
+      decimals: 6,
+      name: "USDC",
+      version: "1"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  // ============================================================================
+  // STELLAR (1 network)
+  // ============================================================================
+  stellar: {
+    chainId: 0,
+    // Non-EVM
+    chainIdHex: "0x0",
+    name: "stellar",
+    displayName: "Stellar",
+    networkType: "stellar",
+    rpcUrl: "https://horizon.stellar.org",
+    explorerUrl: "https://stellar.expert/explorer/public",
+    nativeCurrency: {
+      name: "Lumens",
+      symbol: "XLM",
+      decimals: 7
+      // Stellar uses 7 decimals (stroops)
+    },
+    usdc: {
+      address: "CCW67TSZV3SSS2HXMBQ5JFGCKJNXKZM7UQUWUZPUTHXSTZLEO7SJMI75",
+      // Soroban Asset Contract
+      decimals: 7,
+      // Stellar USDC uses 7 decimals
+      name: "USDC",
+      version: "1"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+    }
+  },
+  // ============================================================================
+  // NEAR (1 network) - Uses NEP-366 meta-transactions
+  // ============================================================================
+  near: {
+    chainId: 0,
+    // Non-EVM
+    chainIdHex: "0x0",
+    name: "near",
+    displayName: "NEAR Protocol",
+    networkType: "near",
+    rpcUrl: "https://rpc.mainnet.near.org",
+    explorerUrl: "https://nearblocks.io",
+    nativeCurrency: {
+      name: "NEAR",
+      symbol: "NEAR",
+      decimals: 24
+      // NEAR uses 24 decimals (yoctoNEAR)
+    },
+    usdc: {
+      address: "17208628f84f5d6ad33f0da3bbbeb27ffcb398eac501a31bd6ad2011e36133a1",
+      // Native Circle USDC
+      decimals: 6,
+      name: "USDC",
+      version: "1"
+    },
+    x402: {
+      facilitatorUrl: DEFAULT_FACILITATOR_URL,
+      enabled: true
+      // NEP-366 meta-transactions supported
+    }
+  }
+};
+function getChainById(chainId) {
+  return Object.values(SUPPORTED_CHAINS).find((chain) => chain.chainId === chainId);
+}
+function getChainByName(name) {
+  return SUPPORTED_CHAINS[name.toLowerCase()];
+}
+function getEnabledChains() {
+  return Object.values(SUPPORTED_CHAINS).filter((chain) => chain.x402.enabled);
+}
+
+// src/client/X402Client.ts
+var X402Client = class {
+  // Configuration
+  config;
+  // Wallet state
+  provider = null;
+  signer = null;
+  connectedAddress = null;
+  currentChainId = null;
+  currentNetwork = null;
+  currentChainName = null;
+  // Event emitter
+  eventHandlers = /* @__PURE__ */ new Map();
+  constructor(config = {}) {
+    this.config = {
+      ...DEFAULT_CONFIG,
+      ...config
+    };
+    if (config.rpcOverrides) {
+      for (const [chainName, rpcUrl] of Object.entries(config.rpcOverrides)) {
+        if (SUPPORTED_CHAINS[chainName]) {
+          SUPPORTED_CHAINS[chainName].rpcUrl = rpcUrl;
+        }
+      }
+    }
+    if (config.customChains) {
+      for (const [chainName, chainConfig] of Object.entries(config.customChains)) {
+        if (SUPPORTED_CHAINS[chainName]) {
+          Object.assign(SUPPORTED_CHAINS[chainName], chainConfig);
+        }
+      }
+    }
+    this.log("X402Client initialized", { config: this.config });
+  }
+  // ============================================================================
+  // PUBLIC API - Wallet Connection
+  // ============================================================================
+  /**
+   * Connect to a wallet on the specified chain
+   */
+  async connect(chainName) {
+    const targetChain = chainName || this.config.defaultChain;
+    const chain = getChainByName(targetChain);
+    if (!chain) {
+      throw new X402Error(`Unsupported chain: ${targetChain}`, "CHAIN_NOT_SUPPORTED");
+    }
+    if (!chain.x402.enabled) {
+      throw new X402Error(`Chain ${targetChain} is not enabled for x402 payments`, "CHAIN_NOT_SUPPORTED");
+    }
+    this.log(`Connecting wallet on ${chain.displayName}...`);
+    switch (chain.networkType) {
+      case "evm":
+        return this.connectEVMWallet(chain);
+      case "solana":
+        throw new X402Error(
+          'Solana support requires importing from "uvd-x402-sdk/solana"',
+          "CHAIN_NOT_SUPPORTED"
+        );
+      case "stellar":
+        throw new X402Error(
+          'Stellar support requires importing from "uvd-x402-sdk/stellar"',
+          "CHAIN_NOT_SUPPORTED"
+        );
+      case "near":
+        throw new X402Error("NEAR is not yet supported by the facilitator", "CHAIN_NOT_SUPPORTED");
+      default:
+        throw new X402Error(`Unknown network type for chain ${targetChain}`, "CHAIN_NOT_SUPPORTED");
+    }
+  }
+  /**
+   * Disconnect the current wallet
+   */
+  async disconnect() {
+    this.provider = null;
+    this.signer = null;
+    this.connectedAddress = null;
+    this.currentChainId = null;
+    this.currentNetwork = null;
+    this.currentChainName = null;
+    this.emit("disconnect", void 0);
+    this.log("Wallet disconnected");
+  }
+  /**
+   * Switch to a different chain (EVM only)
+   */
+  async switchChain(chainName) {
+    const chain = getChainByName(chainName);
+    if (!chain) {
+      throw new X402Error(`Unsupported chain: ${chainName}`, "CHAIN_NOT_SUPPORTED");
+    }
+    if (chain.networkType !== "evm") {
+      throw new X402Error(
+        "switchChain is only supported for EVM networks. Reconnect with connect() for other networks.",
+        "CHAIN_NOT_SUPPORTED"
+      );
+    }
+    if (!this.provider) {
+      throw new X402Error("Wallet not connected", "WALLET_NOT_CONNECTED");
+    }
+    await this.switchEVMChain(chain);
+  }
+  // ============================================================================
+  // PUBLIC API - Payment Creation
+  // ============================================================================
+  /**
+   * Create a payment authorization
+   *
+   * @param paymentInfo - Payment information from 402 response
+   * @returns Payment result with encoded X-PAYMENT header
+   */
+  async createPayment(paymentInfo) {
+    if (!this.connectedAddress) {
+      throw new X402Error("Wallet not connected", "WALLET_NOT_CONNECTED");
+    }
+    if (!this.currentChainName) {
+      throw new X402Error("Chain not set", "CHAIN_NOT_SUPPORTED");
+    }
+    const chain = getChainByName(this.currentChainName);
+    if (!chain) {
+      throw new X402Error(`Chain ${this.currentChainName} not found`, "CHAIN_NOT_SUPPORTED");
+    }
+    this.emit("paymentStarted", { amount: paymentInfo.amount, network: chain.name });
+    this.log("Creating payment...", { paymentInfo, chain: chain.name });
+    try {
+      switch (chain.networkType) {
+        case "evm":
+          return await this.createEVMPayment(paymentInfo, chain);
+        default:
+          throw new X402Error(
+            `Payment creation for ${chain.networkType} requires the appropriate provider`,
+            "CHAIN_NOT_SUPPORTED"
+          );
+      }
+    } catch (error) {
+      const x402Error = error instanceof X402Error ? error : new X402Error(
+        error instanceof Error ? error.message : "Unknown error",
+        "PAYMENT_FAILED",
+        error
+      );
+      this.emit("paymentFailed", { error: x402Error.message, code: x402Error.code });
+      throw x402Error;
+    }
+  }
+  /**
+   * Check USDC balance on current chain
+   */
+  async getBalance() {
+    if (!this.connectedAddress || !this.currentChainName) {
+      throw new X402Error("Wallet not connected", "WALLET_NOT_CONNECTED");
+    }
+    const chain = getChainByName(this.currentChainName);
+    if (!chain) {
+      throw new X402Error(`Chain ${this.currentChainName} not found`, "CHAIN_NOT_SUPPORTED");
+    }
+    switch (chain.networkType) {
+      case "evm":
+        return this.getEVMBalance(chain);
+      default:
+        throw new X402Error(
+          `Balance check for ${chain.networkType} requires the appropriate provider`,
+          "CHAIN_NOT_SUPPORTED"
+        );
+    }
+  }
+  // ============================================================================
+  // PUBLIC API - Getters
+  // ============================================================================
+  /**
+   * Get current wallet state
+   */
+  getState() {
+    return {
+      connected: this.connectedAddress !== null,
+      address: this.connectedAddress,
+      chainId: this.currentChainId,
+      network: this.currentChainName,
+      networkType: this.currentNetwork,
+      balance: null
+      // Call getBalance() separately
+    };
+  }
+  /**
+   * Get connected wallet address
+   */
+  getAddress() {
+    return this.connectedAddress;
+  }
+  /**
+   * Get current chain ID
+   */
+  getChainId() {
+    return this.currentChainId;
+  }
+  /**
+   * Get current chain name
+   */
+  getChainName() {
+    return this.currentChainName;
+  }
+  /**
+   * Get current chain display name
+   */
+  getChainDisplayName() {
+    if (!this.currentChainName) return null;
+    const chain = getChainByName(this.currentChainName);
+    return chain?.displayName ?? null;
+  }
+  /**
+   * Check if wallet is connected
+   */
+  isConnected() {
+    return this.connectedAddress !== null;
+  }
+  /**
+   * Get list of enabled chains
+   */
+  getEnabledChains() {
+    return getEnabledChains();
+  }
+  /**
+   * Get chain config by name
+   */
+  getChain(name) {
+    return getChainByName(name);
+  }
+  // ============================================================================
+  // PUBLIC API - Events
+  // ============================================================================
+  /**
+   * Subscribe to an event
+   */
+  on(event, handler) {
+    if (!this.eventHandlers.has(event)) {
+      this.eventHandlers.set(event, /* @__PURE__ */ new Set());
+    }
+    this.eventHandlers.get(event).add(handler);
+    return () => this.off(event, handler);
+  }
+  /**
+   * Unsubscribe from an event
+   */
+  off(event, handler) {
+    this.eventHandlers.get(event)?.delete(handler);
+  }
+  // ============================================================================
+  // PRIVATE - EVM Wallet Connection
+  // ============================================================================
+  async connectEVMWallet(chain) {
+    if (typeof window === "undefined" || !window.ethereum) {
+      throw new X402Error(
+        "No Ethereum wallet found. Please install MetaMask or another EVM wallet.",
+        "WALLET_NOT_FOUND"
+      );
+    }
+    try {
+      this.provider = new ethers.ethers.BrowserProvider(window.ethereum);
+      await this.provider.send("eth_requestAccounts", []);
+      await this.switchEVMChain(chain);
+      this.signer = await this.provider.getSigner();
+      this.connectedAddress = await this.signer.getAddress();
+      this.currentChainId = chain.chainId;
+      this.currentNetwork = "evm";
+      this.currentChainName = chain.name;
+      this.setupEVMEventListeners();
+      const state = this.getState();
+      this.emit("connect", state);
+      this.log("EVM wallet connected", { address: this.connectedAddress, chain: chain.name });
+      return this.connectedAddress;
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.includes("User rejected") || error.code === 4001) {
+          throw new X402Error("Connection rejected by user", "WALLET_CONNECTION_REJECTED");
+        }
+      }
+      throw new X402Error(
+        `Failed to connect wallet: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "UNKNOWN_ERROR",
+        error
+      );
+    }
+  }
+  async switchEVMChain(chain) {
+    if (!this.provider) {
+      throw new X402Error("Wallet not connected", "WALLET_NOT_CONNECTED");
+    }
+    try {
+      await this.provider.send("wallet_switchEthereumChain", [{ chainId: chain.chainIdHex }]);
+    } catch (switchError) {
+      if (switchError.code === 4902) {
+        try {
+          await this.provider.send("wallet_addEthereumChain", [
+            {
+              chainId: chain.chainIdHex,
+              chainName: chain.displayName,
+              nativeCurrency: chain.nativeCurrency,
+              rpcUrls: [chain.rpcUrl],
+              blockExplorerUrls: [chain.explorerUrl]
+            }
+          ]);
+        } catch (addError) {
+          throw new X402Error(
+            `Failed to add ${chain.displayName} network`,
+            "CHAIN_SWITCH_REJECTED",
+            addError
+          );
+        }
+      } else if (switchError.code === 4001) {
+        throw new X402Error("Network switch rejected by user", "CHAIN_SWITCH_REJECTED");
+      } else {
+        throw new X402Error(
+          `Failed to switch to ${chain.displayName}`,
+          "CHAIN_SWITCH_REJECTED",
+          switchError
+        );
+      }
+    }
+    this.currentChainId = chain.chainId;
+    this.currentChainName = chain.name;
+    this.emit("chainChanged", { chainId: chain.chainId, chainName: chain.name });
+  }
+  setupEVMEventListeners() {
+    if (typeof window === "undefined" || !window.ethereum) return;
+    window.ethereum.on?.("accountsChanged", ((...args) => {
+      const accounts = args[0];
+      if (accounts.length === 0) {
+        this.disconnect();
+      } else if (accounts[0] !== this.connectedAddress) {
+        this.connectedAddress = accounts[0];
+        this.emit("accountChanged", { address: accounts[0] });
+      }
+    }));
+    window.ethereum.on?.("chainChanged", ((...args) => {
+      const chainIdHex = args[0];
+      const chainId = parseInt(chainIdHex, 16);
+      const chain = getChainById(chainId);
+      if (chain) {
+        this.currentChainId = chainId;
+        this.currentChainName = chain.name;
+        this.emit("chainChanged", { chainId, chainName: chain.name });
+      }
+    }));
+  }
+  // ============================================================================
+  // PRIVATE - EVM Payment Creation
+  // ============================================================================
+  async createEVMPayment(paymentInfo, chain) {
+    if (!this.signer) {
+      throw new X402Error("Wallet not connected", "WALLET_NOT_CONNECTED");
+    }
+    const recipient = this.getRecipientForNetwork(paymentInfo, "evm");
+    const nonceBytes = new Uint8Array(32);
+    if (typeof window !== "undefined" && window.crypto) {
+      window.crypto.getRandomValues(nonceBytes);
+    } else {
+      for (let i = 0; i < 32; i++) {
+        nonceBytes[i] = Math.floor(Math.random() * 256);
+      }
+    }
+    const nonce = ethers.ethers.hexlify(nonceBytes);
+    const validAfter = 0;
+    const validityWindowSeconds = chain.name === "base" ? 300 : 60;
+    const validBefore = Math.floor(Date.now() / 1e3) + validityWindowSeconds;
+    const domain = {
+      name: chain.usdc.name,
+      version: chain.usdc.version,
+      chainId: chain.chainId,
+      verifyingContract: chain.usdc.address
+    };
+    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 value = ethers.ethers.parseUnits(paymentInfo.amount, chain.usdc.decimals);
+    const from = await this.signer.getAddress();
+    const to = ethers.ethers.getAddress(recipient);
+    const message = {
+      from,
+      to,
+      value,
+      validAfter,
+      validBefore,
+      nonce
+    };
+    this.log("Signing EIP-712 message...", { domain, message });
+    let signature;
+    try {
+      signature = await this.signer.signTypedData(domain, types, message);
+    } catch (error) {
+      if (error instanceof Error && (error.message.includes("User rejected") || error.code === 4001)) {
+        throw new X402Error("Signature rejected by user", "SIGNATURE_REJECTED");
+      }
+      throw new X402Error(
+        `Failed to sign payment: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "PAYMENT_FAILED",
+        error
+      );
+    }
+    const sig = ethers.ethers.Signature.from(signature);
+    const payload = {
+      from,
+      to,
+      value: value.toString(),
+      validAfter,
+      validBefore,
+      nonce,
+      v: sig.v,
+      r: sig.r,
+      s: sig.s,
+      chainId: chain.chainId,
+      token: chain.usdc.address
+    };
+    const paymentHeader = this.encodeEVMPaymentHeader(payload, chain);
+    this.emit("paymentSigned", { paymentHeader });
+    const result = {
+      success: true,
+      paymentHeader,
+      network: chain.name,
+      payer: from
+    };
+    this.emit("paymentCompleted", result);
+    this.log("Payment created successfully", { network: chain.name, from });
+    return result;
+  }
+  encodeEVMPaymentHeader(payload, chain) {
+    const fullSignature = payload.r + payload.s.slice(2) + payload.v.toString(16).padStart(2, "0");
+    const x402Payload = {
+      x402Version: 1,
+      scheme: "exact",
+      network: chain.name,
+      payload: {
+        signature: fullSignature,
+        authorization: {
+          from: payload.from,
+          to: payload.to,
+          value: payload.value,
+          validAfter: payload.validAfter.toString(),
+          validBefore: payload.validBefore.toString(),
+          nonce: payload.nonce
+        }
+      }
+    };
+    const jsonString = JSON.stringify(x402Payload);
+    return btoa(jsonString);
+  }
+  // ============================================================================
+  // PRIVATE - EVM Balance Check
+  // ============================================================================
+  async getEVMBalance(chain) {
+    const publicProvider = new ethers.ethers.JsonRpcProvider(chain.rpcUrl);
+    const usdcAbi = ["function balanceOf(address owner) view returns (uint256)"];
+    const usdcContract = new ethers.ethers.Contract(chain.usdc.address, usdcAbi, publicProvider);
+    try {
+      const balance = await usdcContract.balanceOf(this.connectedAddress);
+      const formatted = ethers.ethers.formatUnits(balance, chain.usdc.decimals);
+      return parseFloat(formatted).toFixed(2);
+    } catch {
+      return "0.00";
+    }
+  }
+  // ============================================================================
+  // PRIVATE - Utilities
+  // ============================================================================
+  getRecipientForNetwork(paymentInfo, network) {
+    const lookupNetwork = network === "svm" ? "solana" : network;
+    const recipients = paymentInfo.recipients;
+    if (recipients?.[lookupNetwork]) {
+      return recipients[lookupNetwork];
+    }
+    return paymentInfo.recipient;
+  }
+  emit(event, data) {
+    this.eventHandlers.get(event)?.forEach((handler) => {
+      try {
+        handler(data);
+      } catch (error) {
+        console.error(`Error in ${event} handler:`, error);
+      }
+    });
+  }
+  log(message, data) {
+    if (this.config.debug) {
+      console.log(`[X402Client] ${message}`, data ?? "");
+    }
+  }
+};
+var X402Context = react.createContext(null);
+function X402Provider({ children, config }) {
+  const [client] = react.useState(() => new X402Client(config));
+  const [state, setState] = react.useState(() => client.getState());
+  react.useEffect(() => {
+    const unsubConnect = client.on("connect", (newState) => {
+      setState(newState);
+    });
+    const unsubDisconnect = client.on("disconnect", () => {
+      setState(client.getState());
+    });
+    const unsubChainChanged = client.on("chainChanged", () => {
+      setState(client.getState());
+    });
+    const unsubAccountChanged = client.on("accountChanged", () => {
+      setState(client.getState());
+    });
+    return () => {
+      unsubConnect();
+      unsubDisconnect();
+      unsubChainChanged();
+      unsubAccountChanged();
+    };
+  }, [client]);
+  const connect = react.useCallback(
+    async (chainName) => {
+      const address = await client.connect(chainName);
+      setState(client.getState());
+      return address;
+    },
+    [client]
+  );
+  const disconnect = react.useCallback(async () => {
+    await client.disconnect();
+    setState(client.getState());
+  }, [client]);
+  const switchChain = react.useCallback(
+    async (chainName) => {
+      await client.switchChain(chainName);
+      setState(client.getState());
+    },
+    [client]
+  );
+  const getBalance = react.useCallback(() => client.getBalance(), [client]);
+  const value = react.useMemo(
+    () => ({
+      client,
+      state,
+      connect,
+      disconnect,
+      switchChain,
+      getBalance
+    }),
+    [client, state, connect, disconnect, switchChain, getBalance]
+  );
+  return /* @__PURE__ */ jsxRuntime.jsx(X402Context.Provider, { value, children });
+}
+function useX402() {
+  const context = react.useContext(X402Context);
+  if (!context) {
+    throw new Error("useX402 must be used within an X402Provider");
+  }
+  const { client, state, connect, disconnect, switchChain, getBalance } = context;
+  return {
+    // State
+    isConnected: state.connected,
+    address: state.address,
+    chainId: state.chainId,
+    network: state.network,
+    networkType: state.networkType,
+    // Methods
+    connect,
+    disconnect,
+    switchChain,
+    getBalance,
+    // Client access for advanced usage
+    client
+  };
+}
+function useBalance() {
+  const { client, isConnected, network } = useX402();
+  const [balance, setBalance] = react.useState(null);
+  const [isLoading, setIsLoading] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const fetchBalance = react.useCallback(async () => {
+    if (!isConnected) {
+      setBalance(null);
+      return;
+    }
+    setIsLoading(true);
+    setError(null);
+    try {
+      const bal = await client.getBalance();
+      setBalance(bal);
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Failed to fetch balance");
+      setBalance(null);
+    } finally {
+      setIsLoading(false);
+    }
+  }, [client, isConnected]);
+  react.useEffect(() => {
+    fetchBalance();
+  }, [fetchBalance, network]);
+  return {
+    balance,
+    isLoading,
+    error,
+    refetch: fetchBalance
+  };
+}
+function usePayment() {
+  const { client, isConnected } = useX402();
+  const [isPaying, setIsPaying] = react.useState(false);
+  const [error, setError] = react.useState(null);
+  const [lastResult, setLastResult] = react.useState(null);
+  const pay = react.useCallback(
+    async (paymentInfo) => {
+      if (!isConnected) {
+        throw new Error("Wallet not connected");
+      }
+      setIsPaying(true);
+      setError(null);
+      try {
+        const result = await client.createPayment(paymentInfo);
+        setLastResult(result);
+        return result;
+      } catch (err) {
+        const message = err instanceof Error ? err.message : "Payment failed";
+        setError(message);
+        throw err;
+      } finally {
+        setIsPaying(false);
+      }
+    },
+    [client, isConnected]
+  );
+  const reset = react.useCallback(() => {
+    setError(null);
+    setLastResult(null);
+  }, []);
+  return {
+    pay,
+    isPaying,
+    error,
+    lastResult,
+    reset
+  };
+}
+function useChains() {
+  const { network: currentNetwork } = useX402();
+  const chains = react.useMemo(() => getEnabledChains(), []);
+  const currentChain = react.useMemo(
+    () => currentNetwork ? getChainByName(currentNetwork) : null,
+    [currentNetwork]
+  );
+  const evmChains = react.useMemo(
+    () => chains.filter((c) => c.networkType === "evm"),
+    [chains]
+  );
+  const nonEvmChains = react.useMemo(
+    () => chains.filter((c) => c.networkType !== "evm"),
+    [chains]
+  );
+  return {
+    chains,
+    currentChain,
+    evmChains,
+    nonEvmChains,
+    getChain: getChainByName
+  };
+}
+function useNetworkBalances() {
+  const { address, isConnected, networkType } = useX402();
+  const [balances, setBalances] = react.useState(/* @__PURE__ */ new Map());
+  const [isLoading, setIsLoading] = react.useState(false);
+  const fetchAllBalances = react.useCallback(async () => {
+    if (!isConnected || !address) {
+      setBalances(/* @__PURE__ */ new Map());
+      return;
+    }
+    setIsLoading(true);
+    const chains = getEnabledChains();
+    const compatibleChains = chains.filter((chain) => {
+      if (address.startsWith("0x")) {
+        return chain.networkType === "evm";
+      }
+      return chain.networkType === networkType;
+    });
+    const newBalances = /* @__PURE__ */ new Map();
+    compatibleChains.forEach((chain) => {
+      newBalances.set(chain.name, {
+        chainName: chain.name,
+        displayName: chain.displayName,
+        balance: null,
+        isLoading: true,
+        error: null
+      });
+    });
+    setBalances(new Map(newBalances));
+    await Promise.allSettled(
+      compatibleChains.map(async (chain) => {
+        try {
+          const provider = new (await import('ethers')).JsonRpcProvider(chain.rpcUrl);
+          const usdcAbi = ["function balanceOf(address) view returns (uint256)"];
+          const contract = new (await import('ethers')).Contract(
+            chain.usdc.address,
+            usdcAbi,
+            provider
+          );
+          const balance = await contract.balanceOf(address);
+          const formatted = parseFloat(
+            (await import('ethers')).formatUnits(balance, chain.usdc.decimals)
+          ).toFixed(2);
+          newBalances.set(chain.name, {
+            chainName: chain.name,
+            displayName: chain.displayName,
+            balance: formatted,
+            isLoading: false,
+            error: null
+          });
+        } catch (err) {
+          newBalances.set(chain.name, {
+            chainName: chain.name,
+            displayName: chain.displayName,
+            balance: null,
+            isLoading: false,
+            error: err instanceof Error ? err.message : "Failed"
+          });
+        }
+        setBalances(new Map(newBalances));
+      })
+    );
+    setIsLoading(false);
+  }, [address, isConnected, networkType]);
+  react.useEffect(() => {
+    fetchAllBalances();
+  }, [fetchAllBalances]);
+  const highestBalanceNetwork = react.useMemo(() => {
+    let maxBalance = 0;
+    let maxChain = null;
+    balances.forEach((nb, chainName) => {
+      if (nb.balance !== null && !nb.error) {
+        const bal = parseFloat(nb.balance);
+        if (bal > maxBalance) {
+          maxBalance = bal;
+          maxChain = chainName;
+        }
+      }
+    });
+    return maxChain;
+  }, [balances]);
+  return {
+    balances,
+    isLoading,
+    refetch: fetchAllBalances,
+    highestBalanceNetwork
+  };
+}
+
+exports.X402Provider = X402Provider;
+exports.useBalance = useBalance;
+exports.useChains = useChains;
+exports.useNetworkBalances = useNetworkBalances;
+exports.usePayment = usePayment;
+exports.useX402 = useX402;
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map