@voyage_ai/v402-web-ts 0.2.0 → 0.3.0

package/dist/index.mjs

@@ -8,7 +8,7 @@ var PROD_BACK_URL;
 var init_common = __esm({
   "src/types/common.ts"() {
     "use strict";
-    PROD_BACK_URL = "https://v402pay.onvoyage.ai/api/pay";
+    PROD_BACK_URL = true ? "https://v402pay.onvoyage.ai/api/pay" : "https://v402pay.onvoyage.ai/api/pay";
   }
 });
 
@@ -183,16 +183,10 @@ var init_wallet = __esm({
 init_types();
 
 // src/services/svm/payment-header.ts
-import {
-  ComputeBudgetProgram,
-  Connection,
-  PublicKey,
-  TransactionMessage,
-  VersionedTransaction
-} from "@solana/web3.js";
+import { ComputeBudgetProgram, Connection, PublicKey, TransactionMessage, VersionedTransaction } from "@solana/web3.js";
 import {
   createTransferCheckedInstruction,
-  getAssociatedTokenAddress,
+  getAssociatedTokenAddressSync,
   getMint,
   TOKEN_2022_PROGRAM_ID,
   TOKEN_PROGRAM_ID
@@ -201,6 +195,40 @@ import {
 // src/utils/index.ts
 init_wallet();
 
+// src/utils/wallet-discovery.ts
+var evmWallets = /* @__PURE__ */ new Map();
+var evmDiscoveryListeners = /* @__PURE__ */ new Set();
+var evmDiscoveryInitialized = false;
+var currentConnectedWallet = null;
+function initEVMWalletDiscovery() {
+  if (typeof window === "undefined" || evmDiscoveryInitialized) return;
+  evmDiscoveryInitialized = true;
+  window.addEventListener("eip6963:announceProvider", ((event) => {
+    const { info, provider } = event.detail;
+    evmWallets.set(info.uuid, { info, provider });
+    evmDiscoveryListeners.forEach((listener) => listener());
+  }));
+  window.dispatchEvent(new Event("eip6963:requestProvider"));
+}
+function getWalletProviderForPayment(networkType) {
+  if (currentConnectedWallet && currentConnectedWallet.networkType === networkType) {
+    return currentConnectedWallet.provider;
+  }
+  if (typeof window === "undefined") return null;
+  switch (networkType) {
+    case "evm" /* EVM */:
+      return window.ethereum;
+    case "solana" /* SOLANA */:
+    case "svm" /* SVM */:
+      return window.phantom?.solana || window.solana;
+    default:
+      return null;
+  }
+}
+if (typeof window !== "undefined") {
+  initEVMWalletDiscovery();
+}
+
 // src/services/evm/payment-header.ts
 import { ethers } from "ethers";
 async function createEvmPaymentHeader(params) {
@@ -316,6 +344,15 @@ function getChainIdFromNetwork(network) {
 
 // src/services/evm/payment-handler.ts
 init_types();
+var NETWORK_NAMES = {
+  1: "Ethereum Mainnet",
+  11155111: "Sepolia Testnet",
+  8453: "Base Mainnet",
+  84532: "Base Sepolia Testnet",
+  137: "Polygon Mainnet",
+  42161: "Arbitrum One",
+  10: "Optimism Mainnet"
+};
 async function handleEvmPayment(endpoint, config, requestInit) {
   const { wallet, network, maxPaymentAmount } = config;
   const initialResponse = await fetch(endpoint, {
@@ -326,25 +363,10 @@ async function handleEvmPayment(endpoint, config, requestInit) {
     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)) {
+  if (rawResponse.error && !IGNORED_402_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 errorMessage = PAYMENT_ERROR_MESSAGES[rawResponse.error] || `Payment failed: ${rawResponse.error}`;
+    throw wrapPaymentError(new Error(errorMessage));
   }
   const x402Version = rawResponse.x402Version;
   const parsedPaymentRequirements = rawResponse.accepts || [];
@@ -376,19 +398,10 @@ async function handleEvmPayment(endpoint, config, requestInit) {
       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 currentNetworkName = NETWORK_NAMES[currentChainId] || `Chain ${currentChainId}`;
+      const targetNetworkName = NETWORK_NAMES[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.`
       );
@@ -400,7 +413,7 @@ async function handleEvmPayment(endpoint, config, requestInit) {
       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 targetNetworkName = NETWORK_NAMES[targetChainId] || selectedRequirements.network;
       const wrappedError = wrapPaymentError(error);
       let finalError;
       if (wrappedError.code === "USER_REJECTED" /* USER_REJECTED */) {
@@ -454,25 +467,10 @@ async function handleEvmPayment(endpoint, config, requestInit) {
   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)) {
+      if (retryData.error && !IGNORED_402_ERRORS.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);
+        const errorMessage = PAYMENT_ERROR_MESSAGES[retryData.error] || `Payment failed: ${retryData.error}`;
+        throw wrapPaymentError(new Error(errorMessage));
       }
     } catch (error) {
       if (error instanceof PaymentOperationError) {
@@ -503,9 +501,9 @@ async function makePayment(networkType, merchantId, endpoint = PROD_BACK_URL, ad
     }
   } : {};
   if (networkType === "solana" /* SOLANA */ || networkType === "svm" /* SVM */) {
-    const solana = window.solana;
+    const solana = getWalletProviderForPayment(networkType);
     if (!solana) {
-      throw new Error("\u8BF7\u5B89\u88C5 Phantom \u94B1\u5305");
+      throw new Error("\u8BF7\u5148\u8FDE\u63A5 Solana \u94B1\u5305");
     }
     if (!solana.isConnected) {
       await solana.connect();
@@ -516,10 +514,11 @@ async function makePayment(networkType, merchantId, endpoint = PROD_BACK_URL, ad
       // Will use backend's network configuration
     }, requestInit);
   } else if (networkType === "evm" /* EVM */) {
-    if (!window.ethereum) {
-      throw new Error("\u8BF7\u5B89\u88C5 MetaMask \u94B1\u5305");
+    const ethereum = getWalletProviderForPayment(networkType);
+    if (!ethereum) {
+      throw new Error("\u8BF7\u5148\u8FDE\u63A5 EVM \u94B1\u5305");
     }
-    const provider = new ethers2.BrowserProvider(window.ethereum);
+    const provider = new ethers2.BrowserProvider(ethereum);
     const signer = await provider.getSigner();
     const wallet = {
       address: await signer.getAddress(),
@@ -533,7 +532,7 @@ async function makePayment(networkType, merchantId, endpoint = PROD_BACK_URL, ad
       },
       // Switch to a different chain
       switchChain: async (chainId) => {
-        await window.ethereum.request({
+        await ethereum.request({
           method: "wallet_switchEthereumChain",
           params: [{ chainId }]
         });
@@ -620,6 +619,21 @@ function is402Response(response) {
 }
 
 // src/utils/payment-error-handler.ts
+var IGNORED_402_ERRORS = [
+  "X-PAYMENT header is required",
+  "missing X-PAYMENT header",
+  "payment_required"
+];
+var PAYMENT_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",
+  "invalid_exact_svm_payload_transaction_simulation_failed": "Transaction simulation failed due to insufficient balance. Please check your wallet balance carefully and ensure you have enough funds to cover the payment and transaction fees."
+};
 function parsePaymentError(error) {
   if (!error) {
     return {
@@ -754,7 +768,7 @@ function wrapPaymentError(error) {
 // src/services/svm/payment-header.ts
 async function createSvmPaymentHeader(params) {
   const { wallet, paymentRequirements, x402Version, rpcUrl } = params;
-  const connection = new Connection(rpcUrl, "confirmed");
+  const connection = new Connection(rpcUrl);
   const feePayer = paymentRequirements?.extra?.feePayer;
   if (typeof feePayer !== "string" || !feePayer) {
     throw new Error("Missing facilitator feePayer in payment requirements (extra.feePayer).");
@@ -768,83 +782,85 @@ async function createSvmPaymentHeader(params) {
   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
-    })
-  );
+  const destinationPubkey = new PublicKey(paymentRequirements.payTo);
   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(
+  const mintAccountInfo = await connection.getAccountInfo(mintPubkey);
+  if (!mintAccountInfo) {
+    throw new Error(`Mint account ${mintPubkey.toBase58()} not found`);
+  }
+  const tokenProgramId = mintAccountInfo.owner.equals(TOKEN_2022_PROGRAM_ID) ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
+  const mint = await getMint(connection, mintPubkey, void 0, tokenProgramId);
+  const sourceAta = getAssociatedTokenAddressSync(
     mintPubkey,
     userPubkey,
     false,
-    programId
+    tokenProgramId
   );
-  const destinationAta = await getAssociatedTokenAddress(
+  const destinationAta = getAssociatedTokenAddressSync(
     mintPubkey,
-    destination,
+    destinationPubkey,
     false,
-    programId
+    tokenProgramId
   );
-  const sourceAtaInfo = await connection.getAccountInfo(sourceAta, "confirmed");
+  const sourceAtaInfo = await connection.getAccountInfo(sourceAta);
   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");
+  const destAtaInfo = await connection.getAccountInfo(destinationAta);
   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(
+  const instructions = [
+    ComputeBudgetProgram.setComputeUnitLimit({
+      units: 7e3
+      // Sufficient for SPL token transfer
+    }),
+    ComputeBudgetProgram.setComputeUnitPrice({
+      microLamports: 1
+      // Minimal price
+    }),
     createTransferCheckedInstruction(
       sourceAta,
       mintPubkey,
       destinationAta,
       userPubkey,
-      amount,
+      BigInt(paymentRequirements.maxAmountRequired),
       mint.decimals,
       [],
-      programId
+      tokenProgramId
     )
-  );
-  const { blockhash } = await connection.getLatestBlockhash("confirmed");
-  const message = new TransactionMessage({
+  ];
+  const { blockhash } = await connection.getLatestBlockhash();
+  const messageV0 = new TransactionMessage({
     payerKey: feePayerPubkey,
     recentBlockhash: blockhash,
     instructions
   }).compileToV0Message();
-  const transaction = new VersionedTransaction(message);
+  const transaction = new VersionedTransaction(messageV0);
   if (typeof wallet?.signTransaction !== "function") {
     throw new Error("Connected wallet does not support signTransaction");
   }
-  let userSignedTx;
+  let signedTransaction;
   try {
-    userSignedTx = await wallet.signTransaction(transaction);
+    signedTransaction = 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 serializedBytes = signedTransaction.serialize();
+  let binary = "";
+  for (let i = 0; i < serializedBytes.length; i++) {
+    binary += String.fromCharCode(serializedBytes[i]);
+  }
+  const serializedTransaction = btoa(binary);
   const paymentPayload = {
     x402Version,
     scheme: paymentRequirements.scheme,
@@ -853,7 +869,7 @@ async function createSvmPaymentHeader(params) {
       transaction: serializedTransaction
     }
   };
-  const paymentHeader = Buffer.from(JSON.stringify(paymentPayload)).toString("base64");
+  const paymentHeader = btoa(JSON.stringify(paymentPayload));
   return paymentHeader;
 }
 function getDefaultSolanaRpcUrl(network) {
@@ -869,7 +885,7 @@ function getDefaultSolanaRpcUrl(network) {
 // src/services/svm/payment-handler.ts
 init_types();
 async function handleSvmPayment(endpoint, config, requestInit) {
-  const { wallet, network, rpcUrl, maxPaymentAmount } = config;
+  const { wallet, rpcUrl, maxPaymentAmount } = config;
   const initialResponse = await fetch(endpoint, {
     ...requestInit,
     method: requestInit?.method || "POST"
@@ -878,26 +894,10 @@ async function handleSvmPayment(endpoint, config, requestInit) {
     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)) {
+  if (rawResponse.error && !IGNORED_402_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",
-      "invalid_exact_svm_payload_transaction_simulation_failed": "Transaction simulation failed due to insufficient balance. Please check your wallet balance carefully and ensure you have enough funds to cover the payment and transaction fees."
-    };
-    const errorMessage = ERROR_MESSAGES[rawResponse.error] || `Payment failed: ${rawResponse.error}`;
-    const error = new Error(errorMessage);
-    throw wrapPaymentError(error);
+    const errorMessage = PAYMENT_ERROR_MESSAGES[rawResponse.error] || `Payment failed: ${rawResponse.error}`;
+    throw wrapPaymentError(new Error(errorMessage));
   }
   const x402Version = rawResponse.x402Version;
   const parsedPaymentRequirements = rawResponse.accepts || [];
@@ -947,26 +947,10 @@ async function handleSvmPayment(endpoint, config, requestInit) {
   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)) {
+      if (retryData.error && !IGNORED_402_ERRORS.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",
-          "invalid_exact_svm_payload_transaction_simulation_failed": "Transaction simulation failed due to insufficient balance. Please check your wallet balance carefully and ensure you have enough funds to cover the payment and transaction fees."
-        };
-        const errorMessage = ERROR_MESSAGES[retryData.error] || `Payment failed: ${retryData.error}`;
-        const error = new Error(errorMessage);
-        throw wrapPaymentError(error);
+        const errorMessage = PAYMENT_ERROR_MESSAGES[retryData.error] || `Payment failed: ${retryData.error}`;
+        throw wrapPaymentError(new Error(errorMessage));
       }
     } catch (error) {
       if (error instanceof PaymentOperationError) {