@dexterai/x402 1.0.0

package/dist/client/index.cjs

@@ -0,0 +1,602 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+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/adapters/solana.ts
+function isSolanaWallet(wallet) {
+  if (!wallet || typeof wallet !== "object") return false;
+  const w = wallet;
+  return "publicKey" in w && "signTransaction" in w && typeof w.signTransaction === "function";
+}
+function createSolanaAdapter(config) {
+  return new SolanaAdapter(config);
+}
+var import_web3, import_spl_token, SOLANA_MAINNET, SOLANA_DEVNET, SOLANA_TESTNET, DEFAULT_RPC_URLS, DEFAULT_COMPUTE_UNIT_LIMIT, DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS, SolanaAdapter;
+var init_solana = __esm({
+  "src/adapters/solana.ts"() {
+    "use strict";
+    import_web3 = require("@solana/web3.js");
+    import_spl_token = require("@solana/spl-token");
+    SOLANA_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+    SOLANA_DEVNET = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+    SOLANA_TESTNET = "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
+    DEFAULT_RPC_URLS = {
+      [SOLANA_MAINNET]: "https://api.mainnet-beta.solana.com",
+      [SOLANA_DEVNET]: "https://api.devnet.solana.com",
+      [SOLANA_TESTNET]: "https://api.testnet.solana.com"
+    };
+    DEFAULT_COMPUTE_UNIT_LIMIT = 12e3;
+    DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS = 1;
+    SolanaAdapter = class {
+      name = "Solana";
+      networks = [SOLANA_MAINNET, SOLANA_DEVNET, SOLANA_TESTNET];
+      config;
+      log;
+      constructor(config = {}) {
+        this.config = config;
+        this.log = config.verbose ? console.log.bind(console, "[x402:solana]") : () => {
+        };
+      }
+      canHandle(network) {
+        if (this.networks.includes(network)) return true;
+        if (network === "solana") return true;
+        if (network === "solana-devnet") return true;
+        if (network === "solana-testnet") return true;
+        if (network.startsWith("solana:")) return true;
+        return false;
+      }
+      getDefaultRpcUrl(network) {
+        if (this.config.rpcUrls?.[network]) {
+          return this.config.rpcUrls[network];
+        }
+        if (DEFAULT_RPC_URLS[network]) {
+          return DEFAULT_RPC_URLS[network];
+        }
+        if (network === "solana") return DEFAULT_RPC_URLS[SOLANA_MAINNET];
+        if (network === "solana-devnet") return DEFAULT_RPC_URLS[SOLANA_DEVNET];
+        if (network === "solana-testnet") return DEFAULT_RPC_URLS[SOLANA_TESTNET];
+        return DEFAULT_RPC_URLS[SOLANA_MAINNET];
+      }
+      getAddress(wallet) {
+        if (!isSolanaWallet(wallet)) return null;
+        return wallet.publicKey?.toBase58() ?? null;
+      }
+      isConnected(wallet) {
+        if (!isSolanaWallet(wallet)) return false;
+        return wallet.publicKey !== null;
+      }
+      async getBalance(accept, wallet, rpcUrl) {
+        if (!isSolanaWallet(wallet) || !wallet.publicKey) {
+          return 0;
+        }
+        const url = rpcUrl || this.getDefaultRpcUrl(accept.network);
+        const connection = new import_web3.Connection(url, "confirmed");
+        const userPubkey = new import_web3.PublicKey(wallet.publicKey.toBase58());
+        const mintPubkey = new import_web3.PublicKey(accept.asset);
+        try {
+          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 ata = await (0, import_spl_token.getAssociatedTokenAddress)(
+            mintPubkey,
+            userPubkey,
+            false,
+            programId
+          );
+          const account = await (0, import_spl_token.getAccount)(connection, ata, void 0, programId);
+          const decimals = accept.extra?.decimals ?? 6;
+          return Number(account.amount) / Math.pow(10, decimals);
+        } catch {
+          return 0;
+        }
+      }
+      async buildTransaction(accept, wallet, rpcUrl) {
+        if (!isSolanaWallet(wallet)) {
+          throw new Error("Invalid Solana wallet");
+        }
+        if (!wallet.publicKey) {
+          throw new Error("Wallet not connected");
+        }
+        const url = rpcUrl || this.getDefaultRpcUrl(accept.network);
+        const connection = new import_web3.Connection(url, "confirmed");
+        const userPubkey = new import_web3.PublicKey(wallet.publicKey.toBase58());
+        const { payTo, asset, amount, extra } = accept;
+        if (!extra?.feePayer) {
+          throw new Error("Missing feePayer in payment requirements");
+        }
+        if (typeof extra?.decimals !== "number") {
+          throw new Error("Missing decimals in payment requirements");
+        }
+        const feePayerPubkey = new import_web3.PublicKey(extra.feePayer);
+        const mintPubkey = new import_web3.PublicKey(asset);
+        const destinationPubkey = new import_web3.PublicKey(payTo);
+        this.log("Building transaction:", {
+          from: userPubkey.toBase58(),
+          to: payTo,
+          amount,
+          asset,
+          feePayer: extra.feePayer
+        });
+        const instructions = [];
+        instructions.push(
+          import_web3.ComputeBudgetProgram.setComputeUnitLimit({
+            units: DEFAULT_COMPUTE_UNIT_LIMIT
+          })
+        );
+        instructions.push(
+          import_web3.ComputeBudgetProgram.setComputeUnitPrice({
+            microLamports: DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS
+          })
+        );
+        const mintInfo = await connection.getAccountInfo(mintPubkey, "confirmed");
+        if (!mintInfo) {
+          throw new Error(`Token mint ${asset} not found`);
+        }
+        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);
+        if (mint.decimals !== extra.decimals) {
+          this.log(
+            `Decimals mismatch: requirements say ${extra.decimals}, mint says ${mint.decimals}`
+          );
+        }
+        const sourceAta = await (0, import_spl_token.getAssociatedTokenAddress)(
+          mintPubkey,
+          userPubkey,
+          false,
+          programId
+        );
+        const destinationAta = await (0, import_spl_token.getAssociatedTokenAddress)(
+          mintPubkey,
+          destinationPubkey,
+          false,
+          programId
+        );
+        const sourceAtaInfo = await connection.getAccountInfo(sourceAta, "confirmed");
+        if (!sourceAtaInfo) {
+          throw new Error(
+            `No token account found for ${asset}. Please ensure you have USDC in your wallet.`
+          );
+        }
+        const destAtaInfo = await connection.getAccountInfo(destinationAta, "confirmed");
+        if (!destAtaInfo) {
+          throw new Error(
+            `Seller token account not found. The seller (${payTo}) must have a USDC account.`
+          );
+        }
+        const amountBigInt = BigInt(amount);
+        instructions.push(
+          (0, import_spl_token.createTransferCheckedInstruction)(
+            sourceAta,
+            mintPubkey,
+            destinationAta,
+            userPubkey,
+            amountBigInt,
+            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);
+        const signedTx = await wallet.signTransaction(transaction);
+        this.log("Transaction signed successfully");
+        return {
+          serialized: Buffer.from(signedTx.serialize()).toString("base64")
+        };
+      }
+    };
+  }
+});
+
+// src/adapters/evm.ts
+function isEvmWallet(wallet) {
+  if (!wallet || typeof wallet !== "object") return false;
+  const w = wallet;
+  return "address" in w && typeof w.address === "string" && w.address.startsWith("0x");
+}
+function createEvmAdapter(config) {
+  return new EvmAdapter(config);
+}
+var BASE_MAINNET, BASE_SEPOLIA, ETHEREUM_MAINNET, ARBITRUM_ONE, CHAIN_IDS, DEFAULT_RPC_URLS2, USDC_ADDRESSES, EvmAdapter;
+var init_evm = __esm({
+  "src/adapters/evm.ts"() {
+    "use strict";
+    BASE_MAINNET = "eip155:8453";
+    BASE_SEPOLIA = "eip155:84532";
+    ETHEREUM_MAINNET = "eip155:1";
+    ARBITRUM_ONE = "eip155:42161";
+    CHAIN_IDS = {
+      [BASE_MAINNET]: 8453,
+      [BASE_SEPOLIA]: 84532,
+      [ETHEREUM_MAINNET]: 1,
+      [ARBITRUM_ONE]: 42161
+    };
+    DEFAULT_RPC_URLS2 = {
+      [BASE_MAINNET]: "https://mainnet.base.org",
+      [BASE_SEPOLIA]: "https://sepolia.base.org",
+      [ETHEREUM_MAINNET]: "https://eth.llamarpc.com",
+      [ARBITRUM_ONE]: "https://arb1.arbitrum.io/rpc"
+    };
+    USDC_ADDRESSES = {
+      [BASE_MAINNET]: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+      [ETHEREUM_MAINNET]: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+      [ARBITRUM_ONE]: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831"
+    };
+    EvmAdapter = class {
+      name = "EVM";
+      networks = [BASE_MAINNET, BASE_SEPOLIA, ETHEREUM_MAINNET, ARBITRUM_ONE];
+      config;
+      log;
+      constructor(config = {}) {
+        this.config = config;
+        this.log = config.verbose ? console.log.bind(console, "[x402:evm]") : () => {
+        };
+      }
+      canHandle(network) {
+        if (this.networks.includes(network)) return true;
+        if (network === "base") return true;
+        if (network === "ethereum") return true;
+        if (network === "arbitrum") return true;
+        if (network.startsWith("eip155:")) return true;
+        return false;
+      }
+      getDefaultRpcUrl(network) {
+        if (this.config.rpcUrls?.[network]) {
+          return this.config.rpcUrls[network];
+        }
+        if (DEFAULT_RPC_URLS2[network]) {
+          return DEFAULT_RPC_URLS2[network];
+        }
+        if (network === "base") return DEFAULT_RPC_URLS2[BASE_MAINNET];
+        if (network === "ethereum") return DEFAULT_RPC_URLS2[ETHEREUM_MAINNET];
+        if (network === "arbitrum") return DEFAULT_RPC_URLS2[ARBITRUM_ONE];
+        return DEFAULT_RPC_URLS2[BASE_MAINNET];
+      }
+      getAddress(wallet) {
+        if (!isEvmWallet(wallet)) return null;
+        return wallet.address;
+      }
+      isConnected(wallet) {
+        if (!isEvmWallet(wallet)) return false;
+        return !!wallet.address;
+      }
+      getChainId(network) {
+        if (CHAIN_IDS[network]) return CHAIN_IDS[network];
+        if (network.startsWith("eip155:")) {
+          const chainIdStr = network.split(":")[1];
+          return parseInt(chainIdStr, 10);
+        }
+        if (network === "base") return 8453;
+        if (network === "ethereum") return 1;
+        if (network === "arbitrum") return 42161;
+        return 8453;
+      }
+      async getBalance(accept, wallet, rpcUrl) {
+        if (!isEvmWallet(wallet) || !wallet.address) {
+          return 0;
+        }
+        const url = rpcUrl || this.getDefaultRpcUrl(accept.network);
+        try {
+          const data = this.encodeBalanceOf(wallet.address);
+          const response = await fetch(url, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              jsonrpc: "2.0",
+              id: 1,
+              method: "eth_call",
+              params: [
+                {
+                  to: accept.asset,
+                  data
+                },
+                "latest"
+              ]
+            })
+          });
+          const result = await response.json();
+          if (result.error || !result.result) {
+            return 0;
+          }
+          const balance = BigInt(result.result);
+          const decimals = accept.extra?.decimals ?? 6;
+          return Number(balance) / Math.pow(10, decimals);
+        } catch {
+          return 0;
+        }
+      }
+      encodeBalanceOf(address) {
+        const selector = "0x70a08231";
+        const paddedAddress = address.slice(2).toLowerCase().padStart(64, "0");
+        return selector + paddedAddress;
+      }
+      async buildTransaction(accept, wallet, _rpcUrl) {
+        if (!isEvmWallet(wallet)) {
+          throw new Error("Invalid EVM wallet");
+        }
+        if (!wallet.address) {
+          throw new Error("Wallet not connected");
+        }
+        const { payTo, asset, amount, extra } = accept;
+        this.log("Building EVM transaction:", {
+          from: wallet.address,
+          to: payTo,
+          amount,
+          asset,
+          network: accept.network
+        });
+        const chainId = this.getChainId(accept.network);
+        const domain = {
+          name: extra?.name ?? "USD Coin",
+          version: extra?.version ?? "2",
+          chainId: BigInt(chainId),
+          verifyingContract: 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 nonce = "0x" + [...Array(32)].map(() => Math.floor(Math.random() * 256).toString(16).padStart(2, "0")).join("");
+        const now = Math.floor(Date.now() / 1e3);
+        const authorization = {
+          from: wallet.address,
+          to: payTo,
+          value: amount,
+          // string
+          validAfter: String(now - 600),
+          // 10 minutes before (matching upstream)
+          validBefore: String(now + (accept.maxTimeoutSeconds || 60)),
+          nonce
+        };
+        const message = {
+          from: wallet.address,
+          to: payTo,
+          value: BigInt(amount),
+          validAfter: BigInt(now - 600),
+          validBefore: BigInt(now + (accept.maxTimeoutSeconds || 60)),
+          nonce
+        };
+        if (!wallet.signTypedData) {
+          throw new Error("Wallet does not support signTypedData (EIP-712)");
+        }
+        const signature = await wallet.signTypedData({
+          domain,
+          types,
+          primaryType: "TransferWithAuthorization",
+          message
+        });
+        this.log("EIP-712 signature obtained");
+        const payload = {
+          authorization,
+          signature
+        };
+        return {
+          serialized: JSON.stringify(payload),
+          signature
+        };
+      }
+    };
+  }
+});
+
+// src/client/index.ts
+var client_exports = {};
+__export(client_exports, {
+  BASE_MAINNET: () => BASE_MAINNET,
+  DEXTER_FACILITATOR_URL: () => DEXTER_FACILITATOR_URL,
+  SOLANA_MAINNET: () => SOLANA_MAINNET,
+  USDC_MINT: () => USDC_MINT,
+  X402Error: () => X402Error,
+  createEvmAdapter: () => createEvmAdapter,
+  createSolanaAdapter: () => createSolanaAdapter,
+  createX402Client: () => createX402Client
+});
+module.exports = __toCommonJS(client_exports);
+
+// src/types.ts
+var USDC_MINT = "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v";
+var DEXTER_FACILITATOR_URL = "https://x402.dexter.cash";
+var X402Error = class _X402Error extends Error {
+  /** Error code for programmatic handling */
+  code;
+  /** Additional error details */
+  details;
+  constructor(code, message, details) {
+    super(message);
+    this.name = "X402Error";
+    this.code = code;
+    this.details = details;
+    Object.setPrototypeOf(this, _X402Error.prototype);
+  }
+};
+
+// src/adapters/index.ts
+init_solana();
+init_evm();
+
+// src/client/x402-client.ts
+function createX402Client(config) {
+  const {
+    adapters = [createSolanaAdapter({ verbose: config.verbose }), createEvmAdapter({ verbose: config.verbose })],
+    wallets: walletSet,
+    wallet: legacyWallet,
+    preferredNetwork,
+    rpcUrls = {},
+    maxAmountAtomic,
+    fetch: customFetch = globalThis.fetch,
+    verbose = false
+  } = config;
+  const log = verbose ? console.log.bind(console, "[x402]") : () => {
+  };
+  const wallets = walletSet || {};
+  if (legacyWallet && !wallets.solana && isSolanaWallet(legacyWallet)) {
+    wallets.solana = legacyWallet;
+  }
+  if (legacyWallet && !wallets.evm && isEvmWallet(legacyWallet)) {
+    wallets.evm = legacyWallet;
+  }
+  function findPaymentOption(accepts) {
+    const candidates = [];
+    for (const accept of accepts) {
+      const adapter = adapters.find((a) => a.canHandle(accept.network));
+      if (!adapter) continue;
+      let wallet;
+      if (adapter.name === "Solana") {
+        wallet = wallets.solana;
+      } else if (adapter.name === "EVM") {
+        wallet = wallets.evm;
+      }
+      if (wallet && adapter.isConnected(wallet)) {
+        candidates.push({ accept, adapter, wallet });
+      }
+    }
+    if (candidates.length === 0) {
+      return null;
+    }
+    if (preferredNetwork) {
+      const preferred = candidates.find((c) => c.accept.network === preferredNetwork);
+      if (preferred) return preferred;
+    }
+    return candidates[0];
+  }
+  function getRpcUrl(network, adapter) {
+    return rpcUrls[network] || adapter.getDefaultRpcUrl(network);
+  }
+  async function x402Fetch(input, init) {
+    log("Making request:", input);
+    const response = await customFetch(input, init);
+    if (response.status !== 402) {
+      return response;
+    }
+    log("Received 402 Payment Required");
+    const paymentRequiredHeader = response.headers.get("PAYMENT-REQUIRED");
+    if (!paymentRequiredHeader) {
+      throw new X402Error(
+        "missing_payment_required_header",
+        "Server returned 402 but no PAYMENT-REQUIRED header"
+      );
+    }
+    let requirements;
+    try {
+      const decoded = atob(paymentRequiredHeader);
+      requirements = JSON.parse(decoded);
+    } catch {
+      throw new X402Error(
+        "invalid_payment_required",
+        "Failed to decode PAYMENT-REQUIRED header"
+      );
+    }
+    log("Payment requirements:", requirements);
+    const match = findPaymentOption(requirements.accepts);
+    if (!match) {
+      const availableNetworks = requirements.accepts.map((a) => a.network).join(", ");
+      throw new X402Error(
+        "no_matching_payment_option",
+        `No connected wallet for any available network: ${availableNetworks}`
+      );
+    }
+    const { accept, adapter, wallet } = match;
+    log(`Using ${adapter.name} for ${accept.network}`);
+    if (adapter.name === "Solana" && !accept.extra?.feePayer) {
+      throw new X402Error(
+        "missing_fee_payer",
+        "Solana payment option missing feePayer in extra"
+      );
+    }
+    if (typeof accept.extra?.decimals !== "number") {
+      throw new X402Error(
+        "missing_decimals",
+        "Payment option missing decimals in extra"
+      );
+    }
+    if (maxAmountAtomic && BigInt(accept.amount) > BigInt(maxAmountAtomic)) {
+      throw new X402Error(
+        "amount_exceeds_max",
+        `Payment amount ${accept.amount} exceeds maximum ${maxAmountAtomic}`
+      );
+    }
+    log("Building transaction...");
+    const rpcUrl = getRpcUrl(accept.network, adapter);
+    const signedTx = await adapter.buildTransaction(accept, wallet, rpcUrl);
+    log("Transaction signed");
+    let payload;
+    if (adapter.name === "EVM") {
+      payload = JSON.parse(signedTx.serialized);
+    } else {
+      payload = { transaction: signedTx.serialized };
+    }
+    const paymentSignature = {
+      x402Version: 2,
+      resource: requirements.resource,
+      accepted: accept,
+      payload
+    };
+    const paymentSignatureHeader = btoa(JSON.stringify(paymentSignature));
+    log("Retrying request with payment...");
+    const retryResponse = await customFetch(input, {
+      ...init,
+      headers: {
+        ...init?.headers || {},
+        "PAYMENT-SIGNATURE": paymentSignatureHeader
+      }
+    });
+    log("Retry response status:", retryResponse.status);
+    if (retryResponse.status === 402) {
+      let reason = "unknown";
+      try {
+        const body = await retryResponse.clone().json();
+        reason = String(body.error || body.message || JSON.stringify(body));
+        log("Rejection reason:", reason);
+      } catch {
+      }
+      throw new X402Error(
+        "payment_rejected",
+        `Payment was rejected by the server: ${reason}`
+      );
+    }
+    return retryResponse;
+  }
+  return {
+    fetch: x402Fetch
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  BASE_MAINNET,
+  DEXTER_FACILITATOR_URL,
+  SOLANA_MAINNET,
+  USDC_MINT,
+  X402Error,
+  createEvmAdapter,
+  createSolanaAdapter,
+  createX402Client
+});
+//# sourceMappingURL=index.cjs.map