@dexterai/x402 1.7.2 → 1.8.1

package/dist/client/index.js

@@ -1,9 +1,180 @@
+var __defProp = Object.defineProperty;
 var __getOwnPropNames = Object.getOwnPropertyNames;
 var __esm = (fn, res) => function __init() {
   return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
 };
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// node_modules/base-x/src/esm/index.js
+function base(ALPHABET2) {
+  if (ALPHABET2.length >= 255) {
+    throw new TypeError("Alphabet too long");
+  }
+  const BASE_MAP = new Uint8Array(256);
+  for (let j = 0; j < BASE_MAP.length; j++) {
+    BASE_MAP[j] = 255;
+  }
+  for (let i = 0; i < ALPHABET2.length; i++) {
+    const x = ALPHABET2.charAt(i);
+    const xc = x.charCodeAt(0);
+    if (BASE_MAP[xc] !== 255) {
+      throw new TypeError(x + " is ambiguous");
+    }
+    BASE_MAP[xc] = i;
+  }
+  const BASE = ALPHABET2.length;
+  const LEADER = ALPHABET2.charAt(0);
+  const FACTOR = Math.log(BASE) / Math.log(256);
+  const iFACTOR = Math.log(256) / Math.log(BASE);
+  function encode(source) {
+    if (source instanceof Uint8Array) {
+    } else if (ArrayBuffer.isView(source)) {
+      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
+    } else if (Array.isArray(source)) {
+      source = Uint8Array.from(source);
+    }
+    if (!(source instanceof Uint8Array)) {
+      throw new TypeError("Expected Uint8Array");
+    }
+    if (source.length === 0) {
+      return "";
+    }
+    let zeroes = 0;
+    let length = 0;
+    let pbegin = 0;
+    const pend = source.length;
+    while (pbegin !== pend && source[pbegin] === 0) {
+      pbegin++;
+      zeroes++;
+    }
+    const size = (pend - pbegin) * iFACTOR + 1 >>> 0;
+    const b58 = new Uint8Array(size);
+    while (pbegin !== pend) {
+      let carry = source[pbegin];
+      let i = 0;
+      for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
+        carry += 256 * b58[it1] >>> 0;
+        b58[it1] = carry % BASE >>> 0;
+        carry = carry / BASE >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i;
+      pbegin++;
+    }
+    let it2 = size - length;
+    while (it2 !== size && b58[it2] === 0) {
+      it2++;
+    }
+    let str = LEADER.repeat(zeroes);
+    for (; it2 < size; ++it2) {
+      str += ALPHABET2.charAt(b58[it2]);
+    }
+    return str;
+  }
+  function decodeUnsafe(source) {
+    if (typeof source !== "string") {
+      throw new TypeError("Expected String");
+    }
+    if (source.length === 0) {
+      return new Uint8Array();
+    }
+    let psz = 0;
+    let zeroes = 0;
+    let length = 0;
+    while (source[psz] === LEADER) {
+      zeroes++;
+      psz++;
+    }
+    const size = (source.length - psz) * FACTOR + 1 >>> 0;
+    const b256 = new Uint8Array(size);
+    while (psz < source.length) {
+      const charCode = source.charCodeAt(psz);
+      if (charCode > 255) {
+        return;
+      }
+      let carry = BASE_MAP[charCode];
+      if (carry === 255) {
+        return;
+      }
+      let i = 0;
+      for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
+        carry += BASE * b256[it3] >>> 0;
+        b256[it3] = carry % 256 >>> 0;
+        carry = carry / 256 >>> 0;
+      }
+      if (carry !== 0) {
+        throw new Error("Non-zero carry");
+      }
+      length = i;
+      psz++;
+    }
+    let it4 = size - length;
+    while (it4 !== size && b256[it4] === 0) {
+      it4++;
+    }
+    const vch = new Uint8Array(zeroes + (size - it4));
+    let j = zeroes;
+    while (it4 !== size) {
+      vch[j++] = b256[it4++];
+    }
+    return vch;
+  }
+  function decode(string) {
+    const buffer = decodeUnsafe(string);
+    if (buffer) {
+      return buffer;
+    }
+    throw new Error("Non-base" + BASE + " character");
+  }
+  return {
+    encode,
+    decodeUnsafe,
+    decode
+  };
+}
+var esm_default;
+var init_esm = __esm({
+  "node_modules/base-x/src/esm/index.js"() {
+    "use strict";
+    esm_default = base;
+  }
+});
+
+// node_modules/bs58/src/esm/index.js
+var esm_exports = {};
+__export(esm_exports, {
+  default: () => esm_default2
+});
+var ALPHABET, esm_default2;
+var init_esm2 = __esm({
+  "node_modules/bs58/src/esm/index.js"() {
+    "use strict";
+    init_esm();
+    ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    esm_default2 = esm_default(ALPHABET);
+  }
+});
+
+// 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/solana.ts
@@ -22,568 +193,420 @@ import {
   TOKEN_PROGRAM_ID,
   TOKEN_2022_PROGRAM_ID
 } from "@solana/spl-token";
+var SOLANA_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
+var SOLANA_DEVNET = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
+var SOLANA_TESTNET = "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
+var DEFAULT_RPC_URLS = {
+  [SOLANA_MAINNET]: "https://api.dexter.cash/api/solana/rpc",
+  [SOLANA_DEVNET]: "https://api.devnet.solana.com",
+  [SOLANA_TESTNET]: "https://api.testnet.solana.com"
+};
+var DEFAULT_COMPUTE_UNIT_LIMIT = 12e3;
+var DEFAULT_COMPUTE_UNIT_PRICE_MICROLAMPORTS = 1;
 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 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";
-    SOLANA_MAINNET = "solana:5eykt4UsFv8P8NJdTREpY1vzqKqZKvdp";
-    SOLANA_DEVNET = "solana:EtWTRABZaYq6iMfeYKouRu166VU2xqa1";
-    SOLANA_TESTNET = "solana:4uhcVJyU9pJkvQyS88uRDiswHXSCkY3z";
-    DEFAULT_RPC_URLS = {
-      [SOLANA_MAINNET]: "https://api.dexter.cash/api/solana/rpc",
-      [SOLANA_DEVNET]: "https://api.devnet.solana.com",
-      [SOLANA_TESTNET]: "https://api.testnet.solana.com"
+var 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]") : () => {
     };
-    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 Connection(url, "confirmed");
-        const userPubkey = new PublicKey(wallet.publicKey.toBase58());
-        const mintPubkey = new PublicKey(accept.asset);
-        try {
-          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 ata = await getAssociatedTokenAddress(
-            mintPubkey,
-            userPubkey,
-            false,
-            programId
-          );
-          const account = await 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 Connection(url, "confirmed");
-        const userPubkey = new PublicKey(wallet.publicKey.toBase58());
-        const { payTo, asset, extra } = accept;
-        const amount = accept.amount || accept.maxAmountRequired;
-        if (!amount) {
-          throw new Error("Missing amount in payment requirements");
-        }
-        if (!extra?.feePayer) {
-          throw new Error("Missing feePayer in payment requirements");
-        }
-        const feePayerPubkey = new PublicKey(extra.feePayer);
-        const mintPubkey = new PublicKey(asset);
-        const destinationPubkey = new PublicKey(payTo);
-        this.log("Building transaction:", {
-          from: userPubkey.toBase58(),
-          to: payTo,
-          amount,
-          asset,
-          feePayer: extra.feePayer
-        });
-        const instructions = [];
-        instructions.push(
-          ComputeBudgetProgram.setComputeUnitLimit({
-            units: DEFAULT_COMPUTE_UNIT_LIMIT
-          })
-        );
-        instructions.push(
-          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() === TOKEN_2022_PROGRAM_ID.toBase58() ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
-        const mint = await getMint(connection, mintPubkey, void 0, programId);
-        if (typeof extra?.decimals === "number" && mint.decimals !== extra.decimals) {
-          this.log(
-            `Decimals mismatch: requirements say ${extra.decimals}, mint says ${mint.decimals}`
-          );
-        }
-        const sourceAta = await getAssociatedTokenAddress(
-          mintPubkey,
-          userPubkey,
-          false,
-          programId
-        );
-        const destinationAta = await 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(
-          createTransferCheckedInstruction(
-            sourceAta,
-            mintPubkey,
-            destinationAta,
-            userPubkey,
-            amountBigInt,
-            mint.decimals,
-            [],
-            programId
-          )
-        );
-        const { blockhash } = await connection.getLatestBlockhash("confirmed");
-        const message = new TransactionMessage({
-          payerKey: feePayerPubkey,
-          recentBlockhash: blockhash,
-          instructions
-        }).compileToV0Message();
-        const transaction = new VersionedTransaction(message);
-        const signedTx = await wallet.signTransaction(transaction);
-        this.log("Transaction signed successfully");
-        return {
-          serialized: Buffer.from(signedTx.serialize()).toString("base64")
-        };
-      }
+  }
+  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 Connection(url, "confirmed");
+    const userPubkey = new PublicKey(wallet.publicKey.toBase58());
+    const mintPubkey = new PublicKey(accept.asset);
+    try {
+      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 ata = await getAssociatedTokenAddress(
+        mintPubkey,
+        userPubkey,
+        false,
+        programId
+      );
+      const account = await 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 Connection(url, "confirmed");
+    const userPubkey = new PublicKey(wallet.publicKey.toBase58());
+    const { payTo, asset, extra } = accept;
+    const amount = accept.amount || accept.maxAmountRequired;
+    if (!amount) {
+      throw new Error("Missing amount in payment requirements");
+    }
+    if (!extra?.feePayer) {
+      throw new Error("Missing feePayer in payment requirements");
+    }
+    const feePayerPubkey = new PublicKey(extra.feePayer);
+    const mintPubkey = new PublicKey(asset);
+    const destinationPubkey = new PublicKey(payTo);
+    this.log("Building transaction:", {
+      from: userPubkey.toBase58(),
+      to: payTo,
+      amount,
+      asset,
+      feePayer: extra.feePayer
+    });
+    const instructions = [];
+    instructions.push(
+      ComputeBudgetProgram.setComputeUnitLimit({
+        units: DEFAULT_COMPUTE_UNIT_LIMIT
+      })
+    );
+    instructions.push(
+      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() === TOKEN_2022_PROGRAM_ID.toBase58() ? TOKEN_2022_PROGRAM_ID : TOKEN_PROGRAM_ID;
+    const mint = await getMint(connection, mintPubkey, void 0, programId);
+    if (typeof extra?.decimals === "number" && mint.decimals !== extra.decimals) {
+      this.log(
+        `Decimals mismatch: requirements say ${extra.decimals}, mint says ${mint.decimals}`
+      );
+    }
+    const sourceAta = await getAssociatedTokenAddress(
+      mintPubkey,
+      userPubkey,
+      false,
+      programId
+    );
+    const destinationAta = await 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(
+      createTransferCheckedInstruction(
+        sourceAta,
+        mintPubkey,
+        destinationAta,
+        userPubkey,
+        amountBigInt,
+        mint.decimals,
+        [],
+        programId
+      )
+    );
+    const { blockhash } = await connection.getLatestBlockhash("confirmed");
+    const message = new TransactionMessage({
+      payerKey: feePayerPubkey,
+      recentBlockhash: blockhash,
+      instructions
+    }).compileToV0Message();
+    const transaction = new VersionedTransaction(message);
+    const signedTx = await wallet.signTransaction(transaction);
+    this.log("Transaction signed successfully");
+    return {
+      serialized: Buffer.from(signedTx.serialize()).toString("base64")
     };
   }
-});
+};
+function createSolanaAdapter(config) {
+  return new SolanaAdapter(config);
+}
 
 // src/adapters/evm.ts
+var BASE_MAINNET = "eip155:8453";
+var BASE_SEPOLIA = "eip155:84532";
+var ARBITRUM_ONE = "eip155:42161";
+var POLYGON = "eip155:137";
+var OPTIMISM = "eip155:10";
+var AVALANCHE = "eip155:43114";
+var SKALE_BASE = "eip155:1187947933";
+var SKALE_BASE_SEPOLIA = "eip155:324705682";
+var ETHEREUM_MAINNET = "eip155:1";
+var CHAIN_IDS = {
+  [BASE_MAINNET]: 8453,
+  [BASE_SEPOLIA]: 84532,
+  [ARBITRUM_ONE]: 42161,
+  [POLYGON]: 137,
+  [OPTIMISM]: 10,
+  [AVALANCHE]: 43114,
+  [SKALE_BASE]: 1187947933,
+  [SKALE_BASE_SEPOLIA]: 324705682,
+  [ETHEREUM_MAINNET]: 1
+};
+var DEFAULT_RPC_URLS2 = {
+  [BASE_MAINNET]: "https://api.dexter.cash/api/base/rpc",
+  [BASE_SEPOLIA]: "https://sepolia.base.org",
+  [ARBITRUM_ONE]: "https://arb1.arbitrum.io/rpc",
+  [POLYGON]: "https://polygon-rpc.com",
+  [OPTIMISM]: "https://mainnet.optimism.io",
+  [AVALANCHE]: "https://api.avax.network/ext/bc/C/rpc",
+  [SKALE_BASE]: "https://skale-base.skalenodes.com/v1/base",
+  [SKALE_BASE_SEPOLIA]: "https://base-sepolia-testnet.skalenodes.com/v1/jubilant-horrible-ancha",
+  [ETHEREUM_MAINNET]: "https://eth.llamarpc.com"
+};
+var USDC_ADDRESSES = {
+  [BASE_MAINNET]: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+  [BASE_SEPOLIA]: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+  [ARBITRUM_ONE]: "0xaf88d065e77c8cC2239327C5EDb3A432268e5831",
+  [POLYGON]: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+  [OPTIMISM]: "0x0b2C639c533813f4Aa9D7837CAf62653d097Ff85",
+  [AVALANCHE]: "0xB97EF9Ef8734C71904D8002F8b6Bc66Dd9c48a6E",
+  [SKALE_BASE]: "0x85889c8c714505E0c94b30fcfcF64fE3Ac8FCb20",
+  [SKALE_BASE_SEPOLIA]: "0x2e08028E3C4c2356572E096d8EF835cD5C6030bD",
+  [ETHEREUM_MAINNET]: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48"
+};
 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://api.dexter.cash/api/base/rpc",
-      [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, extra } = accept;
-        const amount = accept.amount || accept.maxAmountRequired;
-        if (!amount) {
-          throw new Error("Missing amount in payment requirements");
-        }
-        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
-        };
-      }
+var 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]") : () => {
     };
   }
-});
-
-// node_modules/base-x/src/cjs/index.cjs
-var require_cjs = __commonJS({
-  "node_modules/base-x/src/cjs/index.cjs"(exports) {
-    "use strict";
-    Object.defineProperty(exports, "__esModule", { value: true });
-    function base(ALPHABET) {
-      if (ALPHABET.length >= 255) {
-        throw new TypeError("Alphabet too long");
-      }
-      const BASE_MAP = new Uint8Array(256);
-      for (let j = 0; j < BASE_MAP.length; j++) {
-        BASE_MAP[j] = 255;
-      }
-      for (let i = 0; i < ALPHABET.length; i++) {
-        const x = ALPHABET.charAt(i);
-        const xc = x.charCodeAt(0);
-        if (BASE_MAP[xc] !== 255) {
-          throw new TypeError(x + " is ambiguous");
-        }
-        BASE_MAP[xc] = i;
-      }
-      const BASE = ALPHABET.length;
-      const LEADER = ALPHABET.charAt(0);
-      const FACTOR = Math.log(BASE) / Math.log(256);
-      const iFACTOR = Math.log(256) / Math.log(BASE);
-      function encode(source) {
-        if (source instanceof Uint8Array) {
-        } else if (ArrayBuffer.isView(source)) {
-          source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-        } else if (Array.isArray(source)) {
-          source = Uint8Array.from(source);
-        }
-        if (!(source instanceof Uint8Array)) {
-          throw new TypeError("Expected Uint8Array");
-        }
-        if (source.length === 0) {
-          return "";
-        }
-        let zeroes = 0;
-        let length = 0;
-        let pbegin = 0;
-        const pend = source.length;
-        while (pbegin !== pend && source[pbegin] === 0) {
-          pbegin++;
-          zeroes++;
-        }
-        const size = (pend - pbegin) * iFACTOR + 1 >>> 0;
-        const b58 = new Uint8Array(size);
-        while (pbegin !== pend) {
-          let carry = source[pbegin];
-          let i = 0;
-          for (let it1 = size - 1; (carry !== 0 || i < length) && it1 !== -1; it1--, i++) {
-            carry += 256 * b58[it1] >>> 0;
-            b58[it1] = carry % BASE >>> 0;
-            carry = carry / BASE >>> 0;
-          }
-          if (carry !== 0) {
-            throw new Error("Non-zero carry");
-          }
-          length = i;
-          pbegin++;
-        }
-        let it2 = size - length;
-        while (it2 !== size && b58[it2] === 0) {
-          it2++;
-        }
-        let str = LEADER.repeat(zeroes);
-        for (; it2 < size; ++it2) {
-          str += ALPHABET.charAt(b58[it2]);
-        }
-        return str;
-      }
-      function decodeUnsafe(source) {
-        if (typeof source !== "string") {
-          throw new TypeError("Expected String");
-        }
-        if (source.length === 0) {
-          return new Uint8Array();
-        }
-        let psz = 0;
-        let zeroes = 0;
-        let length = 0;
-        while (source[psz] === LEADER) {
-          zeroes++;
-          psz++;
-        }
-        const size = (source.length - psz) * FACTOR + 1 >>> 0;
-        const b256 = new Uint8Array(size);
-        while (psz < source.length) {
-          const charCode = source.charCodeAt(psz);
-          if (charCode > 255) {
-            return;
-          }
-          let carry = BASE_MAP[charCode];
-          if (carry === 255) {
-            return;
-          }
-          let i = 0;
-          for (let it3 = size - 1; (carry !== 0 || i < length) && it3 !== -1; it3--, i++) {
-            carry += BASE * b256[it3] >>> 0;
-            b256[it3] = carry % 256 >>> 0;
-            carry = carry / 256 >>> 0;
-          }
-          if (carry !== 0) {
-            throw new Error("Non-zero carry");
-          }
-          length = i;
-          psz++;
-        }
-        let it4 = size - length;
-        while (it4 !== size && b256[it4] === 0) {
-          it4++;
-        }
-        const vch = new Uint8Array(zeroes + (size - it4));
-        let j = zeroes;
-        while (it4 !== size) {
-          vch[j++] = b256[it4++];
-        }
-        return vch;
-      }
-      function decode(string) {
-        const buffer = decodeUnsafe(string);
-        if (buffer) {
-          return buffer;
-        }
-        throw new Error("Non-base" + BASE + " character");
+  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;
       }
-      return {
-        encode,
-        decodeUnsafe,
-        decode
-      };
+      const balance = BigInt(result.result);
+      const decimals = accept.extra?.decimals ?? 6;
+      return Number(balance) / Math.pow(10, decimals);
+    } catch {
+      return 0;
     }
-    exports.default = base;
   }
-});
-
-// node_modules/bs58/src/cjs/index.cjs
-var require_cjs2 = __commonJS({
-  "node_modules/bs58/src/cjs/index.cjs"(exports) {
-    "use strict";
-    var __importDefault = exports && exports.__importDefault || function(mod) {
-      return mod && mod.__esModule ? mod : { "default": mod };
-    };
-    Object.defineProperty(exports, "__esModule", { value: true });
-    var base_x_1 = __importDefault(require_cjs());
-    var ALPHABET = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
-    exports.default = (0, base_x_1.default)(ALPHABET);
+  encodeBalanceOf(address) {
+    const selector = "0x70a08231";
+    const paddedAddress = address.slice(2).toLowerCase().padStart(64, "0");
+    return selector + paddedAddress;
   }
-});
-
-// 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);
+  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, extra } = accept;
+    const amount = accept.amount || accept.maxAmountRequired;
+    if (!amount) {
+      throw new Error("Missing amount in payment requirements");
+    }
+    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
+    };
   }
 };
+function createEvmAdapter(config) {
+  return new EvmAdapter(config);
+}
 
 // src/adapters/index.ts
-init_solana();
-init_evm();
+function isKnownUSDC(asset) {
+  if (asset === "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v") return true;
+  if (asset === "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU") return true;
+  const lc = asset.toLowerCase();
+  for (const addr of Object.values(USDC_ADDRESSES)) {
+    if (addr.toLowerCase() === lc) return true;
+  }
+  return false;
+}
 
 // src/client/x402-client.ts
+var receiptStore = /* @__PURE__ */ new WeakMap();
+function getPaymentReceipt(response) {
+  return receiptStore.get(response);
+}
 function createX402Client(config) {
   const {
     adapters = [createSolanaAdapter({ verbose: config.verbose }), createEvmAdapter({ verbose: config.verbose })],
@@ -701,13 +724,7 @@ function createX402Client(config) {
     if (!match) return null;
     const { accept, adapter, wallet } = match;
     if (adapter.name === "Solana" && !accept.extra?.feePayer) return null;
-    const USDC_MINTS = [
-      "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-      "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
-      "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
-    ];
-    const decimals = accept.extra?.decimals ?? (USDC_MINTS.includes(accept.asset) ? 6 : void 0);
+    const decimals = accept.extra?.decimals ?? (isKnownUSDC(accept.asset) ? 6 : void 0);
     if (typeof decimals !== "number") return null;
     const paymentAmount = accept.amount || accept.maxAmountRequired;
     if (!paymentAmount) return null;
@@ -846,17 +863,7 @@ function createX402Client(config) {
         "Solana payment option missing feePayer in extra"
       );
     }
-    const USDC_MINTS = [
-      "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
-      // Solana mainnet
-      "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
-      // Solana devnet
-      "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-      // Base mainnet
-      "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
-      // Base sepolia
-    ];
-    const decimals = accept.extra?.decimals ?? (USDC_MINTS.includes(accept.asset) ? 6 : void 0);
+    const decimals = accept.extra?.decimals ?? (isKnownUSDC(accept.asset) ? 6 : void 0);
     if (typeof decimals !== "number") {
       throw new X402Error(
         "missing_decimals",
@@ -953,7 +960,8 @@ function createX402Client(config) {
     if (paymentResponseHeader) {
       try {
         const receipt = JSON.parse(atob(paymentResponseHeader));
-        retryResponse._x402 = receipt;
+        receiptStore.set(retryResponse, receipt);
+        retryResponse["_x402"] = receipt;
         if (receipt.extensions) {
           log("Settlement extensions:", Object.keys(receipt.extensions).join(", "));
         }
@@ -969,16 +977,22 @@ function createX402Client(config) {
 
 // src/client/keypair-wallet.ts
 import { Keypair, VersionedTransaction as VersionedTransaction2, Transaction } from "@solana/web3.js";
-function createKeypairWallet(privateKey) {
+async function createKeypairWallet(privateKey) {
   let keypair;
   if (typeof privateKey === "string") {
-    const bs58 = require_cjs2();
-    const decode = bs58.decode || bs58.default?.decode;
-    if (!decode) {
-      throw new Error("bs58 module not found or incompatible version");
+    let bs58Decode;
+    try {
+      const mod = await Promise.resolve().then(() => (init_esm2(), esm_exports));
+      const resolve = mod.decode ?? mod.default?.decode;
+      if (!resolve) throw new Error("decode not found");
+      bs58Decode = resolve;
+    } catch (e) {
+      throw new Error(
+        'The "bs58" package is required for base58 private keys. Install it with: npm install bs58'
+      );
     }
     try {
-      const decoded = decode(privateKey);
+      const decoded = bs58Decode(privateKey);
       keypair = Keypair.fromSecretKey(decoded);
     } catch (e) {
       try {
@@ -1057,7 +1071,6 @@ function wrapFetch(fetchImpl, options) {
     walletPrivateKey,
     evmPrivateKey,
     preferredNetwork,
-    // facilitatorUrl is reserved for future use when we add facilitator selection
     rpcUrls,
     maxAmountAtomic,
     verbose,
@@ -1067,17 +1080,26 @@ function wrapFetch(fetchImpl, options) {
     throw new Error("At least one wallet private key is required (walletPrivateKey or evmPrivateKey)");
   }
   const wallets = {};
+  const walletInits = [];
   if (walletPrivateKey) {
-    wallets.solana = createKeypairWallet(walletPrivateKey);
+    walletInits.push(
+      createKeypairWallet(walletPrivateKey).then((w) => {
+        wallets.solana = w;
+      }).catch((e) => {
+        console.warn(`[x402] Solana wallet init failed: ${e.message}`);
+      })
+    );
   }
-  let evmReady = null;
   if (evmPrivateKey) {
-    evmReady = createEvmKeypairWallet(evmPrivateKey).then((w) => {
-      wallets.evm = w;
-    }).catch((e) => {
-      console.warn(`[x402] ${e.message}`);
-    });
+    walletInits.push(
+      createEvmKeypairWallet(evmPrivateKey).then((w) => {
+        wallets.evm = w;
+      }).catch((e) => {
+        console.warn(`[x402] EVM wallet init failed: ${e.message}`);
+      })
+    );
   }
+  const walletsReady = walletInits.length > 0 ? Promise.all(walletInits) : null;
   const clientConfig = {
     wallets,
     preferredNetwork,
@@ -1089,9 +1111,9 @@ function wrapFetch(fetchImpl, options) {
   };
   const client = createX402Client(clientConfig);
   const clientFetch = client.fetch.bind(client);
-  if (evmReady) {
+  if (walletsReady) {
     return (async (input, init) => {
-      await evmReady;
+      await walletsReady;
       return clientFetch(input, init);
     });
   }
@@ -1108,6 +1130,7 @@ export {
   createKeypairWallet,
   createSolanaAdapter,
   createX402Client,
+  getPaymentReceipt,
   isEvmKeypairWallet,
   isKeypairWallet,
   wrapFetch