@voyage_ai/v402-web-ts 0.1.1 → 0.1.2

package/dist/react/index.mjs

@@ -255,510 +255,9 @@ import {
   TOKEN_2022_PROGRAM_ID,
   TOKEN_PROGRAM_ID
 } from "@solana/spl-token";
-async function createSvmPaymentHeader(params) {
-  const { wallet, paymentRequirements, x402Version, rpcUrl } = params;
-  const connection = new Connection(rpcUrl, "confirmed");
-  const feePayer = paymentRequirements?.extra?.feePayer;
-  if (typeof feePayer !== "string" || !feePayer) {
-    throw new Error("Missing facilitator feePayer in payment requirements (extra.feePayer).");
-  }
-  const feePayerPubkey = new PublicKey(feePayer);
-  const walletAddress = wallet?.publicKey?.toString() || wallet?.address;
-  if (!walletAddress) {
-    throw new Error("Missing connected Solana wallet address or publicKey");
-  }
-  const userPubkey = new PublicKey(walletAddress);
-  if (!paymentRequirements?.payTo) {
-    throw new Error("Missing payTo in payment requirements");
-  }
-  const destination = new PublicKey(paymentRequirements.payTo);
-  const instructions = [];
-  instructions.push(
-    ComputeBudgetProgram.setComputeUnitLimit({
-      units: 7e3
-      // Sufficient for SPL token transfer
-    })
-  );
-  instructions.push(
-    ComputeBudgetProgram.setComputeUnitPrice({
-      microLamports: 1
-      // Minimal price
-    })
-  );
-  if (!paymentRequirements.asset) {
-    throw new Error("Missing token mint for SPL transfer");
-  }
-  const mintPubkey = new PublicKey(paymentRequirements.asset);
-  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 mint = await getMint(connection, mintPubkey, void 0, programId);
-  const sourceAta = await getAssociatedTokenAddress(
-    mintPubkey,
-    userPubkey,
-    false,
-    programId
-  );
-  const destinationAta = await getAssociatedTokenAddress(
-    mintPubkey,
-    destination,
-    false,
-    programId
-  );
-  const sourceAtaInfo = await connection.getAccountInfo(sourceAta, "confirmed");
-  if (!sourceAtaInfo) {
-    throw new Error(
-      `User does not have an Associated Token Account for ${paymentRequirements.asset}. Please create one first or ensure you have the required token.`
-    );
-  }
-  const destAtaInfo = await connection.getAccountInfo(destinationAta, "confirmed");
-  if (!destAtaInfo) {
-    throw new Error(
-      `Destination does not have an Associated Token Account for ${paymentRequirements.asset}. The receiver must create their token account before receiving payments.`
-    );
-  }
-  const amount = BigInt(paymentRequirements.maxAmountRequired);
-  instructions.push(
-    createTransferCheckedInstruction(
-      sourceAta,
-      mintPubkey,
-      destinationAta,
-      userPubkey,
-      amount,
-      mint.decimals,
-      [],
-      programId
-    )
-  );
-  const { blockhash } = await connection.getLatestBlockhash("confirmed");
-  const message = new TransactionMessage({
-    payerKey: feePayerPubkey,
-    recentBlockhash: blockhash,
-    instructions
-  }).compileToV0Message();
-  const transaction = new VersionedTransaction(message);
-  if (typeof wallet?.signTransaction !== "function") {
-    throw new Error("Connected wallet does not support signTransaction");
-  }
-  let userSignedTx;
-  try {
-    userSignedTx = await wallet.signTransaction(transaction);
-    console.log("\u2705 Transaction signed successfully");
-  } catch (error) {
-    console.error("\u274C Failed to sign transaction:", error);
-    throw wrapPaymentError(error);
-  }
-  const serializedTransaction = Buffer.from(userSignedTx.serialize()).toString("base64");
-  const paymentPayload = {
-    x402Version,
-    scheme: paymentRequirements.scheme,
-    network: paymentRequirements.network,
-    payload: {
-      transaction: serializedTransaction
-    }
-  };
-  const paymentHeader = Buffer.from(JSON.stringify(paymentPayload)).toString("base64");
-  return paymentHeader;
-}
-function getDefaultSolanaRpcUrl(network) {
-  const normalized = network.toLowerCase();
-  if (normalized === "solana" || normalized === "solana-mainnet") {
-    return "https://cathee-fu8ezd-fast-mainnet.helius-rpc.com";
-  } else if (normalized === "solana-devnet") {
-    return "https://api.devnet.solana.com";
-  }
-  throw new Error(`Unsupported Solana network: ${network}`);
-}
-
-// src/services/svm/payment-handler.ts
-async function handleSvmPayment(endpoint, config, requestInit) {
-  const { wallet, network, rpcUrl, maxPaymentAmount } = config;
-  const initialResponse = await fetch(endpoint, {
-    ...requestInit,
-    method: requestInit?.method || "POST"
-  });
-  if (initialResponse.status !== 402) {
-    return initialResponse;
-  }
-  const rawResponse = await initialResponse.json();
-  const IGNORED_ERRORS = [
-    "X-PAYMENT header is required",
-    "missing X-PAYMENT header",
-    "payment_required"
-  ];
-  if (rawResponse.error && !IGNORED_ERRORS.includes(rawResponse.error)) {
-    console.error(`\u274C Payment verification failed: ${rawResponse.error}`);
-    const ERROR_MESSAGES = {
-      "insufficient_funds": "Insufficient balance to complete this payment",
-      "invalid_signature": "Invalid payment signature",
-      "expired": "Payment authorization has expired",
-      "already_used": "This payment has already been used",
-      "network_mismatch": "Payment network does not match",
-      "invalid_payment": "Invalid payment data",
-      "verification_failed": "Payment verification failed"
-    };
-    const errorMessage = ERROR_MESSAGES[rawResponse.error] || `Payment failed: ${rawResponse.error}`;
-    const error = new Error(errorMessage);
-    throw wrapPaymentError(error);
-  }
-  const x402Version = rawResponse.x402Version;
-  const parsedPaymentRequirements = rawResponse.accepts || [];
-  const selectedRequirements = parsedPaymentRequirements.find(
-    (req) => req.scheme === "exact" && SolanaNetworkSchema.safeParse(req.network.toLowerCase()).success
-  );
-  if (!selectedRequirements) {
-    console.error(
-      "\u274C No suitable Solana payment requirements found. Available networks:",
-      parsedPaymentRequirements.map((req) => req.network)
-    );
-    throw new Error("No suitable Solana payment requirements found");
-  }
-  if (maxPaymentAmount && maxPaymentAmount > BigInt(0)) {
-    if (BigInt(selectedRequirements.maxAmountRequired) > maxPaymentAmount) {
-      throw new Error(
-        `Payment amount ${selectedRequirements.maxAmountRequired} exceeds maximum allowed ${maxPaymentAmount}`
-      );
-    }
-  }
-  const effectiveRpcUrl = rpcUrl || getDefaultSolanaRpcUrl(selectedRequirements.network);
-  console.log(`\u{1F4CD} Using Solana RPC: ${effectiveRpcUrl.substring(0, 40)}...`);
-  console.log(`\u{1F4CD} Network from backend: ${selectedRequirements.network}`);
-  let paymentHeader;
-  try {
-    paymentHeader = await createSvmPaymentHeader({
-      wallet,
-      paymentRequirements: selectedRequirements,
-      x402Version,
-      rpcUrl: effectiveRpcUrl
-    });
-    console.log("\u2705 Payment header created successfully");
-  } catch (error) {
-    console.error("\u274C Failed to create payment header:", error);
-    throw wrapPaymentError(error);
-  }
-  const newInit = {
-    ...requestInit,
-    method: requestInit?.method || "POST",
-    headers: {
-      ...requestInit?.headers || {},
-      "X-PAYMENT": paymentHeader,
-      "Access-Control-Expose-Headers": "X-PAYMENT-RESPONSE"
-    }
-  };
-  const retryResponse = await fetch(endpoint, newInit);
-  if (retryResponse.status === 402) {
-    try {
-      const retryData = await retryResponse.json();
-      const IGNORED_ERRORS2 = [
-        "X-PAYMENT header is required",
-        "missing X-PAYMENT header",
-        "payment_required"
-      ];
-      if (retryData.error && !IGNORED_ERRORS2.includes(retryData.error)) {
-        console.error(`\u274C Payment verification failed: ${retryData.error}`);
-        const ERROR_MESSAGES = {
-          "insufficient_funds": "Insufficient balance to complete this payment",
-          "invalid_signature": "Invalid payment signature",
-          "expired": "Payment authorization has expired",
-          "already_used": "This payment has already been used",
-          "network_mismatch": "Payment network does not match",
-          "invalid_payment": "Invalid payment data",
-          "verification_failed": "Payment verification failed"
-        };
-        const errorMessage = ERROR_MESSAGES[retryData.error] || `Payment failed: ${retryData.error}`;
-        const error = new Error(errorMessage);
-        throw wrapPaymentError(error);
-      }
-    } catch (error) {
-      if (error instanceof PaymentOperationError) {
-        throw error;
-      }
-      console.warn("\u26A0\uFE0F Could not parse retry 402 response:", error);
-    }
-  }
-  return retryResponse;
-}
 
 // src/services/evm/payment-header.ts
 import { ethers } from "ethers";
-async function createEvmPaymentHeader(params) {
-  const { wallet, paymentRequirements, x402Version, chainId } = params;
-  if (!paymentRequirements?.payTo) {
-    throw new Error("Missing payTo in payment requirements");
-  }
-  if (!paymentRequirements?.asset) {
-    throw new Error("Missing asset (token contract) in payment requirements");
-  }
-  if (wallet.getChainId) {
-    try {
-      const currentChainIdHex = await wallet.getChainId();
-      const currentChainId = parseInt(currentChainIdHex, 16);
-      if (currentChainId !== chainId) {
-        const networkNames = {
-          1: "Ethereum Mainnet",
-          11155111: "Sepolia Testnet",
-          8453: "Base Mainnet",
-          84532: "Base Sepolia Testnet",
-          137: "Polygon Mainnet",
-          42161: "Arbitrum One",
-          10: "Optimism Mainnet"
-        };
-        const currentNetworkName = networkNames[currentChainId] || `Chain ${currentChainId}`;
-        const targetNetworkName = networkNames[chainId] || `Chain ${chainId}`;
-        throw new Error(
-          `Network mismatch: Your wallet is connected to ${currentNetworkName}, but payment requires ${targetNetworkName}. Please switch your wallet to the correct network.`
-        );
-      }
-      console.log(`\u2705 Chain ID verified: ${chainId}`);
-    } catch (error) {
-      if (error.message.includes("Network mismatch")) {
-        throw wrapPaymentError(error);
-      }
-      console.warn("Could not verify chainId:", error);
-    }
-  }
-  const now = Math.floor(Date.now() / 1e3);
-  const nonceBytes = ethers.randomBytes(32);
-  const nonceBytes32 = ethers.hexlify(nonceBytes);
-  const domain = {
-    name: paymentRequirements.extra?.name || "USDC",
-    version: paymentRequirements.extra?.version || "2",
-    chainId,
-    verifyingContract: paymentRequirements.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 authorization = {
-    from: wallet.address,
-    to: paymentRequirements.payTo,
-    value: paymentRequirements.maxAmountRequired,
-    validAfter: "0",
-    // Effective immediately
-    validBefore: String(now + (paymentRequirements.maxTimeoutSeconds || 3600)),
-    nonce: nonceBytes32
-  };
-  let signature;
-  try {
-    signature = await wallet.signTypedData(domain, types, authorization);
-    console.log("\u2705 Signature created successfully");
-  } catch (error) {
-    console.error("\u274C Failed to create signature:", error);
-    throw wrapPaymentError(error);
-  }
-  const headerPayload = {
-    x402_version: x402Version,
-    x402Version,
-    scheme: paymentRequirements.scheme,
-    network: paymentRequirements.network,
-    payload: {
-      signature,
-      authorization: {
-        from: authorization.from,
-        to: authorization.to,
-        value: String(authorization.value),
-        valid_after: authorization.validAfter,
-        validAfter: authorization.validAfter,
-        valid_before: authorization.validBefore,
-        validBefore: authorization.validBefore,
-        nonce: authorization.nonce
-      }
-    }
-  };
-  const paymentHeader = btoa(JSON.stringify(headerPayload));
-  return paymentHeader;
-}
-function getChainIdFromNetwork(network) {
-  const chainIdMap = {
-    "ethereum": 1,
-    "sepolia": 11155111,
-    "base": 8453,
-    "base-sepolia": 84532,
-    "polygon": 137,
-    "arbitrum": 42161,
-    "optimism": 10
-  };
-  const chainId = chainIdMap[network.toLowerCase()];
-  if (!chainId) {
-    throw new Error(`Unknown network: ${network}`);
-  }
-  return chainId;
-}
-
-// src/services/evm/payment-handler.ts
-async function handleEvmPayment(endpoint, config, requestInit) {
-  const { wallet, network, maxPaymentAmount } = config;
-  const initialResponse = await fetch(endpoint, {
-    ...requestInit,
-    method: requestInit?.method || "POST"
-  });
-  if (initialResponse.status !== 402) {
-    return initialResponse;
-  }
-  const rawResponse = await initialResponse.json();
-  const IGNORED_ERRORS = [
-    "X-PAYMENT header is required",
-    "missing X-PAYMENT header",
-    "payment_required"
-  ];
-  if (rawResponse.error && !IGNORED_ERRORS.includes(rawResponse.error)) {
-    console.error(`\u274C Payment verification failed: ${rawResponse.error}`);
-    const ERROR_MESSAGES = {
-      "insufficient_funds": "Insufficient balance to complete this payment",
-      "invalid_signature": "Invalid payment signature",
-      "expired": "Payment authorization has expired",
-      "already_used": "This payment has already been used",
-      "network_mismatch": "Payment network does not match",
-      "invalid_payment": "Invalid payment data",
-      "verification_failed": "Payment verification failed"
-    };
-    const errorMessage = ERROR_MESSAGES[rawResponse.error] || `Payment failed: ${rawResponse.error}`;
-    const error = new Error(errorMessage);
-    throw wrapPaymentError(error);
-  }
-  const x402Version = rawResponse.x402Version;
-  const parsedPaymentRequirements = rawResponse.accepts || [];
-  const selectedRequirements = parsedPaymentRequirements.find(
-    (req) => req.scheme === "exact" && EvmNetworkSchema.safeParse(req.network.toLowerCase()).success
-  );
-  if (!selectedRequirements) {
-    console.error(
-      "\u274C No suitable EVM payment requirements found. Available networks:",
-      parsedPaymentRequirements.map((req) => req.network)
-    );
-    throw new Error("No suitable EVM payment requirements found");
-  }
-  if (maxPaymentAmount && maxPaymentAmount > BigInt(0)) {
-    if (BigInt(selectedRequirements.maxAmountRequired) > maxPaymentAmount) {
-      throw new Error(
-        `Payment amount ${selectedRequirements.maxAmountRequired} exceeds maximum allowed ${maxPaymentAmount}`
-      );
-    }
-  }
-  const targetChainId = getChainIdFromNetwork(selectedRequirements.network);
-  let currentChainId;
-  if (wallet.getChainId) {
-    try {
-      const chainIdHex = await wallet.getChainId();
-      currentChainId = parseInt(chainIdHex, 16);
-      console.log(`\u{1F4CD} Current wallet chain: ${currentChainId}`);
-    } catch (error) {
-      console.warn("\u26A0\uFE0F Failed to get current chainId:", error);
-    }
-  }
-  const networkNames = {
-    1: "Ethereum Mainnet",
-    11155111: "Sepolia Testnet",
-    8453: "Base Mainnet",
-    84532: "Base Sepolia Testnet",
-    137: "Polygon Mainnet",
-    42161: "Arbitrum One",
-    10: "Optimism Mainnet"
-  };
-  if (currentChainId && currentChainId !== targetChainId) {
-    if (!wallet.switchChain) {
-      const currentNetworkName = networkNames[currentChainId] || `Chain ${currentChainId}`;
-      const targetNetworkName = networkNames[targetChainId] || selectedRequirements.network;
-      const error = new Error(
-        `Network mismatch: Your wallet is connected to ${currentNetworkName}, but payment requires ${targetNetworkName}. Please switch to ${targetNetworkName} manually in your wallet.`
-      );
-      throw wrapPaymentError(error);
-    }
-    try {
-      console.log(`\u{1F504} Switching to chain ${targetChainId}...`);
-      await wallet.switchChain(`0x${targetChainId.toString(16)}`);
-      console.log(`\u2705 Successfully switched to chain ${targetChainId}`);
-    } catch (error) {
-      console.error("\u274C Failed to switch chain:", error);
-      const targetNetworkName = networkNames[targetChainId] || selectedRequirements.network;
-      const wrappedError = wrapPaymentError(error);
-      let finalError;
-      if (wrappedError.code === "USER_REJECTED" /* USER_REJECTED */) {
-        finalError = new PaymentOperationError({
-          code: wrappedError.code,
-          message: wrappedError.message,
-          userMessage: `You rejected the network switch request. Please switch to ${targetNetworkName} manually.`,
-          originalError: wrappedError.originalError
-        });
-      } else {
-        finalError = new PaymentOperationError({
-          code: "NETWORK_SWITCH_FAILED" /* NETWORK_SWITCH_FAILED */,
-          message: wrappedError.message,
-          userMessage: `Failed to switch to ${targetNetworkName}. Please switch manually in your wallet.`,
-          originalError: wrappedError.originalError
-        });
-      }
-      throw finalError;
-    }
-  } else if (wallet.switchChain && !currentChainId) {
-    try {
-      console.log(`\u{1F504} Attempting to switch to chain ${targetChainId}...`);
-      await wallet.switchChain(`0x${targetChainId.toString(16)}`);
-      console.log(`\u2705 Switch attempted successfully`);
-    } catch (error) {
-      console.warn("\u26A0\uFE0F Failed to switch chain (best effort):", error);
-    }
-  }
-  let paymentHeader;
-  try {
-    paymentHeader = await createEvmPaymentHeader({
-      wallet,
-      paymentRequirements: selectedRequirements,
-      x402Version,
-      chainId: targetChainId
-    });
-  } catch (error) {
-    console.error("\u274C Failed to create payment header:", error);
-    throw wrapPaymentError(error);
-  }
-  const newInit = {
-    ...requestInit,
-    method: requestInit?.method || "POST",
-    headers: {
-      ...requestInit?.headers || {},
-      "X-PAYMENT": paymentHeader,
-      "Access-Control-Expose-Headers": "X-PAYMENT-RESPONSE"
-    }
-  };
-  const retryResponse = await fetch(endpoint, newInit);
-  if (retryResponse.status === 402) {
-    try {
-      const retryData = await retryResponse.json();
-      const IGNORED_ERRORS2 = [
-        "X-PAYMENT header is required",
-        "missing X-PAYMENT header",
-        "payment_required"
-      ];
-      if (retryData.error && !IGNORED_ERRORS2.includes(retryData.error)) {
-        console.error(`\u274C Payment verification failed: ${retryData.error}`);
-        const ERROR_MESSAGES = {
-          "insufficient_funds": "Insufficient balance to complete this payment",
-          "invalid_signature": "Invalid payment signature",
-          "expired": "Payment authorization has expired",
-          "already_used": "This payment has already been used",
-          "network_mismatch": "Payment network does not match",
-          "invalid_payment": "Invalid payment data",
-          "verification_failed": "Payment verification failed"
-        };
-        const errorMessage = ERROR_MESSAGES[retryData.error] || `Payment failed: ${retryData.error}`;
-        const error = new Error(errorMessage);
-        throw wrapPaymentError(error);
-      }
-    } catch (error) {
-      if (error instanceof PaymentOperationError) {
-        throw error;
-      }
-      console.warn("\u26A0\uFE0F Could not parse retry 402 response:", error);
-    }
-  }
-  return retryResponse;
-}
 
 // src/utils/payment-helpers.ts
 import { ethers as ethers2 } from "ethers";
@@ -785,75 +284,6 @@ function getSupportedNetworkTypes(paymentRequirements) {
   });
   return Array.from(networkTypes);
 }
-async function makePayment(networkType, merchantId, endpoint = PROD_BACK_URL) {
-  endpoint = `${endpoint}/${merchantId}`;
-  let response;
-  if (networkType === "solana" /* SOLANA */ || networkType === "svm" /* SVM */) {
-    const solana = window.solana;
-    if (!solana) {
-      throw new Error("\u8BF7\u5B89\u88C5 Phantom \u94B1\u5305");
-    }
-    if (!solana.isConnected) {
-      await solana.connect();
-    }
-    response = await handleSvmPayment(endpoint, {
-      wallet: solana,
-      network: "solana"
-      // Will use backend's network configuration
-    });
-  } else if (networkType === "evm" /* EVM */) {
-    if (!window.ethereum) {
-      throw new Error("\u8BF7\u5B89\u88C5 MetaMask \u94B1\u5305");
-    }
-    const provider = new ethers2.BrowserProvider(window.ethereum);
-    const signer = await provider.getSigner();
-    const wallet = {
-      address: await signer.getAddress(),
-      signTypedData: async (domain, types, message) => {
-        return await signer.signTypedData(domain, types, message);
-      },
-      // Get current chain ID from wallet
-      getChainId: async () => {
-        const network = await provider.getNetwork();
-        return `0x${network.chainId.toString(16)}`;
-      },
-      // Switch to a different chain
-      switchChain: async (chainId) => {
-        await window.ethereum.request({
-          method: "wallet_switchEthereumChain",
-          params: [{ chainId }]
-        });
-      }
-    };
-    response = await handleEvmPayment(endpoint, {
-      wallet,
-      network: "base"
-      // Will use backend's network configuration
-    });
-  } else {
-    throw new Error(`\u4E0D\u652F\u6301\u7684\u7F51\u7EDC\u7C7B\u578B: ${networkType}`);
-  }
-  return response;
-}
-async function handlePayment(endpoint, networkType, callbacks) {
-  try {
-    callbacks?.onStart?.();
-    const response = await makePayment(networkType, "", endpoint);
-    if (!response.ok) {
-      const errorText = await response.text();
-      throw new Error(`\u8BF7\u6C42\u5931\u8D25 (${response.status}): ${errorText}`);
-    }
-    const result = await response.json();
-    callbacks?.onSuccess?.(result);
-    return result;
-  } catch (err) {
-    const errorMessage = err.message || "\u652F\u4ED8\u5931\u8D25";
-    callbacks?.onError?.(errorMessage);
-    throw err;
-  } finally {
-    callbacks?.onFinish?.();
-  }
-}
 
 // src/utils/network.ts
 var NETWORK_TYPE_MAP = {
@@ -877,6 +307,7 @@ var NETWORK_TYPE_MAP = {
 };
 function getNetworkDisplayName(network) {
   const displayNames = {
+    "evm": "EVM",
     "ethereum": "Ethereum",
     "sepolia": "Sepolia Testnet",
     "base": "Base",
@@ -891,138 +322,6 @@ function getNetworkDisplayName(network) {
   return displayNames[network.toLowerCase()] || network;
 }
 
-// src/utils/payment-error-handler.ts
-function parsePaymentError(error) {
-  if (!error) {
-    return {
-      code: "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-      message: "Unknown error occurred",
-      userMessage: "An unknown error occurred. Please try again.",
-      originalError: error
-    };
-  }
-  const errorMessage = error.message || error.toString();
-  const errorCode = error.code;
-  if (errorCode === 4001 || errorCode === "ACTION_REJECTED" || errorMessage.includes("User rejected") || errorMessage.includes("user rejected") || errorMessage.includes("User denied") || errorMessage.includes("user denied") || errorMessage.includes("ethers-user-denied")) {
-    return {
-      code: "USER_REJECTED" /* USER_REJECTED */,
-      message: "User rejected the transaction",
-      userMessage: "You rejected the signature request. Please try again if you want to proceed.",
-      originalError: error
-    };
-  }
-  if (errorMessage.includes("chainId") && (errorMessage.includes("must match") || errorMessage.includes("does not match"))) {
-    const match = errorMessage.match(/chainId.*?"(\d+)".*?active.*?"(\d+)"/i) || errorMessage.match(/chain (\d+).*?chain (\d+)/i);
-    if (match) {
-      const [, requestedChain, activeChain] = match;
-      return {
-        code: "CHAIN_ID_MISMATCH" /* CHAIN_ID_MISMATCH */,
-        message: `Network mismatch (wallet is on different chain): Requested ${requestedChain}, but wallet is on ${activeChain}`,
-        userMessage: `Your wallet is on the wrong network. Please switch to the correct network and try again.`,
-        originalError: error
-      };
-    }
-    return {
-      code: "CHAIN_ID_MISMATCH" /* CHAIN_ID_MISMATCH */,
-      message: "Network mismatch (wallet selected network does not match)",
-      userMessage: "Your wallet is on the wrong network. Please switch to the correct network.",
-      originalError: error
-    };
-  }
-  if (errorMessage.includes("Network mismatch") || errorMessage.includes("Wrong network") || errorMessage.includes("Incorrect network")) {
-    return {
-      code: "NETWORK_MISMATCH" /* NETWORK_MISMATCH */,
-      message: errorMessage,
-      userMessage: "Please switch your wallet to the correct network.",
-      originalError: error
-    };
-  }
-  if (errorMessage.includes("locked") || errorMessage.includes("Wallet is locked")) {
-    return {
-      code: "WALLET_LOCKED" /* WALLET_LOCKED */,
-      message: "Wallet is locked",
-      userMessage: "Please unlock your wallet and try again.",
-      originalError: error
-    };
-  }
-  if (errorMessage.includes("insufficient") && (errorMessage.includes("balance") || errorMessage.includes("funds"))) {
-    return {
-      code: "INSUFFICIENT_BALANCE" /* INSUFFICIENT_BALANCE */,
-      message: "Insufficient balance",
-      userMessage: "You don't have enough balance to complete this payment.",
-      originalError: error
-    };
-  }
-  if (errorMessage.includes("Failed to switch") || errorMessage.includes("switch chain")) {
-    return {
-      code: "NETWORK_SWITCH_FAILED" /* NETWORK_SWITCH_FAILED */,
-      message: errorMessage,
-      userMessage: "Failed to switch network. Please switch manually in your wallet.",
-      originalError: error
-    };
-  }
-  if (errorMessage.includes("not connected") || errorMessage.includes("No wallet") || errorMessage.includes("Connect wallet")) {
-    return {
-      code: "WALLET_NOT_CONNECTED" /* WALLET_NOT_CONNECTED */,
-      message: "Wallet not connected",
-      userMessage: "Please connect your wallet first.",
-      originalError: error
-    };
-  }
-  if (errorMessage.includes("No suitable") || errorMessage.includes("payment requirements") || errorMessage.includes("Missing payTo") || errorMessage.includes("Missing asset")) {
-    return {
-      code: "INVALID_PAYMENT_REQUIREMENTS" /* INVALID_PAYMENT_REQUIREMENTS */,
-      message: errorMessage,
-      userMessage: "Invalid payment configuration. Please contact support.",
-      originalError: error
-    };
-  }
-  if (errorMessage.includes("exceeds maximum")) {
-    return {
-      code: "AMOUNT_EXCEEDED" /* AMOUNT_EXCEEDED */,
-      message: errorMessage,
-      userMessage: "Payment amount exceeds the maximum allowed.",
-      originalError: error
-    };
-  }
-  if (errorMessage.includes("signature") || errorMessage.includes("sign") || errorCode === "UNKNOWN_ERROR") {
-    return {
-      code: "SIGNATURE_FAILED" /* SIGNATURE_FAILED */,
-      message: errorMessage,
-      userMessage: "Failed to sign the transaction. Please try again.",
-      originalError: error
-    };
-  }
-  return {
-    code: "UNKNOWN_ERROR" /* UNKNOWN_ERROR */,
-    message: errorMessage,
-    userMessage: "An unexpected error occurred. Please try again or contact support.",
-    originalError: error
-  };
-}
-var PaymentOperationError = class _PaymentOperationError extends Error {
-  constructor(paymentError) {
-    super(paymentError.message);
-    this.name = "PaymentOperationError";
-    this.code = paymentError.code;
-    this.userMessage = paymentError.userMessage;
-    this.originalError = paymentError.originalError;
-    if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, _PaymentOperationError);
-    }
-  }
-  /**
-   * Get a formatted error message for logging
-   */
-  toLogString() {
-    return `[${this.code}] ${this.message} | User Message: ${this.userMessage}`;
-  }
-};
-function wrapPaymentError(error) {
-  const parsedError = parsePaymentError(error);
-  return new PaymentOperationError(parsedError);
-}
-
 // src/react/store/walletStore.ts
 var WalletStore = class {
   constructor() {
@@ -1201,7 +500,7 @@ function usePayment() {
 
 // src/react/hooks/usePaymentInfo.ts
 import { useEffect, useState as useState2 } from "react";
-function usePaymentInfo(merchantId, endpoint = PROD_BACK_URL) {
+function usePaymentInfo(merchantId, endpoint = PROD_BACK_URL, additionalParams) {
   const [paymentInfo, setPaymentInfo] = useState2(null);
   const [supportedNetworks, setSupportedNetworks] = useState2([]);
   const [isLoading, setIsLoading] = useState2(true);
@@ -1210,8 +509,17 @@ function usePaymentInfo(merchantId, endpoint = PROD_BACK_URL) {
     setIsLoading(true);
     setError(null);
     try {
-      endpoint = `${endpoint}/${merchantId}`;
-      const response = await fetch(endpoint, { method: "POST" });
+      const fullEndpoint = `${endpoint}/${merchantId}`;
+      const requestInit = {
+        method: "POST",
+        ...additionalParams && Object.keys(additionalParams).length > 0 ? {
+          body: JSON.stringify(additionalParams),
+          headers: {
+            "Content-Type": "application/json"
+          }
+        } : {}
+      };
+      const response = await fetch(fullEndpoint, requestInit);
       if (response.status === 402) {
         const body = await response.json();
         const payment = parsePaymentRequired(body);
@@ -1232,7 +540,7 @@ function usePaymentInfo(merchantId, endpoint = PROD_BACK_URL) {
   };
   useEffect(() => {
     fetchPaymentInfo();
-  }, [endpoint]);
+  }, [endpoint, merchantId]);
   return {
     paymentInfo,
     supportedNetworks,
@@ -1335,12 +643,21 @@ var baseButtonStyle = {
 };
 var getConnectButtonStyle = (isDisabled, isHovered) => {
   const c = getColors();
+  const darkMode = isDarkMode();
+  if (isDisabled) {
+    return {
+      ...baseButtonStyle,
+      background: c.disabled,
+      color: c.disabledText,
+      cursor: "not-allowed",
+      border: darkMode ? "1px solid #404040" : "1px solid #d4d4d4"
+    };
+  }
   return {
     ...baseButtonStyle,
-    background: isDisabled ? c.disabled : isHovered ? c.primaryHover : c.primary,
-    color: isDarkMode() ? "#000000" : "#ffffff",
-    cursor: isDisabled ? "not-allowed" : "pointer",
-    opacity: isDisabled ? 0.5 : 1
+    background: isHovered ? c.primaryHover : c.primary,
+    color: darkMode ? "#000000" : "#ffffff",
+    cursor: "pointer"
   };
 };
 var getDisconnectButtonStyle = (isHovered) => {
@@ -1351,17 +668,6 @@ var getDisconnectButtonStyle = (isHovered) => {
     color: "#ffffff"
   };
 };
-var getPayButtonStyle = (isDisabled, isHovered) => {
-  const c = getColors();
-  return {
-    ...baseButtonStyle,
-    background: isDisabled ? c.disabled : isHovered ? c.successHover : c.success,
-    color: "#ffffff",
-    width: "100%",
-    cursor: isDisabled ? "not-allowed" : "pointer",
-    opacity: isDisabled ? 0.5 : 1
-  };
-};
 var getInstallLinkStyle = (isHovered) => {
   const c = getColors();
   return {
@@ -1446,7 +752,7 @@ function WalletConnect({
     disconnect();
     onDisconnect?.();
   };
-  return /* @__PURE__ */ React.createElement("div", { style: { ...containerStyle, ...className ? {} : {} }, className }, !address ? /* @__PURE__ */ React.createElement("div", { style: getSectionStyle() }, /* @__PURE__ */ React.createElement("h3", { style: getTitleStyle() }, "Connect Wallet"), supportedNetworks.length === 0 ? /* @__PURE__ */ React.createElement("p", { style: getHintStyle() }, "No payment required") : /* @__PURE__ */ React.createElement("div", { style: buttonsContainerStyle }, supportedNetworks.map((network) => {
+  return /* @__PURE__ */ React.createElement("div", { style: { ...containerStyle, ...className ? {} : {} }, className }, !address ? /* @__PURE__ */ React.createElement("div", { style: getSectionStyle() }, /* @__PURE__ */ React.createElement("h3", { style: getTitleStyle() }, "Connect Wallet"), supportedNetworks.length === 0 ? /* @__PURE__ */ React.createElement("p", { style: getHintStyle() }, "Please install a supported wallet extension") : /* @__PURE__ */ React.createElement("div", { style: buttonsContainerStyle }, supportedNetworks.map((network) => {
     const installed = isWalletInstalled(network);
     return /* @__PURE__ */ React.createElement("div", { key: network, style: walletOptionStyle }, /* @__PURE__ */ React.createElement(
       "button",
@@ -1481,61 +787,7 @@ function WalletConnect({
     "Disconnect"
   )), /* @__PURE__ */ React.createElement("p", { style: getHintStyle() }, "Switch account in your wallet to change address")));
 }
-
-// src/react/components/PaymentButton.tsx
-import React2, { useState as useState4 } from "react";
-function PaymentButton({
-  endpoint,
-  className = "",
-  disabled = false,
-  onSuccess,
-  onError,
-  onStart,
-  onFinish,
-  children = "Pay Now"
-}) {
-  const { networkType } = useWallet();
-  const { isProcessing, setIsProcessing, setResult, setError, error } = usePayment();
-  const [isHovered, setIsHovered] = useState4(false);
-  const handleClick = async () => {
-    if (!networkType) {
-      const errorMsg = "Please connect wallet first";
-      setError(errorMsg);
-      onError?.(errorMsg);
-      return;
-    }
-    try {
-      onStart?.();
-      setIsProcessing(true);
-      setError(null);
-      const result = await handlePayment(endpoint, networkType);
-      setResult(result);
-      onSuccess?.(result);
-    } catch (err) {
-      const errorMsg = err.message || "Payment failed";
-      setError(errorMsg);
-      onError?.(errorMsg);
-    } finally {
-      setIsProcessing(false);
-      onFinish?.();
-    }
-  };
-  const isDisabled = disabled || isProcessing || !networkType;
-  return /* @__PURE__ */ React2.createElement(React2.Fragment, null, /* @__PURE__ */ React2.createElement(
-    "button",
-    {
-      style: getPayButtonStyle(isDisabled, isHovered),
-      className,
-      onClick: handleClick,
-      disabled: isDisabled,
-      onMouseEnter: () => setIsHovered(true),
-      onMouseLeave: () => setIsHovered(false)
-    },
-    isProcessing ? "Processing..." : children
-  ), error && /* @__PURE__ */ React2.createElement("p", { style: getErrorStyle() }, error));
-}
 export {
-  PaymentButton,
   WalletConnect,
   usePayment,
   usePaymentInfo,