moltspay 1.4.1 → 1.6.0

package/dist/client/web/index.mjs

@@ -0,0 +1,1289 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+// src/client/web/index.ts
+import { ethers } from "ethers";
+import { Connection as Connection3, PublicKey as PublicKey3 } from "@solana/web3.js";
+
+// src/client/core/types.ts
+var X402_VERSION = 2;
+var PAYMENT_REQUIRED_HEADER = "x-payment-required";
+var PAYMENT_HEADER = "x-payment";
+
+// src/client/core/chain-map.ts
+var NETWORK_TO_CHAIN = {
+  "eip155:8453": "base",
+  "eip155:137": "polygon",
+  "eip155:84532": "base_sepolia",
+  "eip155:42431": "tempo_moderato",
+  "eip155:56": "bnb",
+  "eip155:97": "bnb_testnet",
+  "solana:mainnet": "solana",
+  "solana:devnet": "solana_devnet"
+};
+var CHAIN_TO_NETWORK = Object.fromEntries(
+  Object.entries(NETWORK_TO_CHAIN).map(([network, chain]) => [chain, network])
+);
+function networkToChainName(network) {
+  return NETWORK_TO_CHAIN[network] ?? null;
+}
+function chainNameToNetwork(chain) {
+  return CHAIN_TO_NETWORK[chain];
+}
+
+// src/client/core/base64.ts
+var BufferCtor = globalThis.Buffer;
+function encodeBase64(input) {
+  if (BufferCtor) {
+    return BufferCtor.from(input, "utf-8").toString("base64");
+  }
+  const bytes = new TextEncoder().encode(input);
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+function decodeBase64(input) {
+  if (BufferCtor) {
+    return BufferCtor.from(input, "base64").toString("utf-8");
+  }
+  const binary = atob(input);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return new TextDecoder().decode(bytes);
+}
+function base64ToUint8Array(input) {
+  if (BufferCtor) {
+    const buf = BufferCtor.from(input, "base64");
+    return new Uint8Array(buf);
+  }
+  const binary = atob(input);
+  const bytes = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) {
+    bytes[i] = binary.charCodeAt(i);
+  }
+  return bytes;
+}
+function uint8ArrayToBase64(bytes) {
+  if (BufferCtor) {
+    return BufferCtor.from(bytes).toString("base64");
+  }
+  let binary = "";
+  for (let i = 0; i < bytes.length; i++) {
+    binary += String.fromCharCode(bytes[i]);
+  }
+  return btoa(binary);
+}
+
+// src/client/core/errors.ts
+var MoltsPayError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    __publicField(this, "code");
+    this.name = "MoltsPayError";
+    this.code = code;
+  }
+};
+var NotInitializedError = class extends MoltsPayError {
+  constructor(message = "Client not initialized") {
+    super("NOT_INITIALIZED", message);
+    this.name = "NotInitializedError";
+  }
+};
+var UnsupportedChainError = class extends MoltsPayError {
+  constructor(chain, message) {
+    super("UNSUPPORTED_CHAIN", message ?? `Chain not supported: ${chain}`);
+    this.chain = chain;
+    this.name = "UnsupportedChainError";
+  }
+};
+var NeedsApprovalError = class extends MoltsPayError {
+  constructor(details, message) {
+    super(
+      "NEEDS_APPROVAL",
+      message ?? `Insufficient allowance for ${details.spender}. Current=${details.currentAllowance}, required=${details.required}.`
+    );
+    this.details = details;
+    this.name = "NeedsApprovalError";
+  }
+};
+var InsufficientBalanceError = class extends MoltsPayError {
+  constructor(message) {
+    super("INSUFFICIENT_BALANCE", message);
+    this.name = "InsufficientBalanceError";
+  }
+};
+var SpendingLimitExceededError = class extends MoltsPayError {
+  constructor(message) {
+    super("SPENDING_LIMIT_EXCEEDED", message);
+    this.name = "SpendingLimitExceededError";
+  }
+};
+var PaymentRejectedError = class extends MoltsPayError {
+  constructor(message) {
+    super("PAYMENT_REJECTED", message);
+    this.name = "PaymentRejectedError";
+  }
+};
+var ServerError = class extends MoltsPayError {
+  constructor(status, message) {
+    super("SERVER_ERROR", message);
+    this.status = status;
+    this.name = "ServerError";
+  }
+};
+var InvalidPaymentHeaderError = class extends MoltsPayError {
+  constructor(message) {
+    super("INVALID_PAYMENT_HEADER", message);
+    this.name = "InvalidPaymentHeaderError";
+  }
+};
+
+// src/client/core/eip3009.ts
+var EIP3009_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" }
+  ]
+};
+function buildEIP3009TypedData(args) {
+  const validAfter = args.validAfter ?? "0";
+  const validBefore = args.validBefore ?? (Math.floor(Date.now() / 1e3) + 3600).toString();
+  const authorization = {
+    from: args.from,
+    to: args.to,
+    value: args.value,
+    validAfter,
+    validBefore,
+    nonce: args.nonce
+  };
+  return {
+    domain: {
+      name: args.tokenName,
+      version: args.tokenVersion,
+      chainId: args.chainId,
+      verifyingContract: args.tokenAddress
+    },
+    types: EIP3009_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: authorization
+  };
+}
+
+// src/client/core/eip2612.ts
+var EIP2612_TYPES = {
+  Permit: [
+    { name: "owner", type: "address" },
+    { name: "spender", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+function buildEIP2612PermitTypedData(args) {
+  const message = {
+    owner: args.owner,
+    spender: args.spender,
+    value: args.value,
+    nonce: args.nonce,
+    deadline: args.deadline
+  };
+  return {
+    domain: {
+      name: args.tokenName,
+      version: args.tokenVersion,
+      chainId: args.chainId,
+      verifyingContract: args.tokenAddress
+    },
+    types: EIP2612_TYPES,
+    primaryType: "Permit",
+    message
+  };
+}
+
+// src/client/core/bnb-intent.ts
+var BNB_INTENT_TYPES = {
+  PaymentIntent: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "amount", type: "uint256" },
+    { name: "token", type: "address" },
+    { name: "service", type: "string" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var BNB_DOMAIN_NAME = "MoltsPay";
+var BNB_DOMAIN_VERSION = "1";
+function buildBnbIntentTypedData(args) {
+  const intent = {
+    from: args.from,
+    to: args.to,
+    amount: args.amount,
+    token: args.tokenAddress,
+    service: args.service,
+    nonce: args.nonce,
+    deadline: args.deadline
+  };
+  return {
+    domain: {
+      name: BNB_DOMAIN_NAME,
+      version: BNB_DOMAIN_VERSION,
+      chainId: args.chainId
+    },
+    types: BNB_INTENT_TYPES,
+    primaryType: "PaymentIntent",
+    message: intent
+  };
+}
+
+// src/facilitators/solana.ts
+import {
+  Connection as Connection2,
+  PublicKey as PublicKey2,
+  Transaction,
+  VersionedTransaction
+} from "@solana/web3.js";
+import {
+  getAssociatedTokenAddress,
+  createTransferCheckedInstruction,
+  getAccount,
+  createAssociatedTokenAccountInstruction
+} from "@solana/spl-token";
+
+// src/chains/solana.ts
+import { Connection, PublicKey } from "@solana/web3.js";
+var SOLANA_CHAINS = {
+  solana: {
+    name: "Solana Mainnet",
+    cluster: "mainnet-beta",
+    rpc: "https://api.mainnet-beta.solana.com",
+    explorer: "https://solscan.io/account/",
+    explorerTx: "https://solscan.io/tx/",
+    tokens: {
+      USDC: {
+        mint: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v",
+        // Circle official USDC
+        decimals: 6
+      }
+    }
+  },
+  solana_devnet: {
+    name: "Solana Devnet",
+    cluster: "devnet",
+    rpc: "https://api.devnet.solana.com",
+    explorer: "https://solscan.io/account/",
+    explorerTx: "https://solscan.io/tx/",
+    tokens: {
+      USDC: {
+        // Circle's devnet USDC (if not available, we'll deploy our own test token)
+        mint: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU",
+        decimals: 6
+      }
+    }
+  }
+};
+
+// src/facilitators/solana.ts
+async function createSolanaPaymentTransaction(senderPubkey, recipientPubkey, amount, chain, feePayerPubkey, connection) {
+  const chainConfig = SOLANA_CHAINS[chain];
+  const conn = connection ?? new Connection2(chainConfig.rpc, "confirmed");
+  const mint = new PublicKey2(chainConfig.tokens.USDC.mint);
+  const actualFeePayer = feePayerPubkey || senderPubkey;
+  const senderATA = await getAssociatedTokenAddress(mint, senderPubkey);
+  const recipientATA = await getAssociatedTokenAddress(mint, recipientPubkey);
+  const transaction = new Transaction();
+  try {
+    await getAccount(conn, recipientATA);
+  } catch {
+    transaction.add(
+      createAssociatedTokenAccountInstruction(
+        actualFeePayer,
+        // payer (fee payer in gasless mode)
+        recipientATA,
+        // ata to create
+        recipientPubkey,
+        // owner
+        mint
+        // mint
+      )
+    );
+  }
+  transaction.add(
+    createTransferCheckedInstruction(
+      senderATA,
+      // source
+      mint,
+      // mint
+      recipientATA,
+      // destination
+      senderPubkey,
+      // owner (sender still authorizes the transfer)
+      amount,
+      // amount
+      chainConfig.tokens.USDC.decimals
+      // decimals
+    )
+  );
+  const { blockhash, lastValidBlockHeight } = await conn.getLatestBlockhash();
+  transaction.recentBlockhash = blockhash;
+  transaction.feePayer = actualFeePayer;
+  return transaction;
+}
+
+// src/client/core/x402.ts
+function parsePaymentRequiredHeader(header) {
+  let parsed;
+  try {
+    parsed = JSON.parse(decodeBase64(header));
+  } catch {
+    throw new InvalidPaymentHeaderError("Invalid x-payment-required header");
+  }
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (parsed && typeof parsed === "object" && Array.isArray(parsed.accepts)) {
+    return parsed.accepts;
+  }
+  return [parsed];
+}
+function serverAcceptedChains(requirements) {
+  return requirements.map((r) => networkToChainName(r.network)).filter((c) => c !== null);
+}
+function selectChain(requirements, userSpecifiedChain) {
+  const accepted = serverAcceptedChains(requirements);
+  if (userSpecifiedChain) {
+    if (!accepted.includes(userSpecifiedChain)) {
+      throw new UnsupportedChainError(
+        userSpecifiedChain,
+        `Server doesn't accept '${userSpecifiedChain}'. Server accepts: ${accepted.join(", ")}`
+      );
+    }
+    return userSpecifiedChain;
+  }
+  if (accepted.length === 1 && accepted[0] === "base") {
+    return "base";
+  }
+  throw new UnsupportedChainError(
+    "unspecified",
+    `Server accepts: ${accepted.join(", ")}. Please specify a chain explicitly.`
+  );
+}
+function findRequirementForChain(requirements, chain) {
+  const network = chainNameToNetwork(chain);
+  return requirements.find((r) => r.network === network) ?? null;
+}
+function buildPaymentPayload(args) {
+  return {
+    x402Version: X402_VERSION,
+    scheme: args.scheme,
+    network: args.network,
+    payload: args.payload,
+    accepted: args.accepted
+  };
+}
+function encodePaymentHeader(payload) {
+  return encodeBase64(JSON.stringify(payload));
+}
+
+// src/chains/index.ts
+var CHAINS = {
+  // ============ Mainnet ============
+  base: {
+    name: "Base",
+    chainId: 8453,
+    rpc: "https://mainnet.base.org",
+    tokens: {
+      USDC: {
+        address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        decimals: 6,
+        symbol: "USDC",
+        eip712Name: "USD Coin"
+        // EIP-712 domain name
+      },
+      USDT: {
+        address: "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2",
+        decimals: 6,
+        symbol: "USDT",
+        eip712Name: "Tether USD"
+      }
+    },
+    usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    // deprecated, for backward compat
+    explorer: "https://basescan.org/address/",
+    explorerTx: "https://basescan.org/tx/",
+    avgBlockTime: 2
+  },
+  polygon: {
+    name: "Polygon",
+    chainId: 137,
+    rpc: "https://polygon-bor-rpc.publicnode.com",
+    tokens: {
+      USDC: {
+        address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+        decimals: 6,
+        symbol: "USDC",
+        eip712Name: "USD Coin"
+      },
+      USDT: {
+        address: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+        decimals: 6,
+        symbol: "USDT",
+        eip712Name: "(PoS) Tether USD"
+        // Polygon uses this name
+      }
+    },
+    usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    explorer: "https://polygonscan.com/address/",
+    explorerTx: "https://polygonscan.com/tx/",
+    avgBlockTime: 2
+  },
+  // ============ Testnet ============
+  base_sepolia: {
+    name: "Base Sepolia",
+    chainId: 84532,
+    rpc: "https://sepolia.base.org",
+    tokens: {
+      USDC: {
+        address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+        decimals: 6,
+        symbol: "USDC",
+        eip712Name: "USDC"
+        // Testnet USDC uses 'USDC' not 'USD Coin'
+      },
+      USDT: {
+        address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+        // Same as USDC on testnet (no official USDT)
+        decimals: 6,
+        symbol: "USDT",
+        eip712Name: "USDC"
+        // Uses same contract as USDC
+      }
+    },
+    usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    explorer: "https://sepolia.basescan.org/address/",
+    explorerTx: "https://sepolia.basescan.org/tx/",
+    avgBlockTime: 2
+  },
+  // ============ Tempo Testnet (Moderato) ============
+  tempo_moderato: {
+    name: "Tempo Moderato",
+    chainId: 42431,
+    rpc: "https://rpc.moderato.tempo.xyz",
+    tokens: {
+      // TIP-20 stablecoins on Tempo testnet (from mppx SDK)
+      // Note: Tempo uses USD as native gas token, not ETH
+      USDC: {
+        address: "0x20c0000000000000000000000000000000000000",
+        // pathUSD - primary testnet stablecoin
+        decimals: 6,
+        symbol: "USDC",
+        eip712Name: "pathUSD"
+      },
+      USDT: {
+        address: "0x20c0000000000000000000000000000000000001",
+        // alphaUSD
+        decimals: 6,
+        symbol: "USDT",
+        eip712Name: "alphaUSD"
+      }
+    },
+    usdc: "0x20c0000000000000000000000000000000000000",
+    explorer: "https://explore.testnet.tempo.xyz/address/",
+    explorerTx: "https://explore.testnet.tempo.xyz/tx/",
+    avgBlockTime: 0.5
+    // ~500ms finality
+  },
+  // ============ BNB Chain Testnet ============
+  bnb_testnet: {
+    name: "BNB Testnet",
+    chainId: 97,
+    rpc: "https://data-seed-prebsc-1-s1.binance.org:8545",
+    tokens: {
+      // Note: BNB uses 18 decimals for stablecoins (unlike Base/Polygon which use 6)
+      // Using official Binance-Peg testnet tokens
+      USDC: {
+        address: "0x64544969ed7EBf5f083679233325356EbE738930",
+        // Testnet USDC
+        decimals: 18,
+        symbol: "USDC",
+        eip712Name: "USD Coin"
+      },
+      USDT: {
+        address: "0x337610d27c682E347C9cD60BD4b3b107C9d34dDd",
+        // Testnet USDT
+        decimals: 18,
+        symbol: "USDT",
+        eip712Name: "Tether USD"
+      }
+    },
+    usdc: "0x64544969ed7EBf5f083679233325356EbE738930",
+    explorer: "https://testnet.bscscan.com/address/",
+    explorerTx: "https://testnet.bscscan.com/tx/",
+    avgBlockTime: 3,
+    // BNB-specific: requires approval for pay-for-success flow
+    requiresApproval: true
+  },
+  // ============ BNB Chain Mainnet ============
+  bnb: {
+    name: "BNB Smart Chain",
+    chainId: 56,
+    rpc: "https://bsc-dataseed.binance.org",
+    tokens: {
+      // Note: BNB uses 18 decimals for stablecoins
+      USDC: {
+        address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+        decimals: 18,
+        symbol: "USDC",
+        eip712Name: "USD Coin"
+      },
+      USDT: {
+        address: "0x55d398326f99059fF775485246999027B3197955",
+        decimals: 18,
+        symbol: "USDT",
+        eip712Name: "Tether USD"
+      }
+    },
+    usdc: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+    explorer: "https://bscscan.com/address/",
+    explorerTx: "https://bscscan.com/tx/",
+    avgBlockTime: 3,
+    // BNB-specific: requires approval for pay-for-success flow
+    requiresApproval: true
+  }
+};
+
+// src/client/web/storage.ts
+var DEFAULT_STORAGE_KEY = "moltspay:spending";
+function getStorage() {
+  const g = globalThis;
+  return g.localStorage ?? null;
+}
+function todayKey() {
+  return (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0);
+}
+var SpendingLedger = class {
+  constructor(config) {
+    __publicField(this, "storageKey");
+    __publicField(this, "maxPerTx");
+    __publicField(this, "maxPerDay");
+    this.maxPerTx = config.maxPerTx;
+    this.maxPerDay = config.maxPerDay;
+    this.storageKey = config.storageKey ?? DEFAULT_STORAGE_KEY;
+  }
+  /** Load the persisted total for today. Fails silently on parse errors. */
+  read() {
+    const storage = getStorage();
+    const today = todayKey();
+    if (!storage) return { date: today, amount: 0, updatedAt: Date.now() };
+    try {
+      const raw = storage.getItem(this.storageKey);
+      if (!raw) return { date: today, amount: 0, updatedAt: Date.now() };
+      const parsed = JSON.parse(raw);
+      if (parsed.date !== today) {
+        return { date: today, amount: 0, updatedAt: Date.now() };
+      }
+      return parsed;
+    } catch {
+      return { date: today, amount: 0, updatedAt: Date.now() };
+    }
+  }
+  write(entry) {
+    const storage = getStorage();
+    if (!storage) return;
+    try {
+      storage.setItem(this.storageKey, JSON.stringify(entry));
+    } catch {
+    }
+  }
+  /**
+   * Throw `SpendingLimitExceededError` if the requested charge would push
+   * per-tx or per-day limits over. Does NOT mutate state — callers record
+   * only after the payment clears via {@link record}.
+   */
+  check(amount) {
+    if (amount > this.maxPerTx) {
+      throw new SpendingLimitExceededError(
+        `Amount $${amount} exceeds max per transaction ($${this.maxPerTx})`
+      );
+    }
+    const current = this.read();
+    if (current.amount + amount > this.maxPerDay) {
+      throw new SpendingLimitExceededError(
+        `Would exceed daily limit ($${current.amount} + $${amount} > $${this.maxPerDay})`
+      );
+    }
+  }
+  /** Persist a successful charge. Silently no-ops in non-browser runtimes. */
+  record(amount) {
+    const current = this.read();
+    this.write({
+      date: current.date,
+      amount: current.amount + amount,
+      updatedAt: Date.now()
+    });
+  }
+  /** Current aggregate for the active day. Intended for UI display. */
+  get todaySpending() {
+    return this.read().amount;
+  }
+  /** Manually reset — mainly useful for tests. */
+  reset() {
+    this.write({ date: todayKey(), amount: 0, updatedAt: Date.now() });
+  }
+};
+
+// src/client/web/signers/eip1193.ts
+var USER_REJECTED_CODES = /* @__PURE__ */ new Set([4001, -32603]);
+function isUserRejection(err) {
+  const code = err?.code;
+  return code !== void 0 && USER_REJECTED_CODES.has(code);
+}
+function toHexChainId(chainId) {
+  return "0x" + chainId.toString(16);
+}
+function eip1193Signer(provider, options = {}) {
+  async function getEvmAddress() {
+    const accounts = await provider.request({
+      method: "eth_requestAccounts"
+    });
+    if (!accounts || accounts.length === 0) {
+      throw new PaymentRejectedError("No EVM account available from provider");
+    }
+    return accounts[0];
+  }
+  async function ensureChainId(chainId) {
+    const hexId = toHexChainId(chainId);
+    try {
+      const current = await provider.request({ method: "eth_chainId" });
+      if (current?.toLowerCase() === hexId.toLowerCase()) return;
+      await provider.request({
+        method: "wallet_switchEthereumChain",
+        params: [{ chainId: hexId }]
+      });
+    } catch (err) {
+      const code = err?.code;
+      if (code === 4902 || code === -32603) {
+        const meta = options.addChainMetadata?.[chainId];
+        if (!meta) {
+          throw new Error(
+            `Wallet does not know chainId ${chainId}. Provide addChainMetadata to eip1193Signer for automatic addition.`
+          );
+        }
+        await provider.request({
+          method: "wallet_addEthereumChain",
+          params: [
+            {
+              chainId: hexId,
+              chainName: meta.chainName,
+              rpcUrls: meta.rpcUrls,
+              nativeCurrency: meta.nativeCurrency,
+              blockExplorerUrls: meta.blockExplorerUrls
+            }
+          ]
+        });
+        return;
+      }
+      if (isUserRejection(err)) {
+        throw new PaymentRejectedError("User rejected chain switch");
+      }
+      throw err;
+    }
+  }
+  return {
+    getEvmAddress,
+    async signTypedData(envelope) {
+      if (typeof envelope.domain?.chainId === "number") {
+        await ensureChainId(envelope.domain.chainId);
+      }
+      const from = await getEvmAddress();
+      const typesForWire = {
+        EIP712Domain: [
+          { name: "name", type: "string" },
+          { name: "version", type: "string" },
+          { name: "chainId", type: "uint256" },
+          { name: "verifyingContract", type: "address" }
+        ]
+      };
+      for (const [key, fields] of Object.entries(envelope.types)) {
+        typesForWire[key] = [...fields];
+      }
+      const payload = JSON.stringify({
+        domain: envelope.domain,
+        types: typesForWire,
+        primaryType: envelope.primaryType,
+        message: envelope.message
+      });
+      try {
+        return await provider.request({
+          method: "eth_signTypedData_v4",
+          params: [from, payload]
+        });
+      } catch (err) {
+        if (isUserRejection(err)) {
+          throw new PaymentRejectedError("User rejected signature");
+        }
+        throw err;
+      }
+    },
+    async sendEvmTransaction(args) {
+      await ensureChainId(args.chainId);
+      const from = await getEvmAddress();
+      try {
+        return await provider.request({
+          method: "eth_sendTransaction",
+          params: [
+            {
+              from,
+              to: args.to,
+              data: args.data,
+              ...args.value ? { value: args.value } : {}
+            }
+          ]
+        });
+      } catch (err) {
+        if (isUserRejection(err)) {
+          throw new PaymentRejectedError("User rejected transaction");
+        }
+        throw err;
+      }
+    }
+  };
+}
+
+// src/client/web/signers/solana-adapter.ts
+import { Transaction as Transaction2 } from "@solana/web3.js";
+function isUserRejection2(err) {
+  const name = err?.name ?? "";
+  const message = String(err?.message ?? "");
+  return name.toLowerCase().includes("reject") || /user rejected|user denied|rejected by user/i.test(message);
+}
+function solanaSigner(adapter) {
+  return {
+    async getEvmAddress() {
+      throw new Error(
+        "solanaSigner does not support EVM. Compose with eip1193Signer for multi-chain."
+      );
+    },
+    async getSolanaAddress() {
+      return adapter.publicKey ? adapter.publicKey.toBase58() : null;
+    },
+    async signTypedData() {
+      throw new Error("solanaSigner does not support EIP-712 signing.");
+    },
+    async signSolanaTransaction(args) {
+      if (!adapter.publicKey) {
+        throw new PaymentRejectedError("Solana wallet not connected");
+      }
+      const tx = Transaction2.from(base64ToUint8Array(args.transactionBase64));
+      let signed;
+      try {
+        signed = await adapter.signTransaction(tx);
+      } catch (err) {
+        if (isUserRejection2(err)) {
+          throw new PaymentRejectedError("User rejected Solana signature");
+        }
+        throw err;
+      }
+      const serialized = signed.serialize({
+        requireAllSignatures: false,
+        verifySignatures: false
+      });
+      return uint8ArrayToBase64(serialized);
+    }
+  };
+}
+
+// src/client/web/signers/compose.ts
+function composeSigners(...signers) {
+  if (signers.length === 0) {
+    throw new Error("composeSigners requires at least one signer");
+  }
+  if (signers.length === 1) {
+    return signers[0];
+  }
+  async function tryEach(pick) {
+    let lastError = new Error("composeSigners: no signer supported the operation");
+    for (const signer of signers) {
+      const candidate = pick(signer);
+      if (candidate === void 0) continue;
+      try {
+        return await candidate;
+      } catch (err) {
+        lastError = err;
+      }
+    }
+    throw lastError;
+  }
+  return {
+    getEvmAddress: () => tryEach((s) => s.getEvmAddress?.()),
+    getSolanaAddress: () => tryEach(
+      (s) => s.getSolanaAddress ? s.getSolanaAddress() : void 0
+    ),
+    signTypedData: (envelope) => tryEach((s) => s.signTypedData?.(envelope)),
+    sendEvmTransaction: (args) => tryEach(
+      (s) => s.sendEvmTransaction ? s.sendEvmTransaction(args) : void 0
+    ),
+    signSolanaTransaction: (args) => tryEach(
+      (s) => s.signSolanaTransaction ? s.signSolanaTransaction(args) : void 0
+    )
+  };
+}
+
+// src/client/web/index.ts
+var MoltsPayWebClient = class {
+  constructor(options) {
+    __publicField(this, "signer");
+    __publicField(this, "defaultChain");
+    __publicField(this, "ledger");
+    __publicField(this, "fetchImpl");
+    __publicField(this, "solanaRpc");
+    if (!options.signer) {
+      throw new NotInitializedError("MoltsPayWebClient: signer is required");
+    }
+    this.signer = options.signer;
+    this.defaultChain = options.defaultChain;
+    this.ledger = options.spendingLimits ? new SpendingLedger(options.spendingLimits) : null;
+    this.fetchImpl = (options.fetch ?? globalThis.fetch).bind(globalThis);
+    this.solanaRpc = options.solanaRpc;
+  }
+  getSolanaConnection(chain) {
+    const rpc = this.solanaRpc?.[chain] ?? SOLANA_CHAINS[chain].rpc;
+    return new Connection3(rpc, "confirmed");
+  }
+  /** Fetch a provider's service manifest. Mirrors `MoltsPayClient.getServices`. */
+  async getServices(serverUrl) {
+    const normalizedUrl = serverUrl.replace(/\/(services|api\/services|registry\/services)\/?$/, "");
+    const endpoints = ["/services", "/api/services", "/registry/services"];
+    for (const endpoint of endpoints) {
+      try {
+        const res = await this.fetchImpl(`${normalizedUrl}${endpoint}`);
+        if (!res.ok) continue;
+        const contentType = res.headers.get("content-type") ?? "";
+        if (!contentType.includes("application/json")) continue;
+        return await res.json();
+      } catch {
+        continue;
+      }
+    }
+    throw new ServerError(0, `Failed to get services: no valid endpoint found at ${normalizedUrl}`);
+  }
+  /**
+   * Pay for a service via x402. Returns the service `result` field (or the
+   * whole JSON body if the server doesn't wrap). Throws `NeedsApprovalError`
+   * for BNB when allowance is insufficient — call {@link approveBnb} and retry.
+   */
+  async pay(serverUrl, service, params, options = {}) {
+    const executeUrl = await this.resolveExecuteUrl(serverUrl, service);
+    const requestBody = this.buildRequestBody(service, params, options);
+    const initialRes = await this.fetchImpl(executeUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(requestBody)
+    });
+    if (initialRes.status !== 402) {
+      const data = await initialRes.json();
+      if (initialRes.ok && data.result) {
+        return data.result;
+      }
+      if (initialRes.ok) {
+        return data;
+      }
+      throw new ServerError(initialRes.status, data.error ?? "Unexpected response");
+    }
+    const paymentRequiredHeader = initialRes.headers.get(PAYMENT_REQUIRED_HEADER);
+    if (!paymentRequiredHeader) {
+      throw new ServerError(402, "Missing X-Payment-Required header in 402 response");
+    }
+    const requirements = parsePaymentRequiredHeader(paymentRequiredHeader);
+    const chain = this.chooseChain(requirements, options.chain);
+    const req = findRequirementForChain(requirements, chain);
+    if (!req) {
+      throw new UnsupportedChainError(chain, `No payment requirement for chain '${chain}' in server response`);
+    }
+    if (chain === "solana" || chain === "solana_devnet") {
+      return this.paySolana(executeUrl, service, params, req, chain, options);
+    }
+    if (chain === "tempo_moderato") {
+      return this.payTempoPermit(executeUrl, service, params, req, options);
+    }
+    if (chain === "bnb" || chain === "bnb_testnet") {
+      return this.payBnb(executeUrl, service, params, req, chain, options);
+    }
+    return this.payEIP3009(executeUrl, service, params, req, chain, options);
+  }
+  /** Read-only balance check on the specified chain (or `defaultChain` if configured). */
+  async getBalance(chain) {
+    const target = chain ?? this.defaultChain;
+    if (!target) {
+      throw new UnsupportedChainError("unspecified", "No chain provided and no defaultChain configured");
+    }
+    if (target === "solana" || target === "solana_devnet") {
+      const conn = this.getSolanaConnection(target);
+      const owner2 = await this.signer.getSolanaAddress?.();
+      if (!owner2) {
+        throw new NotInitializedError("No Solana address available from signer");
+      }
+      const native = await conn.getBalance(new PublicKey3(owner2));
+      return { usdc: 0, native: native / 1e9 };
+    }
+    const evmChain = CHAINS[target];
+    const provider = new ethers.JsonRpcProvider(evmChain.rpc);
+    const owner = await this.signer.getEvmAddress();
+    const tokenAbi = ["function balanceOf(address) view returns (uint256)"];
+    const [nativeBalance, usdcBalance, usdtBalance] = await Promise.all([
+      provider.getBalance(owner),
+      new ethers.Contract(evmChain.tokens.USDC.address, tokenAbi, provider).balanceOf(owner),
+      new ethers.Contract(evmChain.tokens.USDT.address, tokenAbi, provider).balanceOf(owner)
+    ]);
+    return {
+      usdc: parseFloat(ethers.formatUnits(usdcBalance, evmChain.tokens.USDC.decimals)),
+      usdt: parseFloat(ethers.formatUnits(usdtBalance, evmChain.tokens.USDT.decimals)),
+      native: parseFloat(ethers.formatEther(nativeBalance))
+    };
+  }
+  /**
+   * Approve a spender for the BNB chain's USDC / USDT (one-time, costs BNB gas).
+   * The spender address is what the server advertised as `bnbSpender` in the
+   * 402 response. Amount defaults to `MaxUint256` so only one approval is ever
+   * needed per (chain, token, spender) tuple.
+   */
+  async approveBnb(args) {
+    if (!this.signer.sendEvmTransaction) {
+      throw new NotInitializedError("Signer does not support sendEvmTransaction");
+    }
+    const chain = CHAINS[args.chain];
+    const tokenAddr = chain.tokens[args.token].address;
+    const amount = args.amount ?? ethers.MaxUint256.toString();
+    const iface = new ethers.Interface([
+      "function approve(address spender, uint256 amount) returns (bool)"
+    ]);
+    const data = iface.encodeFunctionData("approve", [args.spender, amount]);
+    return this.signer.sendEvmTransaction({
+      chainId: chain.chainId,
+      to: tokenAddr,
+      data
+    });
+  }
+  // ===== internals =====
+  async resolveExecuteUrl(serverUrl, service) {
+    try {
+      const services = await this.getServices(serverUrl);
+      const svc = services.services?.find((s) => s.id === service);
+      if (svc?.endpoint) {
+        return `${serverUrl}${svc.endpoint}`;
+      }
+    } catch {
+    }
+    return `${serverUrl}/execute`;
+  }
+  buildRequestBody(service, params, options) {
+    const body = options.rawData ? { service, ...params } : { service, params };
+    if (options.chain) body.chain = options.chain;
+    return body;
+  }
+  chooseChain(requirements, userChain) {
+    const preferred = userChain ?? this.defaultChain;
+    if (preferred) {
+      return selectChain(requirements, preferred);
+    }
+    const accepted = serverAcceptedChains(requirements);
+    if (accepted.length === 1) {
+      return accepted[0];
+    }
+    return selectChain(requirements);
+  }
+  /**
+   * Submit the x402 payload and return the service result. Shared by all
+   * scheme branches — the only thing they vary is how they build `payload`.
+   */
+  async submitPayment(executeUrl, service, params, options, paymentHeader, chainForBody, charge) {
+    const body = options.rawData ? { service, ...params, chain: chainForBody } : { service, params, chain: chainForBody };
+    const paidRes = await this.fetchImpl(executeUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        [PAYMENT_HEADER]: paymentHeader
+      },
+      body: JSON.stringify(body)
+    });
+    const result = await paidRes.json();
+    if (!paidRes.ok) {
+      throw new ServerError(paidRes.status, result.error ?? "Payment failed");
+    }
+    if (this.ledger && charge > 0) {
+      this.ledger.record(charge);
+    }
+    return result.result ?? result;
+  }
+  // ----- EIP-3009 (Base / Polygon / Base Sepolia) -----
+  async payEIP3009(executeUrl, service, params, req, chainName, options) {
+    const evmChain = CHAINS[chainName];
+    const amountRaw = req.amount ?? req.maxAmountRequired;
+    if (!amountRaw) {
+      throw new ServerError(402, "Missing amount in payment requirements");
+    }
+    const amountDisplay = Number(amountRaw) / 1e6;
+    this.ledger?.check(amountDisplay);
+    const payTo = req.payTo ?? req.resource;
+    if (!payTo) {
+      throw new ServerError(402, "Missing payTo in payment requirements");
+    }
+    const owner = await this.signer.getEvmAddress();
+    const nonce = ethers.hexlify(ethers.randomBytes(32));
+    const extra = req.extra ?? {};
+    const tokenConfig = evmChain.tokens.USDC;
+    const tokenName = extra.name ?? tokenConfig.eip712Name ?? "USD Coin";
+    const tokenVersion = extra.version ?? "2";
+    const envelope = buildEIP3009TypedData({
+      from: owner,
+      to: payTo,
+      value: amountRaw,
+      nonce,
+      chainId: evmChain.chainId,
+      tokenAddress: req.asset ?? tokenConfig.address,
+      tokenName,
+      tokenVersion
+    });
+    const signature = await this.signer.signTypedData(envelope);
+    const payload = buildPaymentPayload({
+      scheme: "exact",
+      network: chainNameToNetwork(chainName),
+      payload: { authorization: envelope.message, signature },
+      accepted: {
+        scheme: "exact",
+        network: chainNameToNetwork(chainName),
+        asset: req.asset ?? tokenConfig.address,
+        amount: amountRaw,
+        payTo,
+        maxTimeoutSeconds: req.maxTimeoutSeconds ?? 300,
+        extra: { name: tokenName, version: tokenVersion }
+      }
+    });
+    const header = encodePaymentHeader(payload);
+    return this.submitPayment(executeUrl, service, params, options, header, chainName, amountDisplay);
+  }
+  // ----- EIP-2612 permit (Tempo Moderato) -----
+  async payTempoPermit(executeUrl, service, params, req, options) {
+    const amountRaw = req.amount ?? req.maxAmountRequired;
+    if (!amountRaw) {
+      throw new ServerError(402, "Missing amount in Tempo requirements");
+    }
+    const amountDisplay = Number(amountRaw) / 1e6;
+    this.ledger?.check(amountDisplay);
+    const extra = req.extra ?? {};
+    const spender = extra.tempoSpender;
+    if (!spender) {
+      throw new ServerError(
+        402,
+        "Tempo requirement missing extra.tempoSpender \u2014 server has no settler configured (TEMPO_SETTLER_KEY)"
+      );
+    }
+    if (!req.asset) {
+      throw new ServerError(402, "Tempo requirement missing asset (token address)");
+    }
+    if (!extra.name || !extra.version) {
+      throw new ServerError(402, "Tempo requirement missing extra.name / extra.version for EIP-712 domain");
+    }
+    const owner = await this.signer.getEvmAddress();
+    const tempoRpc = CHAINS.tempo_moderato.rpc;
+    const provider = new ethers.JsonRpcProvider(tempoRpc);
+    const token = new ethers.Contract(
+      req.asset,
+      ["function nonces(address owner) view returns (uint256)"],
+      provider
+    );
+    const nonce = await token.nonces(owner);
+    const deadline = Math.floor(Date.now() / 1e3) + 3600;
+    const envelope = buildEIP2612PermitTypedData({
+      owner,
+      spender,
+      value: amountRaw,
+      nonce: nonce.toString(),
+      deadline: deadline.toString(),
+      chainId: CHAINS.tempo_moderato.chainId,
+      tokenAddress: req.asset,
+      tokenName: extra.name,
+      tokenVersion: extra.version
+    });
+    const rawSig = await this.signer.signTypedData(envelope);
+    const split = ethers.Signature.from(rawSig);
+    const payload = buildPaymentPayload({
+      scheme: "permit",
+      network: chainNameToNetwork("tempo_moderato"),
+      payload: {
+        permit: {
+          owner,
+          spender,
+          value: amountRaw,
+          nonce: nonce.toString(),
+          deadline: deadline.toString(),
+          v: split.v,
+          r: split.r,
+          s: split.s
+        }
+      },
+      accepted: {
+        scheme: "permit",
+        network: chainNameToNetwork("tempo_moderato"),
+        asset: req.asset,
+        amount: amountRaw,
+        payTo: req.payTo ?? "",
+        maxTimeoutSeconds: req.maxTimeoutSeconds ?? 300,
+        extra: { name: extra.name, version: extra.version, tempoSpender: spender }
+      }
+    });
+    const header = encodePaymentHeader(payload);
+    return this.submitPayment(executeUrl, service, params, options, header, "tempo_moderato", amountDisplay);
+  }
+  // ----- BNB intent (BNB / BNB Testnet) -----
+  async payBnb(executeUrl, service, params, req, chainName, options) {
+    const evmChain = CHAINS[chainName];
+    const extra = req.extra ?? {};
+    const spender = extra.bnbSpender;
+    if (!spender) {
+      throw new ServerError(402, "BNB requirement missing extra.bnbSpender");
+    }
+    if (!req.amount || !req.payTo) {
+      throw new ServerError(402, "BNB requirement missing amount or payTo");
+    }
+    const owner = await this.signer.getEvmAddress();
+    const tokenConfig = evmChain.tokens.USDC;
+    const tokenAddress = req.asset ?? tokenConfig.address;
+    const amountDisplay = Number(req.amount) / 1e6;
+    this.ledger?.check(amountDisplay);
+    const amountWei = BigInt(Math.floor(amountDisplay * 10 ** tokenConfig.decimals));
+    const amountWeiStr = amountWei.toString();
+    const provider = new ethers.JsonRpcProvider(evmChain.rpc);
+    const erc20 = new ethers.Contract(
+      tokenAddress,
+      ["function allowance(address owner, address spender) view returns (uint256)"],
+      provider
+    );
+    const allowance = await erc20.allowance(owner, spender);
+    if (allowance < amountWei) {
+      throw new NeedsApprovalError({
+        chain: chainName,
+        spender,
+        token: "USDC",
+        currentAllowance: allowance.toString(),
+        required: amountWei.toString()
+      });
+    }
+    if (chainName === "bnb") {
+      const nativeBalance = await provider.getBalance(owner);
+      if (nativeBalance < ethers.parseEther("0.0001") && allowance < amountWei) {
+        throw new InsufficientBalanceError(
+          `Insufficient BNB for approve gas (have ${ethers.formatEther(nativeBalance)}, need ~0.001 BNB)`
+        );
+      }
+    }
+    const envelope = buildBnbIntentTypedData({
+      from: owner,
+      to: req.payTo,
+      amount: amountWeiStr,
+      tokenAddress,
+      service,
+      nonce: Date.now(),
+      deadline: Date.now() + 36e5,
+      chainId: evmChain.chainId
+    });
+    const signature = await this.signer.signTypedData(envelope);
+    const payload = buildPaymentPayload({
+      scheme: "exact",
+      network: chainNameToNetwork(chainName),
+      payload: {
+        intent: { ...envelope.message, signature },
+        chainId: evmChain.chainId
+      },
+      accepted: {
+        scheme: "exact",
+        network: chainNameToNetwork(chainName),
+        asset: tokenAddress,
+        amount: amountWeiStr,
+        payTo: req.payTo,
+        maxTimeoutSeconds: req.maxTimeoutSeconds ?? 300
+      }
+    });
+    const header = encodePaymentHeader(payload);
+    return this.submitPayment(executeUrl, service, params, options, header, chainName, amountDisplay);
+  }
+  // ----- Solana (solana / solana_devnet) -----
+  async paySolana(executeUrl, service, params, req, chainName, options) {
+    if (!this.signer.signSolanaTransaction) {
+      throw new NotInitializedError("Signer does not support Solana \u2014 use solanaSigner(adapter) or composeSigners");
+    }
+    const ownerBase58 = await this.signer.getSolanaAddress?.();
+    if (!ownerBase58) {
+      throw new NotInitializedError("Solana wallet not connected");
+    }
+    if (!req.amount || !req.payTo) {
+      throw new ServerError(402, "Solana requirement missing amount or payTo");
+    }
+    const amountDisplay = Number(req.amount) / 1e6;
+    this.ledger?.check(amountDisplay);
+    const ownerPubkey = new PublicKey3(ownerBase58);
+    const recipientPubkey = new PublicKey3(req.payTo);
+    const extra = req.extra ?? {};
+    const feePayerPubkey = extra.solanaFeePayer ? new PublicKey3(extra.solanaFeePayer) : void 0;
+    const unsignedTx = await createSolanaPaymentTransaction(
+      ownerPubkey,
+      recipientPubkey,
+      BigInt(req.amount),
+      chainName,
+      feePayerPubkey,
+      this.getSolanaConnection(chainName)
+    );
+    const unsignedBytes = unsignedTx.serialize({
+      requireAllSignatures: false,
+      verifySignatures: false
+    });
+    const transactionBase64 = uint8ArrayToBase64(unsignedBytes);
+    const signedTx = await this.signer.signSolanaTransaction({
+      transactionBase64,
+      partialSign: !!feePayerPubkey
+    });
+    const payload = buildPaymentPayload({
+      scheme: "exact",
+      network: chainNameToNetwork(chainName),
+      payload: {
+        signedTransaction: signedTx,
+        sender: ownerBase58,
+        chain: chainName
+      },
+      accepted: {
+        scheme: "exact",
+        network: chainNameToNetwork(chainName),
+        asset: req.asset ?? SOLANA_CHAINS[chainName].tokens.USDC.mint,
+        amount: req.amount,
+        payTo: req.payTo,
+        maxTimeoutSeconds: req.maxTimeoutSeconds ?? 300
+      }
+    });
+    const header = encodePaymentHeader(payload);
+    return this.submitPayment(executeUrl, service, params, options, header, chainName, amountDisplay);
+  }
+};
+export {
+  InsufficientBalanceError,
+  MoltsPayError,
+  MoltsPayWebClient,
+  NeedsApprovalError,
+  PaymentRejectedError,
+  ServerError,
+  SpendingLedger,
+  SpendingLimitExceededError,
+  UnsupportedChainError,
+  composeSigners,
+  eip1193Signer,
+  solanaSigner
+};
+//# sourceMappingURL=index.mjs.map