@voyage_ai/v402-web-ts 0.1.0 → 0.1.1

package/dist/index.mjs

@@ -13,7 +13,7 @@ import {
 } from "x402/types";
 
 // src/types/common.ts
-var PROD_BACK_URL = "https://v402.onvoyage.ai/api";
+var PROD_BACK_URL = "https://v402.onvoyage.ai/api/pay";
 
 // src/types/svm.ts
 import { z } from "zod";
@@ -103,166 +103,63 @@ 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");
+
+// src/utils/wallet.ts
+function isWalletInstalled(networkType) {
+  if (typeof window === "undefined") {
+    return false;
   }
-  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.`
-    );
+  switch (networkType) {
+    case "evm" /* EVM */:
+      return !!window.ethereum;
+    case "solana" /* SOLANA */:
+    case "svm" /* SVM */:
+      return !!window.solana || !!window.phantom;
+    default:
+      return false;
   }
-  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.`
-    );
+}
+function getWalletProvider(networkType) {
+  if (typeof window === "undefined") {
+    return null;
   }
-  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");
+  switch (networkType) {
+    case "evm" /* EVM */:
+      return window.ethereum;
+    case "solana" /* SOLANA */:
+    case "svm" /* SVM */:
+      return window.solana || window.phantom;
+    default:
+      return null;
   }
-  const userSignedTx = await wallet.signTransaction(transaction);
-  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://api.mainnet-beta.solana.com";
-  } else if (normalized === "solana-devnet") {
-    return "https://api.devnet.solana.com";
+function formatAddress(address) {
+  if (!address || address.length < 10) {
+    return address;
   }
-  throw new Error(`Unsupported Solana network: ${network}`);
+  return `${address.slice(0, 6)}...${address.slice(-4)}`;
 }
-
-// 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 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}`
-      );
-    }
+function getWalletInstallUrl(networkType) {
+  switch (networkType) {
+    case "evm" /* EVM */:
+      return "https://metamask.io/download/";
+    case "solana" /* SOLANA */:
+    case "svm" /* SVM */:
+      return "https://phantom.app/download";
+    default:
+      return "#";
   }
-  const effectiveRpcUrl = rpcUrl || getDefaultSolanaRpcUrl(network);
-  const paymentHeader = await createSvmPaymentHeader({
-    wallet,
-    paymentRequirements: selectedRequirements,
-    x402Version,
-    rpcUrl: effectiveRpcUrl
-  });
-  const newInit = {
-    ...requestInit,
-    method: requestInit?.method || "POST",
-    headers: {
-      ...requestInit?.headers || {},
-      "X-PAYMENT": paymentHeader,
-      "Access-Control-Expose-Headers": "X-PAYMENT-RESPONSE"
-    }
-  };
-  return await fetch(endpoint, newInit);
 }
-function createSvmPaymentFetch(config) {
-  return async (input, init) => {
-    const endpoint = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
-    return handleSvmPayment(endpoint, config, init);
-  };
+function getWalletDisplayName(networkType) {
+  switch (networkType) {
+    case "evm" /* EVM */:
+      return "MetaMask";
+    case "solana" /* SOLANA */:
+    case "svm" /* SVM */:
+      return "Phantom";
+    default:
+      return "Unknown Wallet";
+  }
 }
 
 // src/services/evm/payment-header.ts
@@ -275,6 +172,34 @@ async function createEvmPaymentHeader(params) {
   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);
@@ -303,7 +228,14 @@ async function createEvmPaymentHeader(params) {
     validBefore: String(now + (paymentRequirements.maxTimeoutSeconds || 3600)),
     nonce: nonceBytes32
   };
-  const signature = await wallet.signTypedData(domain, types, authorization);
+  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,
@@ -354,6 +286,26 @@ 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)) {
+    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(
@@ -374,19 +326,81 @@ async function handleEvmPayment(endpoint, config, requestInit) {
     }
   }
   const targetChainId = getChainIdFromNetwork(selectedRequirements.network);
-  if (wallet.switchChain) {
+  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.warn("Failed to switch chain:", 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);
     }
   }
-  const paymentHeader = await createEvmPaymentHeader({
-    wallet,
-    paymentRequirements: selectedRequirements,
-    x402Version,
-    chainId: targetChainId
-  });
+  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",
@@ -396,7 +410,38 @@ async function handleEvmPayment(endpoint, config, requestInit) {
       "Access-Control-Expose-Headers": "X-PAYMENT-RESPONSE"
     }
   };
-  return await fetch(endpoint, newInit);
+  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;
 }
 function createEvmPaymentFetch(config) {
   return async (input, init) => {
@@ -405,64 +450,6 @@ function createEvmPaymentFetch(config) {
   };
 }
 
-// src/utils/wallet.ts
-function isWalletInstalled(networkType) {
-  if (typeof window === "undefined") {
-    return false;
-  }
-  switch (networkType) {
-    case "evm" /* EVM */:
-      return !!window.ethereum;
-    case "solana" /* SOLANA */:
-    case "svm" /* SVM */:
-      return !!window.solana || !!window.phantom;
-    default:
-      return false;
-  }
-}
-function getWalletProvider(networkType) {
-  if (typeof window === "undefined") {
-    return null;
-  }
-  switch (networkType) {
-    case "evm" /* EVM */:
-      return window.ethereum;
-    case "solana" /* SOLANA */:
-    case "svm" /* SVM */:
-      return window.solana || window.phantom;
-    default:
-      return null;
-  }
-}
-function formatAddress(address) {
-  if (!address || address.length < 10) {
-    return address;
-  }
-  return `${address.slice(0, 6)}...${address.slice(-4)}`;
-}
-function getWalletInstallUrl(networkType) {
-  switch (networkType) {
-    case "evm" /* EVM */:
-      return "https://metamask.io/download/";
-    case "solana" /* SOLANA */:
-    case "svm" /* SVM */:
-      return "https://phantom.app/download";
-    default:
-      return "#";
-  }
-}
-function getWalletDisplayName(networkType) {
-  switch (networkType) {
-    case "evm" /* EVM */:
-      return "MetaMask";
-    case "solana" /* SOLANA */:
-    case "svm" /* SVM */:
-      return "Phantom";
-    default:
-      return "Unknown Wallet";
-  }
-}
-
 // src/utils/payment-helpers.ts
 import { ethers as ethers2 } from "ethers";
 async function makePayment(networkType, merchantId, endpoint = PROD_BACK_URL) {
@@ -478,7 +465,8 @@ async function makePayment(networkType, merchantId, endpoint = PROD_BACK_URL) {
     }
     response = await handleSvmPayment(endpoint, {
       wallet: solana,
-      network: "solana-devnet"
+      network: "solana"
+      // Will use backend's network configuration
     });
   } else if (networkType === "evm" /* EVM */) {
     if (!window.ethereum) {
@@ -490,12 +478,24 @@ async function makePayment(networkType, merchantId, endpoint = PROD_BACK_URL) {
       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 }]
+        });
       }
     };
-    const network = endpoint.includes("sepolia") ? "base-sepolia" : "base";
     response = await handleEvmPayment(endpoint, {
       wallet,
-      network
+      network: "base"
+      // Will use backend's network configuration
     });
   } else {
     throw new Error(`\u4E0D\u652F\u6301\u7684\u7F51\u7EDC\u7C7B\u578B: ${networkType}`);
@@ -570,6 +570,368 @@ function fromAtomicUnits(atomicUnits, decimals) {
 function is402Response(response) {
   return response && typeof response === "object" && "x402Version" in response && "accepts" in response && Array.isArray(response.accepts);
 }
+
+// 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/services/svm/payment-header.ts
+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;
+}
+function createSvmPaymentFetch(config) {
+  return async (input, init) => {
+    const endpoint = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    return handleSvmPayment(endpoint, config, init);
+  };
+}
 export {
   EVM_NETWORK_CONFIGS,
   EvmNetworkSchema,