moltspay 1.3.0 → 1.4.1

package/dist/cli/index.mjs

@@ -21,16 +21,17 @@ var init_esm_shims = __esm({
 init_esm_shims();
 import { webcrypto } from "crypto";
 import { Command } from "commander";
-import { homedir as homedir2 } from "os";
-import { join as join4, dirname, resolve } from "path";
-import { existsSync as existsSync4, writeFileSync as writeFileSync2, readFileSync as readFileSync4, unlinkSync, mkdirSync as mkdirSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join5, dirname, resolve } from "path";
+import { existsSync as existsSync5, writeFileSync as writeFileSync3, readFileSync as readFileSync5, unlinkSync, mkdirSync as mkdirSync3 } from "fs";
 import { spawn } from "child_process";
+import { ethers as ethers2 } from "ethers";
 
 // src/client/index.ts
 init_esm_shims();
-import { existsSync, readFileSync, writeFileSync, mkdirSync, statSync, chmodSync } from "fs";
-import { homedir } from "os";
-import { join } from "path";
+import { existsSync as existsSync2, readFileSync as readFileSync2, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2, statSync, chmodSync } from "fs";
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
 import { Wallet, ethers } from "ethers";
 
 // src/chains/index.ts
@@ -141,6 +142,63 @@ var CHAINS = {
     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
   }
 };
 function getChain(name) {
@@ -151,6 +209,372 @@ function getChain(name) {
   return config;
 }
 
+// src/wallet/solana.ts
+init_esm_shims();
+import { Keypair, PublicKey as PublicKey2, LAMPORTS_PER_SOL } from "@solana/web3.js";
+import { getAssociatedTokenAddress, getAccount } from "@solana/spl-token";
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import bs58 from "bs58";
+
+// src/chains/solana.ts
+init_esm_shims();
+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
+      }
+    }
+  }
+};
+function getSolanaConnection(chain) {
+  const config = SOLANA_CHAINS[chain];
+  return new Connection(config.rpc, "confirmed");
+}
+function getUSDCMint(chain) {
+  return new PublicKey(SOLANA_CHAINS[chain].tokens.USDC.mint);
+}
+
+// src/wallet/solana.ts
+var DEFAULT_CONFIG_DIR = join(homedir(), ".moltspay");
+var SOLANA_WALLET_FILE = "wallet-solana.json";
+function getSolanaWalletPath(configDir = DEFAULT_CONFIG_DIR) {
+  return join(configDir, SOLANA_WALLET_FILE);
+}
+function solanaWalletExists(configDir = DEFAULT_CONFIG_DIR) {
+  return existsSync(getSolanaWalletPath(configDir));
+}
+function loadSolanaWallet(configDir = DEFAULT_CONFIG_DIR) {
+  const walletPath = getSolanaWalletPath(configDir);
+  if (!existsSync(walletPath)) {
+    return null;
+  }
+  try {
+    const data = JSON.parse(readFileSync(walletPath, "utf-8"));
+    const secretKey = bs58.decode(data.secretKey);
+    return Keypair.fromSecretKey(secretKey);
+  } catch (error) {
+    console.error("Failed to load Solana wallet:", error);
+    return null;
+  }
+}
+function createSolanaWallet(configDir = DEFAULT_CONFIG_DIR) {
+  if (!existsSync(configDir)) {
+    mkdirSync(configDir, { recursive: true });
+  }
+  const keypair = Keypair.generate();
+  const data = {
+    publicKey: keypair.publicKey.toBase58(),
+    secretKey: bs58.encode(keypair.secretKey),
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const walletPath = getSolanaWalletPath(configDir);
+  writeFileSync(walletPath, JSON.stringify(data, null, 2));
+  return keypair;
+}
+function getSolanaAddress(configDir = DEFAULT_CONFIG_DIR) {
+  const wallet = loadSolanaWallet(configDir);
+  return wallet?.publicKey.toBase58() || null;
+}
+async function getSolanaBalance(address, chain) {
+  const connection = getSolanaConnection(chain);
+  const pubkey = new PublicKey2(address);
+  const balance = await connection.getBalance(pubkey);
+  return balance / LAMPORTS_PER_SOL;
+}
+async function getSolanaUSDCBalance(address, chain) {
+  const connection = getSolanaConnection(chain);
+  const owner = new PublicKey2(address);
+  const mint = getUSDCMint(chain);
+  try {
+    const ata = await getAssociatedTokenAddress(mint, owner);
+    const account = await getAccount(connection, ata);
+    return Number(account.amount) / 1e6;
+  } catch (error) {
+    if (error.name === "TokenAccountNotFoundError" || error.message?.includes("could not find account")) {
+      return 0;
+    }
+    throw error;
+  }
+}
+async function getSolanaBalances(address, chain) {
+  const [sol, usdc] = await Promise.all([
+    getSolanaBalance(address, chain),
+    getSolanaUSDCBalance(address, chain)
+  ]);
+  return { sol, usdc };
+}
+function isValidSolanaAddress(address) {
+  try {
+    new PublicKey2(address);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// src/facilitators/solana.ts
+init_esm_shims();
+import {
+  Connection as Connection3,
+  PublicKey as PublicKey3,
+  Transaction,
+  VersionedTransaction
+} from "@solana/web3.js";
+import {
+  getAssociatedTokenAddress as getAssociatedTokenAddress2,
+  createTransferCheckedInstruction,
+  getAccount as getAccount2,
+  createAssociatedTokenAccountInstruction
+} from "@solana/spl-token";
+
+// src/facilitators/interface.ts
+init_esm_shims();
+var BaseFacilitator = class {
+  supportsNetwork(network) {
+    return this.supportedNetworks.includes(network);
+  }
+};
+
+// src/facilitators/solana.ts
+var SolanaFacilitator = class extends BaseFacilitator {
+  name = "solana";
+  displayName = "Solana Direct";
+  supportedNetworks = ["solana:mainnet", "solana:devnet"];
+  connections = /* @__PURE__ */ new Map();
+  feePayerKeypair;
+  constructor(config) {
+    super();
+    this.feePayerKeypair = config?.feePayerKeypair;
+    for (const [chain, config2] of Object.entries(SOLANA_CHAINS)) {
+      this.connections.set(
+        chain,
+        new Connection3(config2.rpc, "confirmed")
+      );
+    }
+    if (this.feePayerKeypair) {
+      console.log(`[SolanaFacilitator] Gasless mode enabled. Fee payer: ${this.feePayerKeypair.publicKey.toBase58()}`);
+    }
+  }
+  /**
+   * Get fee payer public key (for gasless transactions)
+   */
+  getFeePayerPubkey() {
+    return this.feePayerKeypair?.publicKey.toBase58() || null;
+  }
+  getConnection(chain) {
+    const conn = this.connections.get(chain);
+    if (!conn) {
+      throw new Error(`No connection for chain: ${chain}`);
+    }
+    return conn;
+  }
+  /**
+   * Convert our chain name to network identifier
+   */
+  static chainToNetwork(chain) {
+    return chain === "solana" ? "solana:mainnet" : "solana:devnet";
+  }
+  /**
+   * Convert network identifier to chain name
+   */
+  static networkToChain(network) {
+    if (network === "solana:mainnet") return "solana";
+    if (network === "solana:devnet") return "solana_devnet";
+    return null;
+  }
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      const conn = this.getConnection("solana_devnet");
+      await conn.getSlot();
+      return {
+        healthy: true,
+        latencyMs: Date.now() - start
+      };
+    } catch (error) {
+      return {
+        healthy: false,
+        error: error.message
+      };
+    }
+  }
+  /**
+   * Verify a Solana payment
+   * 
+   * Checks:
+   * 1. Transaction is valid and properly signed
+   * 2. Transfer instruction matches expected amount and recipient
+   */
+  async verify(paymentPayload, requirements) {
+    try {
+      const solanaPayload = paymentPayload.payload;
+      if (!solanaPayload || !solanaPayload.signedTransaction) {
+        return { valid: false, error: "Missing signed transaction" };
+      }
+      const chain = solanaPayload.chain || "solana_devnet";
+      const chainConfig = SOLANA_CHAINS[chain];
+      if (!chainConfig) {
+        return { valid: false, error: `Invalid chain: ${chain}` };
+      }
+      const txBuffer = Buffer.from(solanaPayload.signedTransaction, "base64");
+      let tx;
+      try {
+        tx = Transaction.from(txBuffer);
+      } catch {
+        tx = VersionedTransaction.deserialize(txBuffer);
+      }
+      if (tx instanceof Transaction) {
+        const hasAnySignature = tx.signatures.some(
+          (sig) => sig.signature && !sig.signature.every((b) => b === 0)
+        );
+        if (!hasAnySignature) {
+          return { valid: false, error: "Transaction not signed" };
+        }
+      }
+      const expectedAmount = BigInt(requirements.amount);
+      const expectedRecipient = new PublicKey3(requirements.payTo);
+      return {
+        valid: true,
+        details: {
+          chain,
+          sender: solanaPayload.sender,
+          recipient: requirements.payTo,
+          amount: requirements.amount
+        }
+      };
+    } catch (error) {
+      return { valid: false, error: error.message };
+    }
+  }
+  /**
+   * Settle a Solana payment
+   * 
+   * Submits the signed transaction to the network.
+   * In gasless mode, adds fee payer signature before submitting.
+   */
+  async settle(paymentPayload, requirements) {
+    try {
+      const solanaPayload = paymentPayload.payload;
+      if (!solanaPayload || !solanaPayload.signedTransaction) {
+        return { success: false, error: "Missing signed transaction" };
+      }
+      const chain = solanaPayload.chain || "solana_devnet";
+      const connection = this.getConnection(chain);
+      const txBuffer = Buffer.from(solanaPayload.signedTransaction, "base64");
+      let txToSend;
+      try {
+        const tx = Transaction.from(txBuffer);
+        if (this.feePayerKeypair && tx.feePayer) {
+          const feePayerPubkey = this.feePayerKeypair.publicKey.toBase58();
+          const txFeePayer = tx.feePayer.toBase58();
+          if (txFeePayer === feePayerPubkey) {
+            console.log(`[SolanaFacilitator] Gasless mode: adding fee payer signature`);
+            tx.partialSign(this.feePayerKeypair);
+          }
+        }
+        txToSend = tx.serialize();
+      } catch (e) {
+        txToSend = txBuffer;
+      }
+      const signature = await connection.sendRawTransaction(txToSend, {
+        skipPreflight: false,
+        preflightCommitment: "confirmed"
+      });
+      const confirmation = await connection.confirmTransaction(signature, "confirmed");
+      if (confirmation.value.err) {
+        return {
+          success: false,
+          error: `Transaction failed: ${JSON.stringify(confirmation.value.err)}`,
+          transaction: signature
+        };
+      }
+      return {
+        success: true,
+        transaction: signature,
+        status: "confirmed"
+      };
+    } catch (error) {
+      return { success: false, error: error.message };
+    }
+  }
+  supportsNetwork(network) {
+    return this.supportedNetworks.includes(network);
+  }
+};
+async function createSolanaPaymentTransaction(senderPubkey, recipientPubkey, amount, chain, feePayerPubkey) {
+  const chainConfig = SOLANA_CHAINS[chain];
+  const connection = new Connection3(chainConfig.rpc, "confirmed");
+  const mint = new PublicKey3(chainConfig.tokens.USDC.mint);
+  const actualFeePayer = feePayerPubkey || senderPubkey;
+  const senderATA = await getAssociatedTokenAddress2(mint, senderPubkey);
+  const recipientATA = await getAssociatedTokenAddress2(mint, recipientPubkey);
+  const transaction = new Transaction();
+  try {
+    await getAccount2(connection, 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 connection.getLatestBlockhash();
+  transaction.recentBlockhash = blockhash;
+  transaction.feePayer = actualFeePayer;
+  return transaction;
+}
+
+// src/client/index.ts
+import { PublicKey as PublicKey4 } from "@solana/web3.js";
+
 // src/client/types.ts
 init_esm_shims();
 
@@ -173,7 +597,7 @@ var MoltsPayClient = class {
   todaySpending = 0;
   lastSpendingReset = 0;
   constructor(options = {}) {
-    this.configDir = options.configDir || join(homedir(), ".moltspay");
+    this.configDir = options.configDir || join2(homedir2(), ".moltspay");
     this.config = this.loadConfig();
     this.walletData = this.loadWallet();
     this.loadSpending();
@@ -193,6 +617,12 @@ var MoltsPayClient = class {
   get address() {
     return this.wallet?.address || null;
   }
+  /**
+   * Get wallet instance (for direct operations like approvals)
+   */
+  getWallet() {
+    return this.wallet;
+  }
   /**
    * Get current config
    */
@@ -246,11 +676,26 @@ var MoltsPayClient = class {
       throw new Error("Client not initialized. Run: npx moltspay init");
     }
     console.log(`[MoltsPay] Requesting service: ${service}`);
-    const requestBody = { service, params };
+    let executeUrl = `${serverUrl}/execute`;
+    try {
+      const services = await this.getServices(serverUrl);
+      const svc = services.services?.find((s) => s.id === service);
+      if (svc?.endpoint) {
+        executeUrl = `${serverUrl}${svc.endpoint}`;
+        console.log(`[MoltsPay] Using service endpoint: ${svc.endpoint}`);
+      }
+    } catch {
+    }
+    let requestBody;
+    if (options.rawData) {
+      requestBody = { service, ...params };
+    } else {
+      requestBody = { service, params };
+    }
     if (options.chain) {
       requestBody.chain = options.chain;
     }
-    const initialRes = await fetch(`${serverUrl}/execute`, {
+    const initialRes = await fetch(executeUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(requestBody)
@@ -262,9 +707,14 @@ var MoltsPayClient = class {
       }
       throw new Error(data.error || "Unexpected response");
     }
+    const wwwAuthHeader = initialRes.headers.get("www-authenticate");
     const paymentRequiredHeader = initialRes.headers.get(PAYMENT_REQUIRED_HEADER);
+    if (wwwAuthHeader && wwwAuthHeader.toLowerCase().includes("payment")) {
+      console.log("[MoltsPay] Detected MPP protocol, using Tempo flow...");
+      return await this.handleMPPPayment(executeUrl, service, params, wwwAuthHeader, options);
+    }
     if (!paymentRequiredHeader) {
-      throw new Error("Missing x-payment-required header");
+      throw new Error("Missing payment header (x-payment-required or www-authenticate)");
     }
     let requirements;
     try {
@@ -281,17 +731,22 @@ var MoltsPayClient = class {
       throw new Error("Invalid x-payment-required header");
     }
     const networkToChainName = (network2) => {
+      if (network2 === "solana:mainnet") return "solana";
+      if (network2 === "solana:devnet") return "solana_devnet";
       const match = network2.match(/^eip155:(\d+)$/);
       if (!match) return null;
       const chainId = parseInt(match[1]);
       if (chainId === 8453) return "base";
       if (chainId === 137) return "polygon";
       if (chainId === 84532) return "base_sepolia";
+      if (chainId === 42431) return "tempo_moderato";
+      if (chainId === 56) return "bnb";
+      if (chainId === 97) return "bnb_testnet";
       return null;
     };
     const serverChains = requirements.map((r) => networkToChainName(r.network)).filter((c) => c !== null);
-    let chainName;
     const userSpecifiedChain = options.chain;
+    let selectedChain;
     if (userSpecifiedChain) {
       if (!serverChains.includes(userSpecifiedChain)) {
         throw new Error(
@@ -299,17 +754,27 @@ var MoltsPayClient = class {
 Server accepts: ${serverChains.join(", ")}`
         );
       }
-      chainName = userSpecifiedChain;
+      selectedChain = userSpecifiedChain;
     } else {
       if (serverChains.length === 1 && serverChains[0] === "base") {
-        chainName = "base";
+        selectedChain = "base";
       } else {
         throw new Error(
           `Server accepts: ${serverChains.join(", ")}
-Please specify: --chain base, --chain polygon, or --chain base_sepolia`
+Please specify: --chain <chain_name>`
         );
       }
     }
+    if (selectedChain === "solana" || selectedChain === "solana_devnet") {
+      const solanaChain = selectedChain;
+      const network2 = solanaChain === "solana" ? "solana:mainnet" : "solana:devnet";
+      const req2 = requirements.find((r) => r.network === network2);
+      if (!req2) {
+        throw new Error(`Failed to find payment requirement for ${selectedChain}`);
+      }
+      return await this.handleSolanaPayment(executeUrl, service, params, req2, solanaChain, options);
+    }
+    const chainName = selectedChain;
     const chain = getChain(chainName);
     const network = `eip155:${chain.chainId}`;
     const req = requirements.find((r) => r.scheme === "exact" && r.network === network);
@@ -344,6 +809,25 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
     } else {
       console.log(`[MoltsPay] Signing payment: $${amount} ${token} (gasless)`);
     }
+    if (chainName === "bnb" || chainName === "bnb_testnet") {
+      console.log(`[MoltsPay] Using BNB intent-based payment flow...`);
+      const payTo2 = req.payTo || req.resource;
+      if (!payTo2) {
+        throw new Error("Missing payTo address in payment requirements");
+      }
+      const bnbSpender = req.extra?.bnbSpender;
+      if (!bnbSpender) {
+        throw new Error("Server did not provide bnbSpender address. Server may not support BNB payments.");
+      }
+      return await this.handleBNBPayment(executeUrl, service, params, {
+        to: payTo2,
+        amount,
+        token,
+        chainName,
+        chain,
+        spender: bnbSpender
+      }, options);
+    }
     const payTo = req.payTo || req.resource;
     if (!payTo) {
       throw new Error("Missing payTo address in payment requirements");
@@ -373,11 +857,11 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
     };
     const paymentHeader = Buffer.from(JSON.stringify(payload)).toString("base64");
     console.log(`[MoltsPay] Sending request with payment...`);
-    const paidRequestBody = { service, params };
+    const paidRequestBody = options.rawData ? { service, ...params } : { service, params };
     if (options.chain) {
       paidRequestBody.chain = options.chain;
     }
-    const paidRes = await fetch(`${serverUrl}/execute`, {
+    const paidRes = await fetch(executeUrl, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -391,7 +875,304 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
     }
     this.recordSpending(amount);
     console.log(`[MoltsPay] Success! Payment: ${result.payment?.status || "claimed"}`);
-    return result.result;
+    return result.result || result;
+  }
+  /**
+   * Handle MPP (Machine Payments Protocol) payment flow
+   * Called when pay() detects WWW-Authenticate header in 402 response
+   */
+  async handleMPPPayment(executeUrl, service, params, wwwAuthHeader, options = {}) {
+    const { privateKeyToAccount: privateKeyToAccount2 } = await import("viem/accounts");
+    const { createWalletClient, createPublicClient, http } = await import("viem");
+    const { tempoModerato } = await import("viem/chains");
+    const { Actions } = await import("viem/tempo");
+    const privateKey = this.walletData.privateKey;
+    const account = privateKeyToAccount2(privateKey);
+    console.log(`[MoltsPay] Using MPP protocol on Tempo`);
+    console.log(`[MoltsPay] Account: ${account.address}`);
+    const parseAuthParam = (header, key) => {
+      const match = header.match(new RegExp(`${key}="([^"]+)"`, "i"));
+      return match ? match[1] : null;
+    };
+    const challengeId = parseAuthParam(wwwAuthHeader, "id");
+    const method = parseAuthParam(wwwAuthHeader, "method");
+    const realm = parseAuthParam(wwwAuthHeader, "realm");
+    const requestB64 = parseAuthParam(wwwAuthHeader, "request");
+    if (method !== "tempo") {
+      throw new Error(`Unsupported payment method: ${method}`);
+    }
+    if (!requestB64) {
+      throw new Error("Missing request in WWW-Authenticate");
+    }
+    const requestJson = Buffer.from(requestB64, "base64").toString("utf-8");
+    const paymentRequest = JSON.parse(requestJson);
+    const { amount, currency, recipient, methodDetails } = paymentRequest;
+    const chainId = methodDetails?.chainId || 42431;
+    const amountDisplay = Number(amount) / 1e6;
+    console.log(`[MoltsPay] Payment: $${amountDisplay} to ${recipient}`);
+    this.checkLimits(amountDisplay);
+    console.log(`[MoltsPay] Sending transaction on Tempo...`);
+    const tempoChain = { ...tempoModerato, feeToken: currency };
+    const publicClient = createPublicClient({
+      chain: tempoChain,
+      transport: http("https://rpc.moderato.tempo.xyz")
+    });
+    const walletClient = createWalletClient({
+      account,
+      chain: tempoChain,
+      transport: http("https://rpc.moderato.tempo.xyz")
+    });
+    const txHash = await Actions.token.transfer(walletClient, {
+      to: recipient,
+      amount: BigInt(amount),
+      token: currency
+    });
+    console.log(`[MoltsPay] Transaction: ${txHash}`);
+    await publicClient.waitForTransactionReceipt({ hash: txHash });
+    console.log(`[MoltsPay] Confirmed! Retrying with credential...`);
+    const credential = {
+      challenge: {
+        id: challengeId,
+        realm,
+        method: "tempo",
+        intent: "charge",
+        request: paymentRequest
+      },
+      payload: { hash: txHash, type: "hash" },
+      source: `did:pkh:eip155:${chainId}:${account.address}`
+    };
+    const credentialB64 = Buffer.from(JSON.stringify(credential)).toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+    const retryBody = options.rawData ? { service, ...params, chain: "tempo_moderato" } : { service, params, chain: "tempo_moderato" };
+    const paidRes = await fetch(executeUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Payment ${credentialB64}`
+      },
+      body: JSON.stringify(retryBody)
+    });
+    const result = await paidRes.json();
+    if (!paidRes.ok) {
+      throw new Error(result.error || "Payment verification failed");
+    }
+    this.recordSpending(amountDisplay);
+    console.log(`[MoltsPay] Success!`);
+    return result.result || result;
+  }
+  /**
+   * Handle BNB Chain payment flow (pre-approval + intent signature)
+   * 
+   * Flow:
+   * 1. Check client has approved server wallet (done via `moltspay init`)
+   * 2. Sign EIP-712 payment intent (no gas, just signature)
+   * 3. Send intent to server
+   * 4. Server executes service
+   * 5. Server calls transferFrom if successful (pay-for-success)
+   */
+  async handleBNBPayment(executeUrl, service, params, paymentDetails, options = {}) {
+    const { to, amount, token, chainName, chain, spender } = paymentDetails;
+    const tokenConfig = chain.tokens[token];
+    const provider = new ethers.JsonRpcProvider(chain.rpc);
+    const allowance = await this.checkAllowance(tokenConfig.address, spender, provider);
+    const amountWeiCheck = BigInt(Math.floor(amount * 10 ** tokenConfig.decimals));
+    if (allowance < amountWeiCheck) {
+      const nativeBalance = await provider.getBalance(this.wallet.address);
+      const minGasBalance = ethers.parseEther("0.0005");
+      if (nativeBalance < minGasBalance) {
+        const nativeBNB = parseFloat(ethers.formatEther(nativeBalance)).toFixed(4);
+        const isTestnet = chainName === "bnb_testnet";
+        if (isTestnet) {
+          throw new Error(
+            `\u274C Insufficient tBNB for approval transaction
+
+   Current tBNB: ${nativeBNB}
+   Required:     ~0.001 tBNB
+
+   Get testnet tokens: npx moltspay faucet --chain bnb_testnet
+   (Gives USDC + tBNB for gas)`
+          );
+        } else {
+          throw new Error(
+            `\u274C Insufficient BNB for approval transaction
+
+   Current BNB: ${nativeBNB}
+   Required:    ~0.001 BNB (~$0.60)
+
+   To get BNB:
+   \u2022 Withdraw from Binance/exchange to your wallet
+   \u2022 Most exchanges include BNB dust with withdrawals
+
+   After funding, run:
+   npx moltspay approve --chain ${chainName} --spender ${spender}`
+          );
+        }
+      }
+      throw new Error(
+        `Insufficient allowance for ${spender.slice(0, 10)}...
+Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
+      );
+    }
+    const amountWei = BigInt(Math.floor(amount * 10 ** tokenConfig.decimals)).toString();
+    const intent = {
+      from: this.wallet.address,
+      to,
+      amount: amountWei,
+      token: tokenConfig.address,
+      service,
+      nonce: Date.now(),
+      // Use timestamp as nonce for simplicity
+      deadline: Date.now() + 36e5
+      // 1 hour
+    };
+    const domain = {
+      name: "MoltsPay",
+      version: "1",
+      chainId: chain.chainId
+    };
+    const 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" }
+      ]
+    };
+    console.log(`[MoltsPay] Signing BNB payment intent...`);
+    const signature = await this.wallet.signTypedData(domain, types, intent);
+    const network = `eip155:${chain.chainId}`;
+    const payload = {
+      x402Version: 2,
+      scheme: "exact",
+      network,
+      payload: {
+        intent: {
+          ...intent,
+          signature
+        },
+        chainId: chain.chainId
+      },
+      accepted: {
+        scheme: "exact",
+        network,
+        asset: tokenConfig.address,
+        amount: amountWei,
+        payTo: to,
+        maxTimeoutSeconds: 300
+      }
+    };
+    const paymentHeader = Buffer.from(JSON.stringify(payload)).toString("base64");
+    console.log(`[MoltsPay] Sending BNB payment request...`);
+    const bnbRequestBody = options.rawData ? { service, ...params, chain: chainName } : { service, params, chain: chainName };
+    const paidRes = await fetch(executeUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Payment": paymentHeader
+      },
+      body: JSON.stringify(bnbRequestBody)
+    });
+    const result = await paidRes.json();
+    if (!paidRes.ok) {
+      throw new Error(result.error || "BNB payment failed");
+    }
+    this.recordSpending(amount);
+    console.log(`[MoltsPay] Success! BNB payment settled.`);
+    return result.result || result;
+  }
+  /**
+   * Handle Solana payment flow
+   * 
+   * Solana uses SPL token transfers with pay-for-success model:
+   * 1. Client creates and signs a transfer transaction
+   * 2. Server submits the transaction after service completes
+   */
+  async handleSolanaPayment(executeUrl, service, params, requirements, chain, options = {}) {
+    const solanaWallet = loadSolanaWallet(this.configDir);
+    if (!solanaWallet) {
+      throw new Error("No Solana wallet found. Run: npx moltspay init --chain solana_devnet");
+    }
+    const amount = Number(requirements.amount);
+    const amountUSDC = amount / 1e6;
+    this.checkLimits(amountUSDC);
+    console.log(`[MoltsPay] Creating Solana payment: $${amountUSDC} USDC`);
+    if (!requirements.payTo) {
+      throw new Error("Missing payTo address in payment requirements");
+    }
+    const solanaFeePayer = requirements.extra?.solanaFeePayer;
+    const feePayerPubkey = solanaFeePayer ? new PublicKey4(solanaFeePayer) : void 0;
+    if (feePayerPubkey) {
+      console.log(`[MoltsPay] Gasless mode: server pays fees`);
+    }
+    const recipientPubkey = new PublicKey4(requirements.payTo);
+    const transaction = await createSolanaPaymentTransaction(
+      solanaWallet.publicKey,
+      recipientPubkey,
+      BigInt(amount),
+      chain,
+      feePayerPubkey
+      // Optional fee payer for gasless mode
+    );
+    if (feePayerPubkey) {
+      transaction.partialSign(solanaWallet);
+    } else {
+      transaction.sign(solanaWallet);
+    }
+    const signedTx = transaction.serialize({ requireAllSignatures: false }).toString("base64");
+    console.log(`[MoltsPay] Transaction signed, sending to server...`);
+    const network = chain === "solana" ? "solana:mainnet" : "solana:devnet";
+    const payload = {
+      x402Version: 2,
+      scheme: "exact",
+      network,
+      payload: {
+        signedTransaction: signedTx,
+        sender: solanaWallet.publicKey.toBase58(),
+        chain
+      },
+      accepted: {
+        scheme: "exact",
+        network,
+        asset: requirements.asset,
+        amount: requirements.amount,
+        payTo: requirements.payTo,
+        maxTimeoutSeconds: 300
+      }
+    };
+    const paymentHeader = Buffer.from(JSON.stringify(payload)).toString("base64");
+    const solanaRequestBody = options.rawData ? { service, ...params, chain } : { service, params, chain };
+    const paidRes = await fetch(executeUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Payment": paymentHeader
+      },
+      body: JSON.stringify(solanaRequestBody)
+    });
+    const result = await paidRes.json();
+    if (!paidRes.ok) {
+      throw new Error(result.error || "Solana payment failed");
+    }
+    this.recordSpending(amountUSDC);
+    console.log(`[MoltsPay] Success! Solana payment settled.`);
+    if (result.payment?.transaction) {
+      const explorerUrl = chain === "solana" ? `https://solscan.io/tx/${result.payment.transaction}` : `https://solscan.io/tx/${result.payment.transaction}?cluster=devnet`;
+      console.log(`[MoltsPay] Transaction: ${explorerUrl}`);
+    }
+    return result.result || result;
+  }
+  /**
+   * Check ERC20 allowance for a spender
+   */
+  async checkAllowance(tokenAddress, spender, provider) {
+    const contract = new ethers.Contract(
+      tokenAddress,
+      ["function allowance(address owner, address spender) view returns (uint256)"],
+      provider
+    );
+    return await contract.allowance(this.wallet.address, spender);
   }
   /**
    * Sign EIP-3009 transferWithAuthorization (GASLESS)
@@ -463,26 +1244,26 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
   }
   // --- Config & Wallet Management ---
   loadConfig() {
-    const configPath = join(this.configDir, "config.json");
-    if (existsSync(configPath)) {
-      const content = readFileSync(configPath, "utf-8");
+    const configPath = join2(this.configDir, "config.json");
+    if (existsSync2(configPath)) {
+      const content = readFileSync2(configPath, "utf-8");
       return { ...DEFAULT_CONFIG, ...JSON.parse(content) };
     }
     return { ...DEFAULT_CONFIG };
   }
   saveConfig() {
-    mkdirSync(this.configDir, { recursive: true });
-    const configPath = join(this.configDir, "config.json");
-    writeFileSync(configPath, JSON.stringify(this.config, null, 2));
+    mkdirSync2(this.configDir, { recursive: true });
+    const configPath = join2(this.configDir, "config.json");
+    writeFileSync2(configPath, JSON.stringify(this.config, null, 2));
   }
   /**
    * Load spending data from disk
    */
   loadSpending() {
-    const spendingPath = join(this.configDir, "spending.json");
-    if (existsSync(spendingPath)) {
+    const spendingPath = join2(this.configDir, "spending.json");
+    if (existsSync2(spendingPath)) {
       try {
-        const data = JSON.parse(readFileSync(spendingPath, "utf-8"));
+        const data = JSON.parse(readFileSync2(spendingPath, "utf-8"));
         const today = (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0);
         if (data.date && data.date === today) {
           this.todaySpending = data.amount || 0;
@@ -501,18 +1282,18 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
    * Save spending data to disk
    */
   saveSpending() {
-    mkdirSync(this.configDir, { recursive: true });
-    const spendingPath = join(this.configDir, "spending.json");
+    mkdirSync2(this.configDir, { recursive: true });
+    const spendingPath = join2(this.configDir, "spending.json");
     const data = {
       date: this.lastSpendingReset || (/* @__PURE__ */ new Date()).setHours(0, 0, 0, 0),
       amount: this.todaySpending,
       updatedAt: Date.now()
     };
-    writeFileSync(spendingPath, JSON.stringify(data, null, 2));
+    writeFileSync2(spendingPath, JSON.stringify(data, null, 2));
   }
   loadWallet() {
-    const walletPath = join(this.configDir, "wallet.json");
-    if (existsSync(walletPath)) {
+    const walletPath = join2(this.configDir, "wallet.json");
+    if (existsSync2(walletPath)) {
       try {
         const stats = statSync(walletPath);
         const mode = stats.mode & 511;
@@ -523,7 +1304,7 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
         }
       } catch (err) {
       }
-      const content = readFileSync(walletPath, "utf-8");
+      const content = readFileSync2(walletPath, "utf-8");
       return JSON.parse(content);
     }
     return null;
@@ -532,15 +1313,15 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
    * Initialize a new wallet (called by CLI)
    */
   static init(configDir, options) {
-    mkdirSync(configDir, { recursive: true });
+    mkdirSync2(configDir, { recursive: true });
     const wallet = Wallet.createRandom();
     const walletData = {
       address: wallet.address,
       privateKey: wallet.privateKey,
       createdAt: Date.now()
     };
-    const walletPath = join(configDir, "wallet.json");
-    writeFileSync(walletPath, JSON.stringify(walletData, null, 2), { mode: 384 });
+    const walletPath = join2(configDir, "wallet.json");
+    writeFileSync2(walletPath, JSON.stringify(walletData, null, 2), { mode: 384 });
     const config = {
       chain: options.chain,
       limits: {
@@ -548,8 +1329,8 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
         maxPerDay: options.maxPerDay
       }
     };
-    const configPath = join(configDir, "config.json");
-    writeFileSync(configPath, JSON.stringify(config, null, 2));
+    const configPath = join2(configDir, "config.json");
+    writeFileSync2(configPath, JSON.stringify(config, null, 2));
     return { address: wallet.address, configDir };
   }
   /**
@@ -585,7 +1366,7 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
     if (!this.wallet) {
       throw new Error("Client not initialized");
     }
-    const supportedChains = ["base", "polygon", "base_sepolia", "tempo_moderato"];
+    const supportedChains = ["base", "polygon", "base_sepolia", "tempo_moderato", "bnb", "bnb_testnet"];
     const tokenAbi = ["function balanceOf(address) view returns (uint256)"];
     const results = {};
     const tempoTokens = {
@@ -656,12 +1437,12 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
     if (!this.wallet || !this.walletData) {
       throw new Error("Client not initialized. Run: npx moltspay init");
     }
-    const { privateKeyToAccount } = await import("viem/accounts");
+    const { privateKeyToAccount: privateKeyToAccount2 } = await import("viem/accounts");
     const { createWalletClient, createPublicClient, http } = await import("viem");
     const { tempoModerato } = await import("viem/chains");
     const { Actions } = await import("viem/tempo");
     const privateKey = this.walletData.privateKey;
-    const account = privateKeyToAccount(privateKey);
+    const account = privateKeyToAccount2(privateKey);
     console.log(`[MoltsPay] Making MPP request to: ${url}`);
     console.log(`[MoltsPay] Using account: ${account.address}`);
     const initResponse = await fetch(url, {
@@ -758,24 +1539,16 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
 
 // src/server/index.ts
 init_esm_shims();
-import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
+import { readFileSync as readFileSync4, existsSync as existsSync4 } from "fs";
 import { createServer } from "http";
 import * as path3 from "path";
 
 // src/facilitators/index.ts
 init_esm_shims();
 
-// src/facilitators/interface.ts
-init_esm_shims();
-var BaseFacilitator = class {
-  supportsNetwork(network) {
-    return this.supportedNetworks.includes(network);
-  }
-};
-
 // src/facilitators/cdp.ts
 init_esm_shims();
-import { readFileSync as readFileSync2, existsSync as existsSync2 } from "fs";
+import { readFileSync as readFileSync3, existsSync as existsSync3 } from "fs";
 import * as path2 from "path";
 var X402_VERSION2 = 2;
 var CDP_URL = "https://api.cdp.coinbase.com/platform/v2/x402";
@@ -786,9 +1559,9 @@ function loadEnvFile() {
     path2.join(process.env.HOME || "", ".moltspay", ".env")
   ];
   for (const envPath of envPaths) {
-    if (existsSync2(envPath)) {
+    if (existsSync3(envPath)) {
       try {
-        const content = readFileSync2(envPath, "utf-8");
+        const content = readFileSync3(envPath, "utf-8");
         for (const line of content.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -1024,18 +1797,280 @@ var TempoFacilitator = class extends BaseFacilitator {
       if (chainId !== 42431) {
         return { healthy: false, error: `Wrong chainId: ${chainId}` };
       }
-      return { healthy: true, latencyMs: Date.now() - start };
+      return { healthy: true, latencyMs: Date.now() - start };
+    } catch (error) {
+      return { healthy: false, error: String(error) };
+    }
+  }
+  async verify(paymentPayload, requirements) {
+    try {
+      const tempoPayload = paymentPayload.payload;
+      if (!tempoPayload?.txHash) {
+        return { valid: false, error: "Missing txHash in payment payload" };
+      }
+      const receipt = await this.getTransactionReceipt(tempoPayload.txHash);
+      if (!receipt) {
+        return { valid: false, error: "Transaction not found" };
+      }
+      if (receipt.status !== "0x1") {
+        return { valid: false, error: "Transaction failed" };
+      }
+      const transferLog = receipt.logs.find(
+        (log) => log.topics[0] === TRANSFER_EVENT_TOPIC
+      );
+      if (!transferLog) {
+        return { valid: false, error: "No Transfer event found" };
+      }
+      const toAddress = "0x" + transferLog.topics[2].slice(26).toLowerCase();
+      const expectedTo = requirements.payTo.toLowerCase();
+      if (toAddress !== expectedTo) {
+        return {
+          valid: false,
+          error: `Wrong recipient: ${toAddress}, expected ${expectedTo}`
+        };
+      }
+      const amount = BigInt(transferLog.data);
+      const expectedAmount = BigInt(requirements.amount);
+      if (amount < expectedAmount) {
+        return {
+          valid: false,
+          error: `Insufficient amount: ${amount}, expected ${expectedAmount}`
+        };
+      }
+      const tokenAddress = transferLog.address.toLowerCase();
+      const expectedToken = requirements.asset.toLowerCase();
+      if (tokenAddress !== expectedToken) {
+        return {
+          valid: false,
+          error: `Wrong token: ${tokenAddress}, expected ${expectedToken}`
+        };
+      }
+      return {
+        valid: true,
+        details: {
+          txHash: tempoPayload.txHash,
+          from: "0x" + transferLog.topics[1].slice(26),
+          to: toAddress,
+          amount: amount.toString(),
+          token: tokenAddress
+        }
+      };
+    } catch (error) {
+      return { valid: false, error: `Verification failed: ${error}` };
+    }
+  }
+  async settle(paymentPayload, requirements) {
+    const verifyResult = await this.verify(paymentPayload, requirements);
+    if (!verifyResult.valid) {
+      return { success: false, error: verifyResult.error };
+    }
+    const tempoPayload = paymentPayload.payload;
+    return {
+      success: true,
+      transaction: tempoPayload.txHash,
+      status: "settled"
+    };
+  }
+  async getTransactionReceipt(txHash) {
+    const response = await fetch(this.rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "eth_getTransactionReceipt",
+        params: [txHash],
+        id: 1
+      })
+    });
+    const data = await response.json();
+    return data.result;
+  }
+};
+
+// src/facilitators/bnb.ts
+init_esm_shims();
+import { privateKeyToAccount } from "viem/accounts";
+var TRANSFER_EVENT_TOPIC2 = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+var EIP712_DOMAIN = {
+  name: "MoltsPay",
+  version: "1"
+};
+var 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 BNBFacilitator = class extends BaseFacilitator {
+  name = "bnb";
+  displayName = "BNB Smart Chain";
+  supportedNetworks = ["eip155:56", "eip155:97"];
+  // Mainnet + Testnet
+  serverPrivateKey;
+  spenderAddress = null;
+  chainConfigs;
+  constructor(serverPrivateKey) {
+    super();
+    this.serverPrivateKey = serverPrivateKey || process.env.BNB_SERVER_PRIVATE_KEY || "";
+    if (this.serverPrivateKey) {
+      const key = this.serverPrivateKey.startsWith("0x") ? this.serverPrivateKey : `0x${this.serverPrivateKey}`;
+      const account = privateKeyToAccount(key);
+      this.spenderAddress = account.address;
+    }
+    this.chainConfigs = {
+      56: { rpc: CHAINS.bnb.rpc, chain: CHAINS.bnb },
+      97: { rpc: CHAINS.bnb_testnet.rpc, chain: CHAINS.bnb_testnet }
+    };
+  }
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      const response = await fetch(this.chainConfigs[56].rpc, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          jsonrpc: "2.0",
+          method: "eth_chainId",
+          params: [],
+          id: 1
+        })
+      });
+      const data = await response.json();
+      const chainId = parseInt(data.result, 16);
+      if (chainId !== 56) {
+        return { healthy: false, error: `Wrong chainId: ${chainId}` };
+      }
+      return { healthy: true, latencyMs: Date.now() - start };
+    } catch (error) {
+      return { healthy: false, error: String(error) };
+    }
+  }
+  /**
+   * Verify a payment intent signature (before service execution)
+   * 
+   * This verifies:
+   * 1. Signature is valid for the intent
+   * 2. Client has approved server wallet
+   * 3. Client has sufficient balance
+   * 4. Intent hasn't expired
+   */
+  async verify(paymentPayload, requirements) {
+    try {
+      const bnbPayload = paymentPayload.payload;
+      if (!bnbPayload?.intent) {
+        return { valid: false, error: "Missing intent in payment payload" };
+      }
+      const { intent, chainId } = bnbPayload;
+      const config = this.chainConfigs[chainId];
+      if (!config) {
+        return { valid: false, error: `Unsupported chainId: ${chainId}` };
+      }
+      if (intent.deadline < Date.now()) {
+        return { valid: false, error: "Intent expired" };
+      }
+      const recoveredAddress = await this.recoverIntentSigner(intent, chainId);
+      if (recoveredAddress.toLowerCase() !== intent.from.toLowerCase()) {
+        return { valid: false, error: "Invalid signature" };
+      }
+      if (intent.to.toLowerCase() !== requirements.payTo.toLowerCase()) {
+        return { valid: false, error: `Wrong recipient: ${intent.to}` };
+      }
+      if (BigInt(intent.amount) < BigInt(requirements.amount)) {
+        return { valid: false, error: `Insufficient amount: ${intent.amount}` };
+      }
+      if (intent.token.toLowerCase() !== requirements.asset.toLowerCase()) {
+        return { valid: false, error: `Wrong token: ${intent.token}` };
+      }
+      const serverAddress = await this.getServerAddress();
+      const allowance = await this.getAllowance(intent.from, serverAddress, intent.token, config.rpc);
+      if (BigInt(allowance) < BigInt(intent.amount)) {
+        return { valid: false, error: "Insufficient allowance. Run: npx moltspay init --chain bnb" };
+      }
+      const balance = await this.getBalance(intent.from, intent.token, config.rpc);
+      if (BigInt(balance) < BigInt(intent.amount)) {
+        return { valid: false, error: "Insufficient balance" };
+      }
+      return {
+        valid: true,
+        details: {
+          from: intent.from,
+          to: intent.to,
+          amount: intent.amount,
+          token: intent.token,
+          service: intent.service,
+          nonce: intent.nonce,
+          deadline: intent.deadline
+        }
+      };
+    } catch (error) {
+      return { valid: false, error: `Verification failed: ${error}` };
+    }
+  }
+  /**
+   * Settle a payment by executing transferFrom
+   * 
+   * This is called AFTER the service has been successfully delivered.
+   * Server pays gas, transfers tokens from client to provider.
+   */
+  async settle(paymentPayload, requirements) {
+    if (!this.serverPrivateKey) {
+      return { success: false, error: "Server wallet not configured (BNB_SERVER_PRIVATE_KEY)" };
+    }
+    try {
+      const verifyResult = await this.verify(paymentPayload, requirements);
+      if (!verifyResult.valid) {
+        return { success: false, error: verifyResult.error };
+      }
+      const bnbPayload = paymentPayload.payload;
+      const { intent, chainId } = bnbPayload;
+      const config = this.chainConfigs[chainId];
+      const txHash = await this.executeTransferFrom(
+        intent.from,
+        intent.to,
+        intent.amount,
+        intent.token,
+        config.rpc
+      );
+      return {
+        success: true,
+        transaction: txHash,
+        status: "settled"
+      };
     } catch (error) {
-      return { healthy: false, error: String(error) };
+      return { success: false, error: `Settlement failed: ${error}` };
     }
   }
-  async verify(paymentPayload, requirements) {
+  /**
+   * Check if client has approved the server wallet
+   */
+  async checkApproval(clientAddress, token, chainId) {
+    const config = this.chainConfigs[chainId];
+    if (!config) {
+      throw new Error(`Unsupported chainId: ${chainId}`);
+    }
+    const serverAddress = await this.getServerAddress();
+    const allowance = await this.getAllowance(clientAddress, serverAddress, token, config.rpc);
+    const minAllowance = BigInt("1000000000000000000000");
+    return {
+      approved: BigInt(allowance) >= minAllowance,
+      allowance
+    };
+  }
+  /**
+   * Verify a completed transaction (for checking past payments)
+   */
+  async verifyTransaction(txHash, expected, chainId) {
+    const config = this.chainConfigs[chainId];
+    if (!config) {
+      return { valid: false, error: `Unsupported chainId: ${chainId}` };
+    }
     try {
-      const tempoPayload = paymentPayload.payload;
-      if (!tempoPayload?.txHash) {
-        return { valid: false, error: "Missing txHash in payment payload" };
-      }
-      const receipt = await this.getTransactionReceipt(tempoPayload.txHash);
+      const receipt = await this.getTransactionReceipt(txHash, config.rpc);
       if (!receipt) {
         return { valid: false, error: "Transaction not found" };
       }
@@ -1043,63 +2078,117 @@ var TempoFacilitator = class extends BaseFacilitator {
         return { valid: false, error: "Transaction failed" };
       }
       const transferLog = receipt.logs.find(
-        (log) => log.topics[0] === TRANSFER_EVENT_TOPIC
+        (log) => log.topics[0] === TRANSFER_EVENT_TOPIC2 && log.address.toLowerCase() === expected.token.toLowerCase()
       );
       if (!transferLog) {
         return { valid: false, error: "No Transfer event found" };
       }
       const toAddress = "0x" + transferLog.topics[2].slice(26).toLowerCase();
-      const expectedTo = requirements.payTo.toLowerCase();
-      if (toAddress !== expectedTo) {
-        return {
-          valid: false,
-          error: `Wrong recipient: ${toAddress}, expected ${expectedTo}`
-        };
+      if (toAddress !== expected.to.toLowerCase()) {
+        return { valid: false, error: `Wrong recipient: ${toAddress}` };
       }
       const amount = BigInt(transferLog.data);
-      const expectedAmount = BigInt(requirements.amount);
-      if (amount < expectedAmount) {
-        return {
-          valid: false,
-          error: `Insufficient amount: ${amount}, expected ${expectedAmount}`
-        };
-      }
-      const tokenAddress = transferLog.address.toLowerCase();
-      const expectedToken = requirements.asset.toLowerCase();
-      if (tokenAddress !== expectedToken) {
-        return {
-          valid: false,
-          error: `Wrong token: ${tokenAddress}, expected ${expectedToken}`
-        };
+      if (amount < BigInt(expected.amount)) {
+        return { valid: false, error: `Insufficient amount: ${amount}` };
       }
       return {
         valid: true,
         details: {
-          txHash: tempoPayload.txHash,
+          txHash,
           from: "0x" + transferLog.topics[1].slice(26),
           to: toAddress,
           amount: amount.toString(),
-          token: tokenAddress
+          token: transferLog.address
         }
       };
     } catch (error) {
       return { valid: false, error: `Verification failed: ${error}` };
     }
   }
-  async settle(paymentPayload, requirements) {
-    const verifyResult = await this.verify(paymentPayload, requirements);
-    if (!verifyResult.valid) {
-      return { success: false, error: verifyResult.error };
-    }
-    const tempoPayload = paymentPayload.payload;
-    return {
-      success: true,
-      transaction: tempoPayload.txHash,
-      status: "settled"
+  // ==================== Private Methods ====================
+  /**
+   * Get the server's spender address (public, for 402 responses)
+   * Returns cached value computed at construction time.
+   */
+  getSpenderAddress() {
+    return this.spenderAddress;
+  }
+  async getServerAddress() {
+    const { ethers: ethers3 } = await import("ethers");
+    const wallet = new ethers3.Wallet(this.serverPrivateKey);
+    return wallet.address;
+  }
+  async recoverIntentSigner(intent, chainId) {
+    const { ethers: ethers3 } = await import("ethers");
+    const domain = {
+      ...EIP712_DOMAIN,
+      chainId
+    };
+    const message = {
+      from: intent.from,
+      to: intent.to,
+      amount: intent.amount,
+      token: intent.token,
+      service: intent.service,
+      nonce: intent.nonce,
+      deadline: intent.deadline
     };
+    const recoveredAddress = ethers3.verifyTypedData(
+      domain,
+      INTENT_TYPES,
+      message,
+      intent.signature
+    );
+    return recoveredAddress;
   }
-  async getTransactionReceipt(txHash) {
-    const response = await fetch(this.rpcUrl, {
+  async getAllowance(owner, spender, token, rpcUrl) {
+    const selector = "0xdd62ed3e";
+    const ownerPadded = owner.toLowerCase().replace("0x", "").padStart(64, "0");
+    const spenderPadded = spender.toLowerCase().replace("0x", "").padStart(64, "0");
+    const data = selector + ownerPadded + spenderPadded;
+    const response = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "eth_call",
+        params: [{ to: token, data }, "latest"],
+        id: 1
+      })
+    });
+    const result = await response.json();
+    return result.result || "0x0";
+  }
+  async getBalance(account, token, rpcUrl) {
+    const selector = "0x70a08231";
+    const accountPadded = account.toLowerCase().replace("0x", "").padStart(64, "0");
+    const data = selector + accountPadded;
+    const response = await fetch(rpcUrl, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        jsonrpc: "2.0",
+        method: "eth_call",
+        params: [{ to: token, data }, "latest"],
+        id: 1
+      })
+    });
+    const result = await response.json();
+    return result.result || "0x0";
+  }
+  async executeTransferFrom(from, to, amount, token, rpcUrl) {
+    const { ethers: ethers3 } = await import("ethers");
+    const provider = new ethers3.JsonRpcProvider(rpcUrl);
+    const wallet = new ethers3.Wallet(this.serverPrivateKey, provider);
+    const tokenContract = new ethers3.Contract(token, [
+      "function transferFrom(address from, address to, uint256 amount) returns (bool)"
+    ], wallet);
+    const tx = await tokenContract.transferFrom(from, to, amount);
+    const receipt = await tx.wait();
+    return receipt.hash;
+  }
+  async getTransactionReceipt(txHash, rpcUrl) {
+    const response = await fetch(rpcUrl, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
@@ -1116,6 +2205,8 @@ var TempoFacilitator = class extends BaseFacilitator {
 
 // src/facilitators/registry.ts
 init_esm_shims();
+import { Keypair as Keypair4 } from "@solana/web3.js";
+import bs582 from "bs58";
 var FacilitatorRegistry = class {
   factories = /* @__PURE__ */ new Map();
   instances = /* @__PURE__ */ new Map();
@@ -1124,7 +2215,20 @@ var FacilitatorRegistry = class {
   constructor(selection) {
     this.registerFactory("cdp", (config) => new CDPFacilitator(config));
     this.registerFactory("tempo", () => new TempoFacilitator());
-    this.selection = selection || { primary: "cdp", fallback: ["tempo"], strategy: "failover" };
+    this.registerFactory("bnb", (config) => new BNBFacilitator(config?.serverPrivateKey));
+    this.registerFactory("solana", (config) => {
+      let feePayerKeypair;
+      const feePayerKey = config?.feePayerPrivateKey || process.env.SOLANA_FEE_PAYER_KEY;
+      if (feePayerKey) {
+        try {
+          feePayerKeypair = Keypair4.fromSecretKey(bs582.decode(feePayerKey));
+        } catch (e) {
+          console.warn(`[SolanaFacilitator] Invalid fee payer key: ${e.message}`);
+        }
+      }
+      return new SolanaFacilitator({ feePayerKeypair });
+    });
+    this.selection = selection || { primary: "cdp", fallback: ["tempo", "bnb", "solana"], strategy: "failover" };
   }
   /**
    * Register a new facilitator factory
@@ -1371,14 +2475,40 @@ var TOKEN_ADDRESSES = {
     // pathUSD
     USDT: "0x20c0000000000000000000000000000000000001"
     // alphaUSD
+  },
+  // BNB Smart Chain mainnet
+  "eip155:56": {
+    USDC: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+    USDT: "0x55d398326f99059fF775485246999027B3197955"
+  },
+  // BNB Smart Chain testnet
+  "eip155:97": {
+    USDC: "0x64544969ed7EBf5f083679233325356EbE738930",
+    USDT: "0x337610d27c682E347C9cD60BD4b3b107C9d34dDd"
+  },
+  // Solana networks use mint addresses (SPL tokens)
+  "solana:mainnet": {
+    USDC: "EPjFWdd5AufqSSqeM2qN1xzybapC8G4wEGGkZwyTDt1v"
+    // Circle USDC
+  },
+  "solana:devnet": {
+    USDC: "4zMMC9srt5Ri5X14GAgXhaHii3GnPAEERYPJgZJDncDU"
+    // Devnet USDC
   }
 };
 var CHAIN_TO_NETWORK = {
   "base": "eip155:8453",
   "base_sepolia": "eip155:84532",
   "polygon": "eip155:137",
-  "tempo_moderato": "eip155:42431"
+  "tempo_moderato": "eip155:42431",
+  "bnb": "eip155:56",
+  "bnb_testnet": "eip155:97",
+  "solana": "solana:mainnet",
+  "solana_devnet": "solana:devnet"
 };
+function isSolanaNetwork(network) {
+  return network.startsWith("solana:");
+}
 var TOKEN_DOMAINS = {
   // Base mainnet
   "eip155:8453": {
@@ -1400,6 +2530,16 @@ var TOKEN_DOMAINS = {
   "eip155:42431": {
     USDC: { name: "pathUSD", version: "1" },
     USDT: { name: "alphaUSD", version: "1" }
+  },
+  // BNB Smart Chain mainnet
+  "eip155:56": {
+    USDC: { name: "USD Coin", version: "1" },
+    USDT: { name: "Tether USD", version: "1" }
+  },
+  // BNB Smart Chain testnet
+  "eip155:97": {
+    USDC: { name: "USD Coin", version: "1" },
+    USDT: { name: "Tether USD", version: "1" }
   }
 };
 function getTokenDomain(network, token) {
@@ -1415,9 +2555,9 @@ function loadEnvFile2() {
     path3.join(process.env.HOME || "", ".moltspay", ".env")
   ];
   for (const envPath of envPaths) {
-    if (existsSync3(envPath)) {
+    if (existsSync4(envPath)) {
       try {
-        const content = readFileSync3(envPath, "utf-8");
+        const content = readFileSync4(envPath, "utf-8");
         for (const line of content.split("\n")) {
           const trimmed = line.trim();
           if (!trimmed || trimmed.startsWith("#")) continue;
@@ -1448,7 +2588,7 @@ var MoltsPayServer = class {
   useMainnet;
   constructor(servicesPath, options = {}) {
     loadEnvFile2();
-    const content = readFileSync3(servicesPath, "utf-8");
+    const content = readFileSync4(servicesPath, "utf-8");
     this.manifest = JSON.parse(content);
     this.options = {
       port: options.port || 3e3,
@@ -1457,7 +2597,7 @@ var MoltsPayServer = class {
     };
     this.useMainnet = process.env.USE_MAINNET?.toLowerCase() === "true";
     this.networkId = this.useMainnet ? "eip155:8453" : "eip155:84532";
-    const defaultFallback = ["tempo"];
+    const defaultFallback = ["tempo", "bnb", "solana"];
     const envFallback = process.env.FACILITATOR_FALLBACK?.split(",").filter(Boolean);
     const facilitatorConfig = options.facilitators || {
       primary: process.env.FACILITATOR_PRIMARY || "cdp",
@@ -1500,12 +2640,20 @@ var MoltsPayServer = class {
    */
   getProviderChains() {
     const provider = this.manifest.provider;
+    const getWalletForChain = (chainName, explicitWallet) => {
+      if (explicitWallet) return explicitWallet;
+      if ((chainName === "solana" || chainName === "solana_devnet") && provider.solana_wallet) {
+        return provider.solana_wallet;
+      }
+      return provider.wallet;
+    };
     if (provider.chains && provider.chains.length > 0) {
       return provider.chains.map((c) => {
         const chainName = typeof c === "string" ? c : c.chain;
+        const explicitWallet = typeof c === "object" ? c.wallet : null;
         return {
           network: CHAIN_TO_NETWORK[chainName] || "eip155:8453",
-          wallet: (typeof c === "object" ? c.wallet : null) || provider.wallet,
+          wallet: getWalletForChain(chainName, explicitWallet || void 0),
           tokens: (typeof c === "object" ? c.tokens : null) || ["USDC"]
         };
       });
@@ -1514,7 +2662,7 @@ var MoltsPayServer = class {
     const network = CHAIN_TO_NETWORK[chain] || this.networkId;
     return [{
       network,
-      wallet: provider.wallet,
+      wallet: getWalletForChain(chain),
       tokens: ["USDC"]
     }];
   }
@@ -1585,7 +2733,8 @@ var MoltsPayServer = class {
         }
         const body = await this.readBody(req);
         const paymentHeader = req.headers[PAYMENT_HEADER2];
-        return await this.handleProxy(body, paymentHeader, res);
+        const authHeader = req.headers[MPP_AUTH_HEADER];
+        return await this.handleProxy(body, paymentHeader, authHeader, res);
       }
       const servicePath = url.pathname.replace(/^\//, "");
       const skill = this.skills.get(servicePath);
@@ -1622,7 +2771,9 @@ var MoltsPayServer = class {
         name: this.manifest.provider.name,
         description: this.manifest.provider.description,
         wallet: this.manifest.provider.wallet,
-        chain: this.manifest.provider.chain || "base"
+        chain: this.manifest.provider.chain || "base",
+        solana_wallet: this.manifest.provider.solana_wallet,
+        chains: this.manifest.provider.chains
       },
       services,
       endpoints: {
@@ -1735,6 +2886,21 @@ var MoltsPayServer = class {
       });
     }
     console.log(`[MoltsPay] Verified by ${verifyResult.facilitator}`);
+    const isSolana = isSolanaNetwork(paymentNetwork);
+    let settlement = null;
+    if (isSolana) {
+      console.log(`[MoltsPay] Solana detected - settling payment FIRST (blockhash expiry protection)`);
+      try {
+        settlement = await this.registry.settle(payment, requirements);
+        console.log(`[MoltsPay] Payment settled by ${settlement.facilitator}: ${settlement.transaction || "pending"}`);
+      } catch (err) {
+        console.error("[MoltsPay] Solana settlement failed:", err.message);
+        return this.sendJson(res, 402, {
+          error: "Payment settlement failed",
+          message: err.message
+        });
+      }
+    }
     const timeoutSeconds = parseInt(process.env.SKILL_TIMEOUT_SECONDS || "1200");
     console.log(`[MoltsPay] Executing skill: ${service} (timeout: ${timeoutSeconds}s)`);
     let result;
@@ -1749,16 +2915,19 @@ var MoltsPayServer = class {
       console.error("[MoltsPay] Skill execution failed:", err.message);
       return this.sendJson(res, 500, {
         error: "Service execution failed",
-        message: err.message
+        message: err.message,
+        paymentSettled: isSolana ? true : false,
+        note: isSolana ? "Payment was settled before execution. Contact support for refund." : void 0
       });
     }
-    console.log(`[MoltsPay] Skill succeeded, settling payment...`);
-    let settlement = null;
-    try {
-      settlement = await this.registry.settle(payment, requirements);
-      console.log(`[MoltsPay] Payment settled by ${settlement.facilitator}: ${settlement.transaction || "pending"}`);
-    } catch (err) {
-      console.error("[MoltsPay] Settlement failed:", err.message);
+    if (!isSolana) {
+      console.log(`[MoltsPay] Skill succeeded, settling payment...`);
+      try {
+        settlement = await this.registry.settle(payment, requirements);
+        console.log(`[MoltsPay] Payment settled by ${settlement.facilitator}: ${settlement.transaction || "pending"}`);
+      } catch (err) {
+        console.error("[MoltsPay] Settlement failed:", err.message);
+      }
     }
     const responseHeaders = {};
     if (settlement?.success) {
@@ -2034,7 +3203,7 @@ var MoltsPayServer = class {
     const tokenAddresses = TOKEN_ADDRESSES[selectedNetwork] || {};
     const tokenAddress = tokenAddresses[selectedToken];
     const tokenDomain = getTokenDomain(selectedNetwork, selectedToken);
-    return {
+    const requirements = {
       scheme: "exact",
       network: selectedNetwork,
       asset: tokenAddress,
@@ -2043,6 +3212,27 @@ var MoltsPayServer = class {
       maxTimeoutSeconds: 300,
       extra: tokenDomain
     };
+    if (selectedNetwork === "solana:mainnet" || selectedNetwork === "solana:devnet") {
+      const solanaFacilitator = this.registry.get("solana");
+      const feePayerPubkey = solanaFacilitator?.getFeePayerPubkey?.();
+      if (feePayerPubkey) {
+        requirements.extra = {
+          ...requirements.extra || {},
+          solanaFeePayer: feePayerPubkey
+        };
+      }
+    }
+    if (selectedNetwork === "eip155:56" || selectedNetwork === "eip155:97") {
+      const bnbFacilitator = this.registry.get("bnb");
+      const spenderAddress = bnbFacilitator?.getSpenderAddress?.();
+      if (spenderAddress) {
+        requirements.extra = {
+          ...requirements.extra || {},
+          bnbSpender: spenderAddress
+        };
+      }
+    }
+    return requirements;
   }
   /**
    * Detect which token is being used in the payment
@@ -2095,8 +3285,10 @@ var MoltsPayServer = class {
   isProxyAllowed(clientIP) {
     const allowedIPs = process.env.PROXY_ALLOWED_IPS?.split(",").map((ip) => ip.trim()) || [];
     if (allowedIPs.length === 0) {
-      console.log(`[MoltsPay] /proxy denied: no PROXY_ALLOWED_IPS configured`);
-      return false;
+      return true;
+    }
+    if (allowedIPs.includes("*")) {
+      return true;
     }
     const normalizedIP = clientIP === "::1" ? "127.0.0.1" : clientIP.replace("::ffff:", "");
     const allowed = allowedIPs.includes(normalizedIP) || allowedIPs.includes(clientIP);
@@ -2108,31 +3300,42 @@ var MoltsPayServer = class {
   /**
    * POST /proxy - Handle payment for external services (moltspay-creators)
    * 
-   * This endpoint allows other services to delegate x402 payment handling.
+   * This endpoint allows other services to delegate x402/MPP payment handling.
    * It does NOT execute any skill - just handles payment verification/settlement.
    * 
    * Request body:
    *   { wallet, amount, currency, chain, memo, serviceId, description }
    * 
-   * Without X-Payment header: returns 402 with payment requirements
-   * With X-Payment header: verifies payment and returns result
+   * For x402 (base, polygon, base_sepolia):
+   *   Without X-Payment header: returns 402 with X-Payment-Required
+   *   With X-Payment header: verifies payment via CDP
+   * 
+   * For MPP (tempo_moderato):
+   *   Without Authorization header: returns 402 with WWW-Authenticate
+   *   With Authorization: Payment header: verifies tx on Tempo chain
    */
-  async handleProxy(body, paymentHeader, res) {
+  async handleProxy(body, paymentHeader, authHeader, res) {
     const { wallet, amount, currency, chain, memo, serviceId, description } = body;
     if (!wallet || !amount) {
       return this.sendJson(res, 400, { error: "Missing required fields: wallet, amount" });
     }
-    if (!/^0x[a-fA-F0-9]{40}$/.test(wallet)) {
-      return this.sendJson(res, 400, { error: "Invalid wallet address format" });
+    const supportedChains = ["base", "polygon", "base_sepolia", "tempo_moderato", "bnb", "bnb_testnet", "solana", "solana_devnet"];
+    if (chain && !supportedChains.includes(chain)) {
+      return this.sendJson(res, 400, { error: `Unsupported chain: ${chain}. Supported: ${supportedChains.join(", ")}` });
+    }
+    const isSolanaChain = chain === "solana" || chain === "solana_devnet";
+    const isValidEvmAddress = /^0x[a-fA-F0-9]{40}$/.test(wallet);
+    const isValidSolanaAddress2 = /^[1-9A-HJ-NP-Za-km-z]{32,44}$/.test(wallet);
+    if (isSolanaChain && !isValidSolanaAddress2) {
+      return this.sendJson(res, 400, { error: "Invalid Solana wallet address format" });
+    }
+    if (!isSolanaChain && !isValidEvmAddress) {
+      return this.sendJson(res, 400, { error: "Invalid EVM wallet address format" });
     }
     const amountNum = parseFloat(amount);
     if (isNaN(amountNum) || amountNum <= 0) {
       return this.sendJson(res, 400, { error: "Invalid amount" });
     }
-    const supportedChains = ["base", "polygon", "base_sepolia"];
-    if (chain && !supportedChains.includes(chain)) {
-      return this.sendJson(res, 400, { error: `Unsupported chain: ${chain}. Supported: ${supportedChains.join(", ")}` });
-    }
     const proxyConfig = {
       id: serviceId || "proxy",
       name: description || "Proxy Payment",
@@ -2144,6 +3347,9 @@ var MoltsPayServer = class {
       input: {},
       output: {}
     };
+    if (chain === "tempo_moderato") {
+      return await this.handleProxyMPP(body, proxyConfig, authHeader, res);
+    }
     const requirements = this.buildProxyPaymentRequirements(proxyConfig, wallet, currency, chain);
     if (!paymentHeader) {
       return this.sendProxyPaymentRequired(proxyConfig, wallet, memo, chain, res);
@@ -2155,37 +3361,225 @@ var MoltsPayServer = class {
     } catch {
       return this.sendJson(res, 400, { error: "Invalid X-Payment header" });
     }
-    if (payment.x402Version !== X402_VERSION3) {
-      return this.sendJson(res, 402, { error: `Unsupported x402 version: ${payment.x402Version}` });
+    if (payment.x402Version !== X402_VERSION3) {
+      return this.sendJson(res, 402, { error: `Unsupported x402 version: ${payment.x402Version}` });
+    }
+    const scheme = payment.accepted?.scheme || payment.scheme;
+    const network = payment.accepted?.network || payment.network;
+    if (scheme !== "exact") {
+      return this.sendJson(res, 402, { error: `Unsupported scheme: ${scheme}` });
+    }
+    const expectedNetwork = chain ? CHAIN_TO_NETWORK[chain] || this.networkId : this.networkId;
+    if (network !== expectedNetwork) {
+      return this.sendJson(res, 402, { error: `Network mismatch: expected ${expectedNetwork}, got ${network}` });
+    }
+    console.log(`[MoltsPay] /proxy: Verifying payment for ${wallet}...`);
+    const verifyResult = await this.registry.verify(payment, requirements);
+    if (!verifyResult.valid) {
+      return this.sendJson(res, 402, {
+        success: false,
+        error: `Payment verification failed: ${verifyResult.error}`,
+        facilitator: verifyResult.facilitator
+      });
+    }
+    console.log(`[MoltsPay] /proxy: Verified by ${verifyResult.facilitator}`);
+    const { execute, service, params } = body;
+    if (execute && service) {
+      const skill = this.skills.get(service);
+      if (!skill) {
+        console.log(`[MoltsPay] /proxy: Service not found: ${service} - NOT settling`);
+        return this.sendJson(res, 404, {
+          success: false,
+          paymentSettled: false,
+          error: `Service not found: ${service}`
+        });
+      }
+      const isSolana = isSolanaNetwork(network);
+      let settlement2 = null;
+      if (isSolana) {
+        console.log(`[MoltsPay] /proxy: Solana detected - settling payment FIRST`);
+        try {
+          settlement2 = await this.registry.settle(payment, requirements);
+          console.log(`[MoltsPay] /proxy: Payment settled by ${settlement2.facilitator}: ${settlement2.transaction || "pending"}`);
+          if (!settlement2.success) {
+            console.error(`[MoltsPay] /proxy: Solana settlement failed: ${settlement2.error}`);
+            return this.sendJson(res, 402, {
+              success: false,
+              paymentSettled: false,
+              error: `Payment settlement failed: ${settlement2.error || "Unknown error"}`
+            });
+          }
+        } catch (err) {
+          console.error("[MoltsPay] /proxy: Solana settlement failed:", err.message);
+          return this.sendJson(res, 402, {
+            success: false,
+            paymentSettled: false,
+            error: `Payment settlement failed: ${err.message}`
+          });
+        }
+      } else {
+        console.log(`[MoltsPay] /proxy: Executing skill first (pay on success): ${service}`);
+      }
+      const timeoutSeconds = parseInt(process.env.SKILL_TIMEOUT_SECONDS || "1200");
+      let result;
+      try {
+        result = await Promise.race([
+          skill.handler(params || {}),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error(`Skill timeout after ${timeoutSeconds}s`)), timeoutSeconds * 1e3)
+          )
+        ]);
+        console.log(`[MoltsPay] /proxy: Skill succeeded`);
+      } catch (err) {
+        console.error(`[MoltsPay] /proxy: Skill failed: ${err.message}`);
+        return this.sendJson(res, 500, {
+          success: false,
+          paymentSettled: isSolana ? true : false,
+          error: `Service execution failed: ${err.message}`,
+          note: isSolana ? "Payment was settled before execution. Contact support for refund." : void 0
+        });
+      }
+      if (!isSolana) {
+        console.log(`[MoltsPay] /proxy: Settling payment...`);
+        try {
+          settlement2 = await this.registry.settle(payment, requirements);
+          console.log(`[MoltsPay] /proxy: Payment settled by ${settlement2.facilitator}: ${settlement2.transaction || "pending"}`);
+        } catch (err) {
+          console.error("[MoltsPay] /proxy: Settlement failed:", err.message);
+          return this.sendJson(res, 200, {
+            success: true,
+            verified: true,
+            settled: false,
+            settlementError: err.message,
+            from: payment.payload?.authorization?.from,
+            paidTo: wallet,
+            amount: amountNum,
+            currency: currency || "USDC",
+            memo,
+            result
+          });
+        }
+      }
+      return this.sendJson(res, 200, {
+        success: true,
+        verified: true,
+        settled: settlement2?.success || false,
+        txHash: settlement2?.transaction,
+        from: payment.payload?.authorization?.from,
+        paidTo: wallet,
+        amount: amountNum,
+        currency: currency || "USDC",
+        facilitator: settlement2?.facilitator,
+        memo,
+        result
+      });
+    }
+    console.log(`[MoltsPay] /proxy: Settling payment (no execution)...`);
+    let settlement = null;
+    try {
+      settlement = await this.registry.settle(payment, requirements);
+      console.log(`[MoltsPay] /proxy: Payment settled by ${settlement.facilitator}: ${settlement.transaction || "pending"}`);
+    } catch (err) {
+      console.error("[MoltsPay] /proxy: Settlement failed:", err.message);
+      return this.sendJson(res, 500, {
+        success: false,
+        error: `Settlement failed: ${err.message}`
+      });
+    }
+    this.sendJson(res, 200, {
+      success: true,
+      verified: true,
+      settled: settlement?.success || false,
+      txHash: settlement?.transaction,
+      from: payment.payload?.authorization?.from,
+      // Buyer's wallet address
+      paidTo: wallet,
+      amount: amountNum,
+      currency: currency || "USDC",
+      facilitator: settlement?.facilitator,
+      memo
+    });
+  }
+  /**
+   * Handle MPP payment flow for /proxy endpoint (tempo_moderato chain)
+   */
+  async handleProxyMPP(body, config, authHeader, res) {
+    const { wallet, amount, memo, serviceId } = body;
+    const amountNum = parseFloat(amount);
+    const amountInUnits = Math.floor(amountNum * 1e6).toString();
+    if (!authHeader || !authHeader.toLowerCase().startsWith("payment ")) {
+      const challengeId = this.generateChallengeId();
+      const tokenAddress = TOKEN_ADDRESSES["eip155:42431"]?.USDC || "0x20c0000000000000000000000000000000000000";
+      const mppRequest = {
+        amount: amountInUnits,
+        currency: tokenAddress,
+        methodDetails: {
+          chainId: 42431,
+          feePayer: true
+        },
+        recipient: wallet
+      };
+      const mppRequestEncoded = Buffer.from(JSON.stringify(mppRequest)).toString("base64");
+      const expiresAt = new Date(Date.now() + 5 * 60 * 1e3).toISOString();
+      const wwwAuth = `Payment id="${challengeId}", realm="MoltsPay Proxy", method="tempo", intent="charge", request="${mppRequestEncoded}", description="${config.name}", expires="${expiresAt}"`;
+      res.writeHead(402, {
+        "Content-Type": "application/problem+json",
+        [MPP_WWW_AUTH_HEADER]: wwwAuth
+      });
+      res.end(JSON.stringify({
+        type: "https://paymentauth.org/problems/payment-required",
+        title: "Payment Required",
+        status: 402,
+        detail: `Payment is required (${config.name}).`,
+        service: serviceId || "proxy",
+        price: amountNum,
+        currency: "USDC"
+      }, null, 2));
+      return;
+    }
+    const credentialMatch = authHeader.match(/Payment\s+(.+)/i);
+    if (!credentialMatch) {
+      return this.sendJson(res, 400, { error: "Invalid Authorization header format" });
     }
-    const scheme = payment.accepted?.scheme || payment.scheme;
-    const network = payment.accepted?.network || payment.network;
-    if (scheme !== "exact") {
-      return this.sendJson(res, 402, { error: `Unsupported scheme: ${scheme}` });
+    let mppCredential;
+    try {
+      const base64 = credentialMatch[1].replace(/-/g, "+").replace(/_/g, "/");
+      const decoded = Buffer.from(base64, "base64").toString("utf-8");
+      mppCredential = JSON.parse(decoded);
+    } catch (err) {
+      console.error("[MoltsPay] /proxy MPP: Failed to parse credential:", err);
+      return this.sendJson(res, 400, { error: "Invalid payment credential encoding" });
     }
-    const expectedNetwork = chain ? CHAIN_TO_NETWORK[chain] || this.networkId : this.networkId;
-    if (network !== expectedNetwork) {
-      return this.sendJson(res, 402, { error: `Network mismatch: expected ${expectedNetwork}, got ${network}` });
+    let txHash;
+    if (mppCredential.payload?.type === "hash" && mppCredential.payload?.hash) {
+      txHash = mppCredential.payload.hash;
+    } else {
+      return this.sendJson(res, 400, { error: "Missing transaction hash in credential" });
     }
-    console.log(`[MoltsPay] /proxy: Verifying payment for ${wallet}...`);
-    const verifyResult = await this.registry.verify(payment, requirements);
-    if (!verifyResult.valid) {
+    console.log(`[MoltsPay] /proxy MPP: Verifying tx ${txHash} on Tempo...`);
+    const requirements = this.buildPaymentRequirements(config, "eip155:42431", wallet, "USDC");
+    const paymentPayload = {
+      x402Version: X402_VERSION3,
+      scheme: "exact",
+      network: "eip155:42431",
+      payload: { txHash, chainId: 42431 }
+    };
+    const verification = await this.registry.verify(paymentPayload, requirements);
+    if (!verification.valid) {
       return this.sendJson(res, 402, {
-        success: false,
-        error: `Payment verification failed: ${verifyResult.error}`,
-        facilitator: verifyResult.facilitator
+        error: `Payment verification failed: ${verification.error}`
       });
     }
-    console.log(`[MoltsPay] /proxy: Verified by ${verifyResult.facilitator}`);
+    console.log(`[MoltsPay] /proxy MPP: Payment verified by ${verification.facilitator}`);
     const { execute, service, params } = body;
     if (execute && service) {
-      console.log(`[MoltsPay] /proxy: Executing skill first (pay on success): ${service}`);
+      console.log(`[MoltsPay] /proxy MPP: Executing skill: ${service}`);
       const skill = this.skills.get(service);
       if (!skill) {
-        console.log(`[MoltsPay] /proxy: Service not found: ${service} - NOT settling`);
         return this.sendJson(res, 404, {
           success: false,
-          paymentSettled: false,
+          paymentSettled: true,
+          // Payment already happened on Tempo
           error: `Service not found: ${service}`
         });
       }
@@ -2198,73 +3592,36 @@ var MoltsPayServer = class {
             (_, reject) => setTimeout(() => reject(new Error(`Skill timeout after ${timeoutSeconds}s`)), timeoutSeconds * 1e3)
           )
         ]);
-        console.log(`[MoltsPay] /proxy: Skill succeeded, now settling payment...`);
       } catch (err) {
-        console.error(`[MoltsPay] /proxy: Skill failed: ${err.message} - NOT settling`);
+        console.error(`[MoltsPay] /proxy MPP: Skill failed: ${err.message}`);
         return this.sendJson(res, 500, {
           success: false,
-          paymentSettled: false,
+          paymentSettled: true,
           error: `Service execution failed: ${err.message}`
         });
       }
-      let settlement2 = null;
-      try {
-        settlement2 = await this.registry.settle(payment, requirements);
-        console.log(`[MoltsPay] /proxy: Payment settled by ${settlement2.facilitator}: ${settlement2.transaction || "pending"}`);
-      } catch (err) {
-        console.error("[MoltsPay] /proxy: Settlement failed:", err.message);
-        return this.sendJson(res, 200, {
-          success: true,
-          verified: true,
-          settled: false,
-          settlementError: err.message,
-          from: payment.payload?.authorization?.from,
-          // Buyer's wallet address
-          paidTo: wallet,
-          amount: amountNum,
-          currency: currency || "USDC",
-          memo,
-          result
-        });
-      }
       return this.sendJson(res, 200, {
         success: true,
         verified: true,
-        settled: settlement2?.success || false,
-        txHash: settlement2?.transaction,
-        from: payment.payload?.authorization?.from,
-        // Buyer's wallet address
+        txHash,
+        chain: "tempo_moderato",
         paidTo: wallet,
         amount: amountNum,
-        currency: currency || "USDC",
-        facilitator: settlement2?.facilitator,
+        currency: "USDC",
+        facilitator: verification.facilitator,
         memo,
         result
       });
     }
-    console.log(`[MoltsPay] /proxy: Settling payment (no execution)...`);
-    let settlement = null;
-    try {
-      settlement = await this.registry.settle(payment, requirements);
-      console.log(`[MoltsPay] /proxy: Payment settled by ${settlement.facilitator}: ${settlement.transaction || "pending"}`);
-    } catch (err) {
-      console.error("[MoltsPay] /proxy: Settlement failed:", err.message);
-      return this.sendJson(res, 500, {
-        success: false,
-        error: `Settlement failed: ${err.message}`
-      });
-    }
     this.sendJson(res, 200, {
       success: true,
       verified: true,
-      settled: settlement?.success || false,
-      txHash: settlement?.transaction,
-      from: payment.payload?.authorization?.from,
-      // Buyer's wallet address
+      txHash,
+      chain: "tempo_moderato",
       paidTo: wallet,
       amount: amountNum,
-      currency: currency || "USDC",
-      facilitator: settlement?.facilitator,
+      currency: "USDC",
+      facilitator: verification.facilitator,
       memo
     });
   }
@@ -2279,7 +3636,7 @@ var MoltsPayServer = class {
     const tokenAddresses = TOKEN_ADDRESSES[networkId] || TOKEN_ADDRESSES[this.networkId] || {};
     const tokenAddress = tokenAddresses[selectedToken];
     const tokenDomain = getTokenDomain(networkId, selectedToken);
-    return {
+    const requirements = {
       scheme: "exact",
       network: networkId,
       asset: tokenAddress,
@@ -2289,6 +3646,17 @@ var MoltsPayServer = class {
       maxTimeoutSeconds: 300,
       extra: tokenDomain
     };
+    if (networkId === "eip155:56" || networkId === "eip155:97") {
+      const bnbFacilitator = this.registry.get("bnb");
+      const spenderAddress = bnbFacilitator?.getSpenderAddress?.();
+      if (spenderAddress) {
+        requirements.extra = {
+          ...requirements.extra || {},
+          bnbSpender: spenderAddress
+        };
+      }
+    }
+    return requirements;
   }
   /**
    * Return 402 with x402 payment requirements for proxy endpoint
@@ -2338,14 +3706,14 @@ if (!globalThis.crypto) {
 }
 function getVersion() {
   const locations = [
-    join4(__dirname, "../../package.json"),
-    join4(__dirname, "../package.json"),
-    join4(process.cwd(), "node_modules/moltspay/package.json")
+    join5(__dirname, "../../package.json"),
+    join5(__dirname, "../package.json"),
+    join5(process.cwd(), "node_modules/moltspay/package.json")
   ];
   for (const loc of locations) {
     try {
-      if (existsSync4(loc)) {
-        const pkg = JSON.parse(readFileSync4(loc, "utf-8"));
+      if (existsSync5(loc)) {
+        const pkg = JSON.parse(readFileSync5(loc, "utf-8"));
         if (pkg.name === "moltspay") return pkg.version;
       }
     } catch {
@@ -2353,11 +3721,94 @@ function getVersion() {
   }
   return "0.0.0";
 }
+var BNB_SPONSOR_KEY = process.env.MOLTSPAY_BNB_SPONSOR_KEY;
+var BNB_SPENDER_ADDRESS = process.env.MOLTSPAY_BNB_SPENDER || "0xEBB45208D806A0c73F9673E0c5713FF720DD6b79";
+var ERC20_APPROVE_ABI = [
+  "function approve(address spender, uint256 amount) returns (bool)",
+  "function allowance(address owner, address spender) view returns (uint256)"
+];
+async function setupBNBApprovals(client, chain, spenderAddress, sponsorGas = false) {
+  const chainConfig = CHAINS[chain];
+  const provider = new ethers2.JsonRpcProvider(chainConfig.rpc);
+  const wallet = client.getWallet();
+  if (!wallet) {
+    console.log("   \u274C No wallet found");
+    return;
+  }
+  const signer = wallet.connect(provider);
+  console.log(`   Spender: ${spenderAddress}`);
+  let bnbBalance = await provider.getBalance(wallet.address);
+  const minGasRequired = ethers2.parseEther("0.0005");
+  if (bnbBalance < minGasRequired) {
+    if (sponsorGas && BNB_SPONSOR_KEY) {
+      console.log("   \u23F3 Sponsoring BNB gas for approvals...");
+      try {
+        const sponsorWallet = new ethers2.Wallet(BNB_SPONSOR_KEY, provider);
+        const tx = await sponsorWallet.sendTransaction({
+          to: wallet.address,
+          value: ethers2.parseEther("0.001")
+        });
+        await tx.wait();
+        console.log(`   \u2705 Sponsored 0.001 BNB (tx: ${tx.hash.slice(0, 10)}...)`);
+        bnbBalance = await provider.getBalance(wallet.address);
+      } catch (err) {
+        console.log(`   \u26A0\uFE0F  Gas sponsorship failed: ${err.message}`);
+        console.log(`   \u{1F4A1} Get testnet BNB: https://testnet.bnbchain.org/faucet-smart`);
+        return;
+      }
+    } else {
+      console.log(`   \u26A0\uFE0F  Need BNB for gas (~0.0005 BNB)`);
+      console.log(`   \u{1F4A1} Run: npx moltspay faucet --chain bnb_testnet`);
+      console.log(`   Then run: npx moltspay approve --chain ${chain} --spender ${spenderAddress}`);
+      return;
+    }
+  }
+  for (const tokenSymbol of ["USDT", "USDC"]) {
+    const tokenConfig = chainConfig.tokens[tokenSymbol];
+    const tokenContract = new ethers2.Contract(tokenConfig.address, ERC20_APPROVE_ABI, signer);
+    const allowance = await tokenContract.allowance(wallet.address, spenderAddress);
+    if (allowance > 0n) {
+      console.log(`   \u2705 ${tokenSymbol}: already approved for ${spenderAddress.slice(0, 10)}...`);
+      continue;
+    }
+    console.log(`   \u23F3 Approving ${tokenSymbol}...`);
+    try {
+      const tx = await tokenContract.approve(spenderAddress, ethers2.MaxUint256);
+      await tx.wait();
+      console.log(`   \u2705 ${tokenSymbol}: approved (tx: ${tx.hash.slice(0, 10)}...)`);
+    } catch (err) {
+      console.log(`   \u274C ${tokenSymbol}: approval failed - ${err.message}`);
+    }
+  }
+  console.log("");
+}
+async function checkBNBApprovals(address, chain, configDir = DEFAULT_CONFIG_DIR2) {
+  const chainConfig = CHAINS[chain];
+  const provider = new ethers2.JsonRpcProvider(chainConfig.rpc);
+  let spenderAddress = null;
+  try {
+    const walletPath = join5(configDir, "wallet.json");
+    const walletData = JSON.parse(readFileSync5(walletPath, "utf-8"));
+    spenderAddress = walletData.approvals?.[chain] || null;
+  } catch {
+  }
+  const result = { usdt: false, usdc: false, spender: spenderAddress };
+  if (!spenderAddress) {
+    return result;
+  }
+  for (const tokenSymbol of ["USDT", "USDC"]) {
+    const tokenConfig = chainConfig.tokens[tokenSymbol];
+    const tokenContract = new ethers2.Contract(tokenConfig.address, ERC20_APPROVE_ABI, provider);
+    const allowance = await tokenContract.allowance(address, spenderAddress);
+    result[tokenSymbol.toLowerCase()] = allowance > 0n;
+  }
+  return result;
+}
 var program = new Command();
-var DEFAULT_CONFIG_DIR = join4(homedir2(), ".moltspay");
-var PID_FILE = join4(DEFAULT_CONFIG_DIR, "server.pid");
-if (!existsSync4(DEFAULT_CONFIG_DIR)) {
-  mkdirSync2(DEFAULT_CONFIG_DIR, { recursive: true });
+var DEFAULT_CONFIG_DIR2 = join5(homedir3(), ".moltspay");
+var PID_FILE = join5(DEFAULT_CONFIG_DIR2, "server.pid");
+if (!existsSync5(DEFAULT_CONFIG_DIR2)) {
+  mkdirSync3(DEFAULT_CONFIG_DIR2, { recursive: true });
 }
 function prompt(question) {
   const rl = readline.createInterface({
@@ -2372,19 +3823,49 @@ function prompt(question) {
   });
 }
 program.name("moltspay").description("MoltsPay - Payment infrastructure for AI Agents").version(getVersion());
-program.command("init").description("Initialize MoltsPay client (create wallet, set limits)").option("--chain <chain>", "Blockchain to use", "base").option("--max-per-tx <amount>", "Max amount per transaction").option("--max-per-day <amount>", "Max amount per day").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).action(async (options) => {
-  console.log("\n\u{1F510} MoltsPay Client Setup\n");
-  if (existsSync4(join4(options.configDir, "wallet.json"))) {
-    console.log('\u26A0\uFE0F  Already initialized. Use "moltspay config" to update settings.');
-    console.log(`   Config dir: ${options.configDir}`);
-    return;
-  }
+program.command("init").description("Initialize MoltsPay client (create wallet, set limits)").option("--chain <chain>", "Blockchain to use", "base").option("--max-per-tx <amount>", "Max amount per transaction").option("--max-per-day <amount>", "Max amount per day").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR2).action(async (options) => {
   let chain = options.chain;
-  const supportedChains = ["base", "polygon", "base_sepolia", "tempo_moderato"];
+  const supportedEVMChains = ["base", "polygon", "base_sepolia", "tempo_moderato", "bnb", "bnb_testnet"];
+  const supportedSolanaChains = ["solana", "solana_devnet"];
+  const supportedChains = [...supportedEVMChains, ...supportedSolanaChains];
   if (!supportedChains.includes(chain)) {
     console.error(`\u274C Unknown chain: ${chain}. Supported: ${supportedChains.join(", ")}`);
     process.exit(1);
   }
+  if (supportedSolanaChains.includes(chain)) {
+    console.log("\n\u{1F7E3} Solana Wallet Setup\n");
+    if (solanaWalletExists(options.configDir)) {
+      const existingAddress = getSolanaAddress(options.configDir);
+      console.log(`\u26A0\uFE0F  Solana wallet already exists: ${existingAddress}`);
+      console.log(`   Config dir: ${options.configDir}`);
+      return;
+    }
+    console.log("Creating Solana wallet...");
+    const keypair = createSolanaWallet(options.configDir);
+    const address = keypair.publicKey.toBase58();
+    console.log(`
+\u2705 Solana wallet created: ${address}`);
+    console.log(`
+\u{1F4C1} Config saved to: ${join5(options.configDir, "wallet-solana.json")}`);
+    console.log(`
+\u26A0\uFE0F  IMPORTANT: Back up your wallet file!`);
+    console.log(`   This file contains your private key!
+`);
+    if (chain === "solana_devnet") {
+      console.log("\u{1F4A1} Get testnet tokens:");
+      console.log("   npx moltspay faucet --chain solana_devnet\n");
+    } else {
+      console.log(`\u{1F4B0} Fund your wallet with USDC on Solana to start (gasless - no SOL needed).
+`);
+    }
+    return;
+  }
+  console.log("\n\u{1F510} MoltsPay Client Setup\n");
+  if (existsSync5(join5(options.configDir, "wallet.json"))) {
+    console.log('\u26A0\uFE0F  EVM wallet already initialized. Use "moltspay config" to update settings.');
+    console.log(`   Config dir: ${options.configDir}`);
+    return;
+  }
   let maxPerTx = options.maxPerTx ? parseFloat(options.maxPerTx) : null;
   let maxPerDay = options.maxPerDay ? parseFloat(options.maxPerDay) : null;
   if (!maxPerTx) {
@@ -2406,13 +3887,21 @@ program.command("init").description("Initialize MoltsPay client (create wallet,
   console.log(`
 \u{1F4C1} Config saved to: ${result.configDir}`);
   console.log(`
-\u26A0\uFE0F  IMPORTANT: Back up ${join4(result.configDir, "wallet.json")}`);
+\u26A0\uFE0F  IMPORTANT: Back up ${join5(result.configDir, "wallet.json")}`);
   console.log(`   This file contains your private key!
 `);
+  if (chain === "bnb" || chain === "bnb_testnet") {
+    console.log("\u{1F4CB} Setting up BNB chain approvals...\n");
+    console.log("   \u2139\uFE0F  Using default spender. For other services, run:");
+    console.log(`   npx moltspay approve --chain ${chain} --spender <address>
+`);
+    const client = new MoltsPayClient({ configDir: options.configDir });
+    await setupBNBApprovals(client, chain, BNB_SPENDER_ADDRESS, true);
+  }
   console.log(`\u{1F4B0} Fund your wallet with USDC on ${chain} to start using services.
 `);
 });
-program.command("config").description("Update MoltsPay settings").option("--max-per-tx <amount>", "Max amount per transaction").option("--max-per-day <amount>", "Max amount per day").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).action(async (options) => {
+program.command("config").description("Update MoltsPay settings").option("--max-per-tx <amount>", "Max amount per transaction").option("--max-per-day <amount>", "Max amount per day").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR2).action(async (options) => {
   const client = new MoltsPayClient({ configDir: options.configDir });
   if (!client.isInitialized) {
     console.log("\u274C Not initialized. Run: npx moltspay init");
@@ -2447,25 +3936,40 @@ program.command("config").description("Update MoltsPay settings").option("--max-
     }
   }
 });
-program.command("fund <amount>").description("Fund wallet with USDC via Coinbase (US debit card / Apple Pay)").option("--chain <chain>", "Chain to fund (base, polygon, or base_sepolia)", "base").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).action(async (amountStr, options) => {
+program.command("fund <amount>").description("Fund wallet with USDC via Coinbase (US debit card / Apple Pay)").option("--chain <chain>", "Chain to fund (base, polygon, solana, base_sepolia, bnb, or bnb_testnet)", "base").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR2).action(async (amountStr, options) => {
   const client = new MoltsPayClient({ configDir: options.configDir });
-  if (!client.isInitialized) {
-    console.log("\u274C Not initialized. Run: npx moltspay init");
-    return;
-  }
   const amount = parseFloat(amountStr);
   if (isNaN(amount) || amount < 5) {
     console.log("\u274C Minimum $5.");
     return;
   }
   const chain = options.chain?.toLowerCase() || "base";
-  if (!["base", "polygon", "base_sepolia"].includes(chain)) {
-    console.log("\u274C Invalid chain. Use: base, polygon, or base_sepolia");
+  if (!["base", "polygon", "base_sepolia", "solana", "bnb", "bnb_testnet"].includes(chain)) {
+    console.log("\u274C Invalid chain. Use: base, polygon, solana, base_sepolia, bnb, or bnb_testnet");
     return;
   }
+  let walletAddress;
+  if (chain === "solana") {
+    const solanaWallet = loadSolanaWallet(options.configDir || DEFAULT_CONFIG_DIR2);
+    if (!solanaWallet) {
+      console.log("\u274C No Solana wallet found. Run: npx moltspay init --chain solana");
+      return;
+    }
+    walletAddress = getSolanaAddress(options.configDir || DEFAULT_CONFIG_DIR2) || "";
+    if (!walletAddress) {
+      console.log("\u274C Could not get Solana wallet address.");
+      return;
+    }
+  } else {
+    if (!client.isInitialized) {
+      console.log("\u274C Not initialized. Run: npx moltspay init");
+      return;
+    }
+    walletAddress = client.address;
+  }
   if (chain === "base_sepolia") {
     console.log("\n\u{1F9EA} Testnet Funding\n");
-    console.log(`   Wallet: ${client.address}`);
+    console.log(`   Wallet: ${walletAddress}`);
     console.log(`   Chain: Base Sepolia (testnet)
 `);
     console.log("\u{1F4A1} Use the MoltsPay faucet to get free testnet USDC:\n");
@@ -2473,9 +3977,36 @@ program.command("fund <amount>").description("Fund wallet with USDC via Coinbase
     console.log("   Or get from Circle Faucet: https://faucet.circle.com/\n");
     return;
   }
+  if (chain === "bnb_testnet") {
+    console.log("\n\u{1F9EA} BNB Testnet Funding\n");
+    console.log(`   Wallet: ${walletAddress}`);
+    console.log(`   Chain: BNB Testnet
+`);
+    console.log("\u{1F4A1} Use the MoltsPay faucet to get testnet USDC + tBNB:\n");
+    console.log("   npx moltspay faucet --chain bnb_testnet\n");
+    console.log("   This gives you:\n");
+    console.log("   \u2022 1 USDC (testnet) for payments");
+    console.log("   \u2022 0.001 tBNB for gas (first approval tx)\n");
+    return;
+  }
+  if (chain === "bnb") {
+    console.log("\n\u{1F4CB} BNB Chain Funding\n");
+    console.log(`   Wallet: ${walletAddress}
+`);
+    console.log("   To use MoltsPay on BNB Chain, you need:\n");
+    console.log("   1. USDC for payments");
+    console.log("      \u2192 Withdraw from Binance/exchange to your wallet address\n");
+    console.log("   2. Small amount of BNB for gas (~0.001 BNB / ~$0.60)");
+    console.log("      \u2192 First approval transaction requires gas");
+    console.log("      \u2192 After approval, all payments are gasless\n");
+    console.log("   \u{1F4A1} Tip: Most exchanges include BNB dust when you withdraw to BNB Chain\n");
+    console.log("   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+    console.log("   After funding, check status: npx moltspay status\n");
+    return;
+  }
   console.log("\n\u{1F4B3} Fund your agent wallet\n");
-  console.log(`   Wallet: ${client.address}`);
-  console.log(`   Chain: ${chain}`);
+  console.log(`   Wallet: ${walletAddress}`);
+  console.log(`   Chain: ${chain === "solana" ? "Solana" : chain}`);
   console.log(`   Amount: $${amount.toFixed(2)}
 `);
   try {
@@ -2484,7 +4015,7 @@ program.command("fund <amount>").description("Fund wallet with USDC via Coinbase
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify({
-        address: client.address,
+        address: walletAddress,
         amount,
         chain
       })
@@ -2502,11 +4033,92 @@ program.command("fund <amount>").description("Fund wallet with USDC via Coinbase
     console.log(`\u274C ${error.message}`);
   }
 });
-program.command("faucet").description("Request testnet tokens from faucet (Base Sepolia or Tempo Moderato)").option("--chain <chain>", "Chain to get tokens on (base_sepolia or tempo_moderato)", "base_sepolia").option("--address <address>", "Wallet address (defaults to your wallet)").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).action(async (options) => {
+program.command("approve").description("Approve a spender address for BNB chain payments").requiredOption("--spender <address>", "Spender address to approve (from server 402 response)").option("--chain <chain>", "BNB chain (bnb or bnb_testnet)", "bnb_testnet").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR2).action(async (options) => {
+  const chain = options.chain;
+  if (chain !== "bnb" && chain !== "bnb_testnet") {
+    console.log("\u274C approve command is only for BNB chains (bnb or bnb_testnet)");
+    return;
+  }
+  if (!options.spender.match(/^0x[a-fA-F0-9]{40}$/)) {
+    console.log("\u274C Invalid spender address format");
+    return;
+  }
+  const client = new MoltsPayClient({ configDir: options.configDir });
+  if (!client.isInitialized) {
+    console.log("\u274C Wallet not initialized. Run: npx moltspay init --chain " + chain);
+    return;
+  }
+  console.log(`
+\u{1F510} Approving spender for ${chain}...
+`);
+  await setupBNBApprovals(client, chain, options.spender, false);
+  const walletPath = join5(options.configDir || DEFAULT_CONFIG_DIR2, "wallet.json");
+  try {
+    const walletData = JSON.parse(readFileSync5(walletPath, "utf-8"));
+    walletData.approvals = walletData.approvals || {};
+    walletData.approvals[chain] = options.spender;
+    writeFileSync3(walletPath, JSON.stringify(walletData, null, 2));
+    console.log(`\u2705 Approval complete! Spender saved for ${chain}.
+`);
+  } catch (err) {
+    console.log("\u2705 Approval complete!\n");
+    console.log("\u26A0\uFE0F  Could not save spender to wallet config");
+  }
+});
+program.command("faucet").description("Request testnet tokens from faucet (Base Sepolia, Tempo Moderato, BNB Testnet, or Solana Devnet)").option("--chain <chain>", "Chain to get tokens on (base_sepolia, tempo_moderato, bnb_testnet, or solana_devnet)", "base_sepolia").option("--address <address>", "Wallet address (defaults to your wallet)").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR2).action(async (options) => {
   let address = options.address;
   const chain = options.chain?.toLowerCase() || "base_sepolia";
-  if (!["base_sepolia", "tempo_moderato"].includes(chain)) {
-    console.log("\u274C Invalid chain. Use: base_sepolia or tempo_moderato");
+  if (!["base_sepolia", "tempo_moderato", "bnb_testnet", "solana_devnet"].includes(chain)) {
+    console.log("\u274C Invalid chain. Use: base_sepolia, tempo_moderato, bnb_testnet, or solana_devnet");
+    return;
+  }
+  if (chain === "solana_devnet") {
+    if (!address) {
+      address = getSolanaAddress(options.configDir);
+      if (!address) {
+        console.log("\u274C No Solana wallet found. Run: npx moltspay init --chain solana_devnet");
+        return;
+      }
+    }
+    if (!isValidSolanaAddress(address)) {
+      console.log("\u274C Invalid Solana address");
+      return;
+    }
+    console.log("\n\u{1F6B0} Solana Devnet Faucet (Gasless Mode)\n");
+    console.log(`   Address: ${address}
+`);
+    let usdcSuccess = false;
+    try {
+      console.log("   \u23F3 Requesting 1 USDC from faucet...");
+      const FAUCET_API = process.env.MOLTSPAY_FAUCET_API || "https://moltspay.com/api/v1/faucet";
+      const response = await fetch(FAUCET_API, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ address, chain: "solana_devnet" })
+      });
+      const result = await response.json();
+      if (!response.ok) {
+        console.log(`   \u26A0\uFE0F  USDC faucet: ${result.error || "Request failed"}`);
+        if (result.hint) console.log(`      ${result.hint}`);
+        if (result.retry_after) console.log(`      Retry after: ${result.retry_after}`);
+      } else {
+        console.log(`   \u2705 Received ${result.amount} USDC!`);
+        console.log(`   Transaction: ${result.explorer}`);
+        if (result.faucet_balance) {
+          console.log(`   Faucet balance: ${result.faucet_balance} USDC remaining`);
+        }
+        usdcSuccess = true;
+      }
+    } catch (error) {
+      console.log(`   \u26A0\uFE0F  USDC faucet error: ${error.message}`);
+    }
+    console.log("");
+    if (usdcSuccess) {
+      console.log("\u{1F4A1} Check your balance:");
+      console.log("   npx moltspay status\n");
+    } else {
+      console.log("\u274C Faucet request failed. Try again in a few minutes.\n");
+    }
     return;
   }
   if (!address) {
@@ -2554,6 +4166,46 @@ program.command("faucet").description("Request testnet tokens from faucet (Base
       console.log(`\u274C ${error.message}`);
       console.log("\n   Try Tempo Wallet instead: https://wallet.tempo.xyz\n");
     }
+  } else if (chain === "bnb_testnet") {
+    console.log(`   Requesting 1 USDC on BNB Testnet...`);
+    console.log(`   Address: ${address}
+`);
+    try {
+      const FAUCET_API = process.env.MOLTSPAY_FAUCET_API || "https://moltspay.com/api/v1/faucet";
+      const response = await fetch(FAUCET_API, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ address, chain: "bnb_testnet" })
+      });
+      const result = await response.json();
+      if (!response.ok) {
+        console.log(`\u274C ${result.error || "Request failed"}`);
+        if (result.hint) console.log(`   ${result.hint}`);
+        if (result.retry_after) console.log(`   Retry after: ${result.retry_after}`);
+        console.log("\n\u{1F4A1} Alternatively, get tokens manually:");
+        console.log(`   1. Get test BNB: https://www.bnbchain.org/en/testnet-faucet`);
+        console.log(`   2. Select "Peggy Tokens" -> USDC`);
+        console.log(`   3. Enter: ${address}
+`);
+        return;
+      }
+      console.log(`\u2705 Received ${result.amount} ${result.token || "USDC"} on ${result.chain_name || "BNB Testnet"}!
+`);
+      console.log(`   Transaction: ${result.explorer || `https://testnet.bscscan.com/tx/${result.transaction}`}`);
+      if (result.faucet_balance) {
+        console.log(`   Faucet balance: ${result.faucet_balance} USDC`);
+      }
+      console.log("\n\u{1F4A1} Now you can test BNB payments:");
+      console.log(`   npx moltspay pay <service-url> <service-id> --chain bnb_testnet
+`);
+    } catch (error) {
+      console.log(`\u274C ${error.message}`);
+      console.log("\n\u{1F4A1} Get tokens manually:");
+      console.log(`   1. Get test BNB: https://www.bnbchain.org/en/testnet-faucet`);
+      console.log(`   2. Select "Peggy Tokens" -> USDC`);
+      console.log(`   3. Enter: ${address}
+`);
+    }
   } else {
     console.log(`   Requesting 1 USDC on Base Sepolia...`);
     console.log(`   Address: ${address}
@@ -2563,7 +4215,7 @@ program.command("faucet").description("Request testnet tokens from faucet (Base
       const response = await fetch(FAUCET_API, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ address })
+        body: JSON.stringify({ address, chain: "base_sepolia" })
       });
       const result = await response.json();
       if (!response.ok) {
@@ -2586,7 +4238,7 @@ program.command("faucet").description("Request testnet tokens from faucet (Base
     }
   }
 });
-program.command("status").description("Show wallet status and balance").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).option("--json", "Output as JSON").action(async (options) => {
+program.command("status").description("Show wallet status and balance").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR2).option("--json", "Output as JSON").action(async (options) => {
   const client = new MoltsPayClient({ configDir: options.configDir });
   if (!client.isInitialized) {
     if (options.json) {
@@ -2603,12 +4255,31 @@ program.command("status").description("Show wallet status and balance").option("
   } catch (err) {
     console.error("Warning: Could not fetch balances:", err.message);
   }
+  const solanaAddress = getSolanaAddress(options.configDir);
+  let solanaBalances = {};
+  if (solanaAddress) {
+    try {
+      solanaBalances.devnet = await getSolanaBalances(solanaAddress, "solana_devnet");
+    } catch {
+    }
+    try {
+      solanaBalances.mainnet = await getSolanaBalances(solanaAddress, "solana");
+    } catch {
+    }
+  }
   if (options.json) {
-    console.log(JSON.stringify({
+    const output = {
       address: client.address,
       balances: allBalances,
       limits: config.limits
-    }, null, 2));
+    };
+    if (solanaAddress) {
+      output.solana = {
+        address: solanaAddress,
+        balances: solanaBalances
+      };
+    }
+    console.log(JSON.stringify(output, null, 2));
   } else {
     console.log("\n\u{1F4CA} MoltsPay Wallet Status\n");
     console.log(`   Address: ${client.address}`);
@@ -2632,18 +4303,90 @@ program.command("status").description("Show wallet status and balance").option("
         console.log(`       alphaUSD:  ${tempo.alphaUSD.toFixed(2)}`);
         console.log(`       betaUSD:   ${tempo.betaUSD.toFixed(2)}`);
         console.log(`       thetaUSD:  ${tempo.thetaUSD.toFixed(2)}`);
+      } else if (chainName === "bnb" || chainName === "bnb_testnet") {
+        const bnbBalance = balance.native;
+        const bnbWarning = bnbBalance < 5e-4 ? " \u26A0\uFE0F Low gas" : "";
+        console.log(`     ${chainLabel.padEnd(14)} ${balance.usdc.toFixed(2)} USDC | ${balance.usdt.toFixed(2)} USDT | ${bnbBalance.toFixed(4)} BNB${bnbWarning}`);
       } else {
         console.log(`     ${chainLabel.padEnd(14)} ${balance.usdc.toFixed(2)} USDC | ${balance.usdt.toFixed(2)} USDT`);
       }
     }
+    const address = client.address;
+    let bnbApprovalStatus = null;
+    let bnbTestnetApprovalStatus = null;
+    try {
+      if (allBalances["bnb"]) {
+        bnbApprovalStatus = await checkBNBApprovals(address, "bnb", options.configDir);
+      }
+      if (allBalances["bnb_testnet"]) {
+        bnbTestnetApprovalStatus = await checkBNBApprovals(address, "bnb_testnet", options.configDir);
+      }
+    } catch {
+    }
+    if (bnbApprovalStatus || bnbTestnetApprovalStatus) {
+      console.log("");
+      console.log("   BNB Approvals (pay-for-success):");
+      if (bnbApprovalStatus) {
+        if (!bnbApprovalStatus.spender) {
+          console.log("     BNB:          \u26A0\uFE0F No spender configured");
+          console.log("     \u2514\u2500 Run a payment first, or: npx moltspay approve --chain bnb --spender <address>");
+        } else {
+          const status = bnbApprovalStatus.usdt && bnbApprovalStatus.usdc ? "\u2705" : "\u26A0\uFE0F";
+          const tokens = [
+            bnbApprovalStatus.usdt ? "USDT\u2713" : "USDT\u2717",
+            bnbApprovalStatus.usdc ? "USDC\u2713" : "USDC\u2717"
+          ].join(", ");
+          console.log(`     BNB:          ${status} ${tokens}`);
+          const bnbNative = allBalances["bnb"]?.native || 0;
+          if (!bnbApprovalStatus.usdc && !bnbApprovalStatus.usdt && bnbNative < 5e-4) {
+            console.log("     \u26A0\uFE0F  Need ~0.001 BNB for first approval tx. Get from exchange.");
+          }
+        }
+      }
+      if (bnbTestnetApprovalStatus) {
+        if (!bnbTestnetApprovalStatus.spender) {
+          console.log("     BNB Testnet:  \u26A0\uFE0F No spender configured");
+          console.log("     \u2514\u2500 Run a payment first, or: npx moltspay approve --chain bnb_testnet --spender <address>");
+        } else {
+          const status = bnbTestnetApprovalStatus.usdt && bnbTestnetApprovalStatus.usdc ? "\u2705" : "\u26A0\uFE0F";
+          const tokens = [
+            bnbTestnetApprovalStatus.usdt ? "USDT\u2713" : "USDT\u2717",
+            bnbTestnetApprovalStatus.usdc ? "USDC\u2713" : "USDC\u2717"
+          ].join(", ");
+          console.log(`     BNB Testnet:  ${status} ${tokens}`);
+          const tbnbNative = allBalances["bnb_testnet"]?.native || 0;
+          if (!bnbTestnetApprovalStatus.usdc && !bnbTestnetApprovalStatus.usdt && tbnbNative < 5e-4) {
+            console.log("     \u26A0\uFE0F  Need tBNB for approval. Run: npx moltspay faucet --chain bnb_testnet");
+          }
+        }
+      }
+    }
     console.log("");
     console.log("   Spending Limits:");
     console.log(`     Per Transaction: $${config.limits.maxPerTx}`);
     console.log(`     Daily:           $${config.limits.maxPerDay}`);
+    const solanaAddress2 = getSolanaAddress(options.configDir);
+    if (solanaAddress2) {
+      console.log("");
+      console.log("   \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
+      console.log(`   \u{1F7E3} Solana: ${solanaAddress2}`);
+      try {
+        const devnetBalances = await getSolanaBalances(solanaAddress2, "solana_devnet");
+        console.log(`     Devnet:    ${devnetBalances.sol.toFixed(4)} SOL | ${devnetBalances.usdc.toFixed(2)} USDC`);
+      } catch (err) {
+        console.log(`     Devnet:    (unable to fetch)`);
+      }
+      try {
+        const mainnetBalances = await getSolanaBalances(solanaAddress2, "solana");
+        console.log(`     Mainnet:   ${mainnetBalances.sol.toFixed(4)} SOL | ${mainnetBalances.usdc.toFixed(2)} USDC`);
+      } catch (err) {
+        console.log(`     Mainnet:   (unable to fetch)`);
+      }
+    }
     console.log("");
   }
 });
-program.command("list").description("List recent transactions").option("--days <n>", "Number of days to look back", "7").option("--chain <chain>", "Chain to query (base, polygon, base_sepolia, or all)", "all").option("--limit <n>", "Max transactions to show", "20").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).action(async (options) => {
+program.command("list").description("List recent transactions").option("--days <n>", "Number of days to look back", "7").option("--chain <chain>", "Chain to query (base, polygon, base_sepolia, or all)", "all").option("--limit <n>", "Max transactions to show", "20").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR2).action(async (options) => {
   const client = new MoltsPayClient({ configDir: options.configDir });
   if (!client.isInitialized) {
     console.log("\u274C Not initialized. Run: npx moltspay init");
@@ -2950,14 +4693,14 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
     let manifestPath;
     let skillDir;
     let isSkillDir = false;
-    if (existsSync4(join4(resolvedPath, "moltspay.services.json"))) {
-      manifestPath = join4(resolvedPath, "moltspay.services.json");
+    if (existsSync5(join5(resolvedPath, "moltspay.services.json"))) {
+      manifestPath = join5(resolvedPath, "moltspay.services.json");
       skillDir = resolvedPath;
       isSkillDir = true;
-    } else if (existsSync4(resolvedPath) && resolvedPath.endsWith(".json")) {
+    } else if (existsSync5(resolvedPath) && resolvedPath.endsWith(".json")) {
       manifestPath = resolvedPath;
       skillDir = dirname(resolvedPath);
-    } else if (existsSync4(resolvedPath)) {
+    } else if (existsSync5(resolvedPath)) {
       console.error(`\u274C No moltspay.services.json found in: ${resolvedPath}`);
       continue;
     } else {
@@ -2966,25 +4709,25 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
     }
     console.log(`\u{1F4E6} Loading: ${manifestPath}`);
     try {
-      const manifestContent = JSON.parse(readFileSync4(manifestPath, "utf-8"));
+      const manifestContent = JSON.parse(readFileSync5(manifestPath, "utf-8"));
       if (!provider) {
         provider = manifestContent.provider;
       }
       let skillModule = null;
       if (isSkillDir) {
         let entryPoint = "index.js";
-        const pkgJsonPath = join4(skillDir, "package.json");
-        if (existsSync4(pkgJsonPath)) {
+        const pkgJsonPath = join5(skillDir, "package.json");
+        if (existsSync5(pkgJsonPath)) {
           try {
-            const pkgJson = JSON.parse(readFileSync4(pkgJsonPath, "utf-8"));
+            const pkgJson = JSON.parse(readFileSync5(pkgJsonPath, "utf-8"));
             if (pkgJson.main) {
               entryPoint = pkgJson.main;
             }
           } catch {
           }
         }
-        const modulePath = join4(skillDir, entryPoint);
-        if (existsSync4(modulePath)) {
+        const modulePath = join5(skillDir, entryPoint);
+        if (existsSync5(modulePath)) {
           try {
             skillModule = await import(modulePath);
             console.log(`   \u2705 Loaded module: ${modulePath}`);
@@ -3062,8 +4805,8 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
     provider,
     services: allServices
   };
-  const tempManifestPath = join4(DEFAULT_CONFIG_DIR, "combined-manifest.json");
-  writeFileSync2(tempManifestPath, JSON.stringify(combinedManifest, null, 2));
+  const tempManifestPath = join5(DEFAULT_CONFIG_DIR2, "combined-manifest.json");
+  writeFileSync3(tempManifestPath, JSON.stringify(combinedManifest, null, 2));
   console.log(`
 \u{1F4CB} Combined manifest: ${allServices.length} services`);
   console.log(`   Provider: ${provider.name}`);
@@ -3076,12 +4819,12 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
       server.skill(serviceId, handler);
     }
     const pidData = { pid: process.pid, port, paths: allPaths };
-    writeFileSync2(PID_FILE, JSON.stringify(pidData, null, 2));
+    writeFileSync3(PID_FILE, JSON.stringify(pidData, null, 2));
     server.listen(port);
     const cleanup = () => {
       try {
-        if (existsSync4(PID_FILE)) unlinkSync(PID_FILE);
-        if (existsSync4(tempManifestPath)) unlinkSync(tempManifestPath);
+        if (existsSync5(PID_FILE)) unlinkSync(PID_FILE);
+        if (existsSync5(tempManifestPath)) unlinkSync(tempManifestPath);
       } catch {
       }
     };
@@ -3102,12 +4845,12 @@ program.command("start <paths...>").description("Start MoltsPay server from skil
   }
 });
 program.command("stop").description("Stop the running MoltsPay server").action(async () => {
-  if (!existsSync4(PID_FILE)) {
+  if (!existsSync5(PID_FILE)) {
     console.log("\u274C No running server found (no PID file)");
     process.exit(1);
   }
   try {
-    const pidData = JSON.parse(readFileSync4(PID_FILE, "utf-8"));
+    const pidData = JSON.parse(readFileSync5(PID_FILE, "utf-8"));
     const { pid, port, manifest } = pidData;
     console.log(`
 \u{1F6D1} Stopping MoltsPay Server
@@ -3132,7 +4875,7 @@ program.command("stop").description("Stop the running MoltsPay server").action(a
       process.kill(pid, "SIGKILL");
     } catch {
     }
-    if (existsSync4(PID_FILE)) {
+    if (existsSync5(PID_FILE)) {
       unlinkSync(PID_FILE);
     }
     console.log("\u2705 Server stopped\n");
@@ -3141,14 +4884,23 @@ program.command("stop").description("Stop the running MoltsPay server").action(a
     process.exit(1);
   }
 });
-program.command("pay <server> <service> [params]").description("Pay for a service and get the result").option("--prompt <text>", "Prompt for the service").option("--image <path>", "Image URL or local file path").option("--token <token>", "Token to pay with (USDC or USDT)", "USDC").option("--chain <chain>", "Chain to pay on (base, polygon, base_sepolia, or tempo_moderato).").option("--config-dir <dir>", "Config directory with wallet.json", DEFAULT_CONFIG_DIR).option("--json", "Output raw JSON only").action(async (server, service, paramsJson, options) => {
+program.command("pay <server> <service> [params]").description("Pay for a service and get the result").option("--prompt <text>", "Prompt for the service").option("--image <path>", "Image URL or local file path").option("--data <json>", "Raw JSON data to send (for custom input formats)").option("--token <token>", "Token to pay with (USDC or USDT)", "USDC").option("--chain <chain>", "Chain to pay on (base, polygon, base_sepolia, tempo_moderato, solana, or solana_devnet).").option("--config-dir <dir>", "Config directory with wallet.json", DEFAULT_CONFIG_DIR2).option("--json", "Output raw JSON only").action(async (server, service, paramsJson, options) => {
   const client = new MoltsPayClient({ configDir: options.configDir });
   if (!client.isInitialized) {
     console.error("\u274C Wallet not initialized. Run: npx moltspay init");
     process.exit(1);
   }
   let params = {};
-  if (paramsJson) {
+  let useRawData = false;
+  if (options.data) {
+    try {
+      params = JSON.parse(options.data);
+      useRawData = true;
+    } catch {
+      console.error("\u274C Invalid JSON in --data flag");
+      process.exit(1);
+    }
+  } else if (paramsJson) {
     try {
       params = JSON.parse(paramsJson);
     } catch {
@@ -3156,24 +4908,25 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
       process.exit(1);
     }
   }
-  if (options.prompt) params.prompt = options.prompt;
+  if (!useRawData && options.prompt) params.prompt = options.prompt;
   if (options.image) {
     const imagePath = options.image;
     if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
       params.image_url = imagePath;
     } else {
       const filePath = resolve(imagePath);
-      if (!existsSync4(filePath)) {
+      if (!existsSync5(filePath)) {
         console.error(`\u274C Image file not found: ${filePath}`);
         process.exit(1);
       }
-      const imageData = readFileSync4(filePath);
+      const imageData = readFileSync5(filePath);
       params.image_base64 = imageData.toString("base64");
     }
   }
+  const supportedPayChains = ["base", "polygon", "base_sepolia", "tempo_moderato", "bnb", "bnb_testnet", "solana", "solana_devnet"];
   const chain = options.chain?.toLowerCase();
-  if (chain && !["base", "polygon", "base_sepolia", "tempo_moderato"].includes(chain)) {
-    console.error(`\u274C Unknown chain: ${chain}. Supported: base, polygon, base_sepolia, tempo_moderato`);
+  if (chain && !supportedPayChains.includes(chain)) {
+    console.error(`\u274C Unknown chain: ${chain}. Supported: ${supportedPayChains.join(", ")}`);
     process.exit(1);
   }
   const imageDisplay = params.image_url || (params.image_base64 ? `[local file: ${options.image}]` : null);
@@ -3196,7 +4949,11 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
 `);
     console.log(`   Server: ${server}`);
     console.log(`   Service: ${service}`);
-    console.log(`   Prompt: ${params.prompt}`);
+    if (useRawData) {
+      console.log(`   Data: ${JSON.stringify(params).slice(0, 50)}${JSON.stringify(params).length > 50 ? "..." : ""}`);
+    } else {
+      console.log(`   Prompt: ${params.prompt}`);
+    }
     if (imageDisplay) console.log(`   Image: ${imageDisplay}`);
     console.log(`   Chain: ${chain || "(auto)"}`);
     console.log(`   Token: ${token}`);
@@ -3204,22 +4961,11 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
     console.log("");
   }
   try {
-    let result;
-    if (chain === "tempo_moderato") {
-      if (!options.json) {
-        console.log("   Protocol: MPP (Machine Payments Protocol)");
-        console.log("");
-      }
-      const mppUrl = server.includes(service) ? server : `${server}/${service}`;
-      result = await client.payWithMPP(mppUrl, {
-        body: params
-      });
-    } else {
-      result = await client.pay(server, service, params, {
-        token,
-        chain
-      });
-    }
+    const result = await client.pay(server, service, params, {
+      token,
+      chain,
+      rawData: useRawData
+    });
     if (options.json) {
       console.log(JSON.stringify(result));
     } else {
@@ -3239,9 +4985,9 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
 program.command("validate <path>").description("Validate a moltspay.services.json file against the schema").action(async (inputPath) => {
   const resolvedPath = resolve(inputPath);
   let manifestPath;
-  if (existsSync4(join4(resolvedPath, "moltspay.services.json"))) {
-    manifestPath = join4(resolvedPath, "moltspay.services.json");
-  } else if (resolvedPath.endsWith(".json") && existsSync4(resolvedPath)) {
+  if (existsSync5(join5(resolvedPath, "moltspay.services.json"))) {
+    manifestPath = join5(resolvedPath, "moltspay.services.json");
+  } else if (resolvedPath.endsWith(".json") && existsSync5(resolvedPath)) {
     manifestPath = resolvedPath;
   } else {
     console.error(`\u274C Not found: ${resolvedPath}`);
@@ -3251,7 +4997,7 @@ program.command("validate <path>").description("Validate a moltspay.services.jso
 \u{1F4CB} Validating: ${manifestPath}
 `);
   try {
-    const content = JSON.parse(readFileSync4(manifestPath, "utf-8"));
+    const content = JSON.parse(readFileSync5(manifestPath, "utf-8"));
     const errors = [];
     if (!content.provider) {
       errors.push("Missing required field: provider");