@voyage_ai/v402-web-ts 0.1.0

package/dist/index.js

@@ -0,0 +1,636 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  EVM_NETWORK_CONFIGS: () => EVM_NETWORK_CONFIGS,
+  EvmNetworkSchema: () => EvmNetworkSchema,
+  EvmPaymentPayloadSchema: () => EvmPaymentPayloadSchema,
+  SolanaNetworkSchema: () => SolanaNetworkSchema,
+  SolanaPaymentPayloadSchema: () => SolanaPaymentPayloadSchema,
+  createEvmPaymentFetch: () => createEvmPaymentFetch,
+  createEvmPaymentHeader: () => createEvmPaymentHeader,
+  createSvmPaymentFetch: () => createSvmPaymentFetch,
+  createSvmPaymentHeader: () => createSvmPaymentHeader,
+  formatAddress: () => formatAddress,
+  fromAtomicUnits: () => fromAtomicUnits,
+  getChainId: () => getChainId,
+  getChainIdFromNetwork: () => getChainIdFromNetwork,
+  getDefaultSolanaRpcUrl: () => getDefaultSolanaRpcUrl,
+  getNetworkDisplayName: () => getNetworkDisplayName,
+  getNetworkType: () => getNetworkType,
+  getWalletDisplayName: () => getWalletDisplayName,
+  getWalletInstallUrl: () => getWalletInstallUrl,
+  getWalletProvider: () => getWalletProvider,
+  handleEvmPayment: () => handleEvmPayment,
+  handleSvmPayment: () => handleSvmPayment,
+  is402Response: () => is402Response,
+  isEvmAddress: () => isEvmAddress,
+  isEvmNetwork: () => isEvmNetwork,
+  isSolanaAddress: () => isSolanaAddress,
+  isSolanaNetwork: () => isSolanaNetwork,
+  isWalletInstalled: () => isWalletInstalled,
+  makePayment: () => makePayment,
+  toAtomicUnits: () => toAtomicUnits
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/types/index.ts
+var import_types3 = require("x402/types");
+
+// src/types/common.ts
+var PROD_BACK_URL = "https://v402.onvoyage.ai/api";
+
+// src/types/svm.ts
+var import_zod = require("zod");
+var import_types = require("x402/types");
+var SolanaNetworkSchema = import_zod.z.enum([
+  "solana-devnet",
+  "solana",
+  "solana-mainnet"
+  // Alias for mainnet
+]);
+var SolanaPaymentPayloadSchema = import_zod.z.object({
+  x402Version: import_zod.z.literal(1),
+  scheme: import_zod.z.literal("exact"),
+  network: SolanaNetworkSchema,
+  payload: import_types.ExactSvmPayloadSchema
+});
+
+// src/types/evm.ts
+var import_zod2 = require("zod");
+var import_types2 = require("x402/types");
+var EvmNetworkSchema = import_zod2.z.enum([
+  "ethereum",
+  "sepolia",
+  "base",
+  "base-sepolia",
+  "polygon",
+  "arbitrum",
+  "optimism"
+]);
+var EvmPaymentPayloadSchema = import_zod2.z.object({
+  x402Version: import_zod2.z.literal(1),
+  scheme: import_zod2.z.literal("exact"),
+  network: EvmNetworkSchema,
+  payload: import_types2.ExactEvmPayloadSchema
+});
+var EVM_NETWORK_CONFIGS = {
+  "ethereum": {
+    chainId: "0x1",
+    chainName: "Ethereum Mainnet",
+    rpcUrls: ["https://eth.llamarpc.com"],
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 }
+  },
+  "sepolia": {
+    chainId: "0xaa36a7",
+    chainName: "Sepolia",
+    rpcUrls: ["https://sepolia.infura.io/v3/"],
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 }
+  },
+  "base": {
+    chainId: "0x2105",
+    chainName: "Base",
+    rpcUrls: ["https://mainnet.base.org"],
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 }
+  },
+  "base-sepolia": {
+    chainId: "0x14a34",
+    chainName: "Base Sepolia",
+    rpcUrls: ["https://sepolia.base.org"],
+    nativeCurrency: { name: "Ether", symbol: "ETH", decimals: 18 }
+  }
+};
+function getChainId(network) {
+  const chainIdMap = {
+    "ethereum": 1,
+    "sepolia": 11155111,
+    "base": 8453,
+    "base-sepolia": 84532,
+    "polygon": 137,
+    "arbitrum": 42161,
+    "optimism": 10
+  };
+  return chainIdMap[network.toLowerCase()] || 1;
+}
+
+// src/services/svm/payment-header.ts
+var import_web3 = require("@solana/web3.js");
+var import_spl_token = require("@solana/spl-token");
+async function createSvmPaymentHeader(params) {
+  const { wallet, paymentRequirements, x402Version, rpcUrl } = params;
+  const connection = new import_web3.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 import_web3.PublicKey(feePayer);
+  const walletAddress = wallet?.publicKey?.toString() || wallet?.address;
+  if (!walletAddress) {
+    throw new Error("Missing connected Solana wallet address or publicKey");
+  }
+  const userPubkey = new import_web3.PublicKey(walletAddress);
+  if (!paymentRequirements?.payTo) {
+    throw new Error("Missing payTo in payment requirements");
+  }
+  const destination = new import_web3.PublicKey(paymentRequirements.payTo);
+  const instructions = [];
+  instructions.push(
+    import_web3.ComputeBudgetProgram.setComputeUnitLimit({
+      units: 7e3
+      // Sufficient for SPL token transfer
+    })
+  );
+  instructions.push(
+    import_web3.ComputeBudgetProgram.setComputeUnitPrice({
+      microLamports: 1
+      // Minimal price
+    })
+  );
+  if (!paymentRequirements.asset) {
+    throw new Error("Missing token mint for SPL transfer");
+  }
+  const mintPubkey = new import_web3.PublicKey(paymentRequirements.asset);
+  const mintInfo = await connection.getAccountInfo(mintPubkey, "confirmed");
+  const programId = mintInfo?.owner?.toBase58() === import_spl_token.TOKEN_2022_PROGRAM_ID.toBase58() ? import_spl_token.TOKEN_2022_PROGRAM_ID : import_spl_token.TOKEN_PROGRAM_ID;
+  const mint = await (0, import_spl_token.getMint)(connection, mintPubkey, void 0, programId);
+  const sourceAta = await (0, import_spl_token.getAssociatedTokenAddress)(
+    mintPubkey,
+    userPubkey,
+    false,
+    programId
+  );
+  const destinationAta = await (0, import_spl_token.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(
+    (0, import_spl_token.createTransferCheckedInstruction)(
+      sourceAta,
+      mintPubkey,
+      destinationAta,
+      userPubkey,
+      amount,
+      mint.decimals,
+      [],
+      programId
+    )
+  );
+  const { blockhash } = await connection.getLatestBlockhash("confirmed");
+  const message = new import_web3.TransactionMessage({
+    payerKey: feePayerPubkey,
+    recentBlockhash: blockhash,
+    instructions
+  }).compileToV0Message();
+  const transaction = new import_web3.VersionedTransaction(message);
+  if (typeof wallet?.signTransaction !== "function") {
+    throw new Error("Connected wallet does not support signTransaction");
+  }
+  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";
+  }
+  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 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(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);
+  };
+}
+
+// src/services/evm/payment-header.ts
+var import_ethers = require("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");
+  }
+  const now = Math.floor(Date.now() / 1e3);
+  const nonceBytes = import_ethers.ethers.randomBytes(32);
+  const nonceBytes32 = import_ethers.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
+  };
+  const signature = await wallet.signTypedData(domain, types, authorization);
+  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 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);
+  if (wallet.switchChain) {
+    try {
+      await wallet.switchChain(`0x${targetChainId.toString(16)}`);
+    } catch (error) {
+      console.warn("Failed to switch chain:", error);
+    }
+  }
+  const paymentHeader = await createEvmPaymentHeader({
+    wallet,
+    paymentRequirements: selectedRequirements,
+    x402Version,
+    chainId: targetChainId
+  });
+  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 createEvmPaymentFetch(config) {
+  return async (input, init) => {
+    const endpoint = typeof input === "string" ? input : input instanceof URL ? input.href : input.url;
+    return handleEvmPayment(endpoint, config, init);
+  };
+}
+
+// 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
+var import_ethers2 = require("ethers");
+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-devnet"
+    });
+  } else if (networkType === "evm" /* EVM */) {
+    if (!window.ethereum) {
+      throw new Error("\u8BF7\u5B89\u88C5 MetaMask \u94B1\u5305");
+    }
+    const provider = new import_ethers2.ethers.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);
+      }
+    };
+    const network = endpoint.includes("sepolia") ? "base-sepolia" : "base";
+    response = await handleEvmPayment(endpoint, {
+      wallet,
+      network
+    });
+  } else {
+    throw new Error(`\u4E0D\u652F\u6301\u7684\u7F51\u7EDC\u7C7B\u578B: ${networkType}`);
+  }
+  return response;
+}
+
+// src/utils/network.ts
+var NETWORK_TYPE_MAP = {
+  // EVM chains
+  "ethereum": "evm" /* EVM */,
+  "eth": "evm" /* EVM */,
+  "base": "evm" /* EVM */,
+  "base-sepolia": "evm" /* EVM */,
+  "polygon": "evm" /* EVM */,
+  "arbitrum": "evm" /* EVM */,
+  "optimism": "evm" /* EVM */,
+  "bsc": "evm" /* EVM */,
+  "sepolia": "evm" /* EVM */,
+  "goerli": "evm" /* EVM */,
+  // Solana/SVM
+  "solana": "solana" /* SOLANA */,
+  "solana-devnet": "solana" /* SOLANA */,
+  "solana-testnet": "solana" /* SOLANA */,
+  "solana-mainnet": "solana" /* SOLANA */,
+  "svm": "svm" /* SVM */
+};
+function getNetworkType(network) {
+  const normalizedNetwork = network.toLowerCase().trim();
+  return NETWORK_TYPE_MAP[normalizedNetwork] || "unknown" /* UNKNOWN */;
+}
+function isEvmNetwork(network) {
+  return getNetworkType(network) === "evm" /* EVM */;
+}
+function isSolanaNetwork(network) {
+  const type = getNetworkType(network);
+  return type === "solana" /* SOLANA */ || type === "svm" /* SVM */;
+}
+function isSolanaAddress(address) {
+  if (address.startsWith("0x")) {
+    return false;
+  }
+  const base58Regex = /^[1-9A-HJ-NP-Za-km-z]+$/;
+  return base58Regex.test(address) && address.length >= 32 && address.length <= 44;
+}
+function isEvmAddress(address) {
+  return /^0x[a-fA-F0-9]{40}$/.test(address);
+}
+function getNetworkDisplayName(network) {
+  const displayNames = {
+    "ethereum": "Ethereum",
+    "sepolia": "Sepolia Testnet",
+    "base": "Base",
+    "base-sepolia": "Base Sepolia",
+    "polygon": "Polygon",
+    "arbitrum": "Arbitrum",
+    "optimism": "Optimism",
+    "solana": "Solana",
+    "solana-devnet": "Solana Devnet",
+    "solana-mainnet": "Solana Mainnet"
+  };
+  return displayNames[network.toLowerCase()] || network;
+}
+
+// src/utils/helpers.ts
+function toAtomicUnits(amount, decimals) {
+  return BigInt(Math.floor(amount * Math.pow(10, decimals)));
+}
+function fromAtomicUnits(atomicUnits, decimals) {
+  return Number(atomicUnits) / Math.pow(10, decimals);
+}
+function is402Response(response) {
+  return response && typeof response === "object" && "x402Version" in response && "accepts" in response && Array.isArray(response.accepts);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EVM_NETWORK_CONFIGS,
+  EvmNetworkSchema,
+  EvmPaymentPayloadSchema,
+  SolanaNetworkSchema,
+  SolanaPaymentPayloadSchema,
+  createEvmPaymentFetch,
+  createEvmPaymentHeader,
+  createSvmPaymentFetch,
+  createSvmPaymentHeader,
+  formatAddress,
+  fromAtomicUnits,
+  getChainId,
+  getChainIdFromNetwork,
+  getDefaultSolanaRpcUrl,
+  getNetworkDisplayName,
+  getNetworkType,
+  getWalletDisplayName,
+  getWalletInstallUrl,
+  getWalletProvider,
+  handleEvmPayment,
+  handleSvmPayment,
+  is402Response,
+  isEvmAddress,
+  isEvmNetwork,
+  isSolanaAddress,
+  isSolanaNetwork,
+  isWalletInstalled,
+  makePayment,
+  toAtomicUnits
+});
+//# sourceMappingURL=index.js.map