moltspay 1.2.1 → 1.4.0

package/dist/cli/index.mjs

@@ -7,25 +7,31 @@ var __esm = (fn, res) => function __init() {
 // node_modules/tsup/assets/esm_shims.js
 import path from "path";
 import { fileURLToPath } from "url";
+var getFilename, getDirname, __dirname;
 var init_esm_shims = __esm({
   "node_modules/tsup/assets/esm_shims.js"() {
     "use strict";
+    getFilename = () => fileURLToPath(import.meta.url);
+    getDirname = () => path.dirname(getFilename());
+    __dirname = /* @__PURE__ */ getDirname();
   }
 });
 
 // src/cli/index.ts
 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
@@ -107,6 +113,92 @@ var CHAINS = {
     explorer: "https://sepolia.basescan.org/address/",
     explorerTx: "https://sepolia.basescan.org/tx/",
     avgBlockTime: 2
+  },
+  // ============ Tempo Testnet (Moderato) ============
+  tempo_moderato: {
+    name: "Tempo Moderato",
+    chainId: 42431,
+    rpc: "https://rpc.moderato.tempo.xyz",
+    tokens: {
+      // TIP-20 stablecoins on Tempo testnet (from mppx SDK)
+      // Note: Tempo uses USD as native gas token, not ETH
+      USDC: {
+        address: "0x20c0000000000000000000000000000000000000",
+        // pathUSD - primary testnet stablecoin
+        decimals: 6,
+        symbol: "USDC",
+        eip712Name: "pathUSD"
+      },
+      USDT: {
+        address: "0x20c0000000000000000000000000000000000001",
+        // alphaUSD
+        decimals: 6,
+        symbol: "USDT",
+        eip712Name: "alphaUSD"
+      }
+    },
+    usdc: "0x20c0000000000000000000000000000000000000",
+    explorer: "https://explore.testnet.tempo.xyz/address/",
+    explorerTx: "https://explore.testnet.tempo.xyz/tx/",
+    avgBlockTime: 0.5
+    // ~500ms finality
+  },
+  // ============ BNB Chain Testnet ============
+  bnb_testnet: {
+    name: "BNB Testnet",
+    chainId: 97,
+    rpc: "https://data-seed-prebsc-1-s1.binance.org:8545",
+    tokens: {
+      // Note: BNB uses 18 decimals for stablecoins (unlike Base/Polygon which use 6)
+      // Using official Binance-Peg testnet tokens
+      USDC: {
+        address: "0x64544969ed7EBf5f083679233325356EbE738930",
+        // Testnet USDC
+        decimals: 18,
+        symbol: "USDC",
+        eip712Name: "USD Coin"
+      },
+      USDT: {
+        address: "0x337610d27c682E347C9cD60BD4b3b107C9d34dDd",
+        // Testnet USDT
+        decimals: 18,
+        symbol: "USDT",
+        eip712Name: "Tether USD"
+      }
+    },
+    usdc: "0x64544969ed7EBf5f083679233325356EbE738930",
+    explorer: "https://testnet.bscscan.com/address/",
+    explorerTx: "https://testnet.bscscan.com/tx/",
+    avgBlockTime: 3,
+    // BNB-specific: requires approval for pay-for-success flow
+    requiresApproval: true
+  },
+  // ============ BNB Chain Mainnet ============
+  bnb: {
+    name: "BNB Smart Chain",
+    chainId: 56,
+    rpc: "https://bsc-dataseed.binance.org",
+    tokens: {
+      // Note: BNB uses 18 decimals for stablecoins
+      USDC: {
+        address: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+        decimals: 18,
+        symbol: "USDC",
+        eip712Name: "USD Coin"
+      },
+      USDT: {
+        address: "0x55d398326f99059fF775485246999027B3197955",
+        decimals: 18,
+        symbol: "USDT",
+        eip712Name: "Tether USD"
+      }
+    },
+    usdc: "0x8AC76a51cc950d9822D68b83fE1Ad97B32Cd580d",
+    explorer: "https://bscscan.com/address/",
+    explorerTx: "https://bscscan.com/tx/",
+    avgBlockTime: 3,
+    // BNB-specific: requires approval for pay-for-success flow
+    requiresApproval: true
   }
 };
 function getChain(name) {
@@ -117,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();
 
@@ -139,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();
@@ -159,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
    */
@@ -228,9 +692,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(serverUrl, service, params, wwwAuthHeader);
+    }
     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 {
@@ -247,17 +716,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(
@@ -265,17 +739,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(serverUrl, service, params, req2, solanaChain);
+    }
+    const chainName = selectedChain;
     const chain = getChain(chainName);
     const network = `eip155:${chain.chainId}`;
     const req = requirements.find((r) => r.scheme === "exact" && r.network === network);
@@ -310,6 +794,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(serverUrl, service, params, {
+        to: payTo2,
+        amount,
+        token,
+        chainName,
+        chain,
+        spender: bnbSpender
+      });
+    }
     const payTo = req.payTo || req.resource;
     if (!payTo) {
       throw new Error("Missing payTo address in payment requirements");
@@ -359,6 +862,300 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
     console.log(`[MoltsPay] Success! Payment: ${result.payment?.status || "claimed"}`);
     return result.result;
   }
+  /**
+   * Handle MPP (Machine Payments Protocol) payment flow
+   * Called when pay() detects WWW-Authenticate header in 402 response
+   */
+  async handleMPPPayment(serverUrl, service, params, wwwAuthHeader) {
+    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 paidRes = await fetch(`${serverUrl}/execute`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Payment ${credentialB64}`
+      },
+      body: JSON.stringify({ service, params, chain: "tempo_moderato" })
+    });
+    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(serverUrl, service, params, paymentDetails) {
+    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 paidRes = await fetch(`${serverUrl}/execute`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Payment": paymentHeader
+      },
+      body: JSON.stringify({ service, params, chain: chainName })
+    });
+    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(serverUrl, service, params, requirements, chain) {
+    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 paidRes = await fetch(`${serverUrl}/execute`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "X-Payment": paymentHeader
+      },
+      body: JSON.stringify({ service, params, chain })
+    });
+    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)
    * This only signs - no on-chain transaction, no gas needed.
@@ -429,26 +1226,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;
@@ -467,18 +1264,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;
@@ -489,7 +1286,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;
@@ -498,15 +1295,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: {
@@ -514,8 +1311,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 };
   }
   /**
@@ -545,30 +1342,59 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
     };
   }
   /**
-   * Get wallet balances on all supported chains (Base + Polygon)
+   * Get wallet balances on all supported chains (Base + Polygon + Tempo)
    */
   async getAllBalances() {
     if (!this.wallet) {
       throw new Error("Client not initialized");
     }
-    const supportedChains = ["base", "polygon", "base_sepolia"];
+    const supportedChains = ["base", "polygon", "base_sepolia", "tempo_moderato", "bnb", "bnb_testnet"];
     const tokenAbi = ["function balanceOf(address) view returns (uint256)"];
     const results = {};
+    const tempoTokens = {
+      pathUSD: "0x20c0000000000000000000000000000000000000",
+      alphaUSD: "0x20c0000000000000000000000000000000000001",
+      betaUSD: "0x20c0000000000000000000000000000000000002",
+      thetaUSD: "0x20c0000000000000000000000000000000000003"
+    };
     await Promise.all(
       supportedChains.map(async (chainName) => {
         try {
           const chain = getChain(chainName);
           const provider = new ethers.JsonRpcProvider(chain.rpc);
-          const [nativeBalance, usdcBalance, usdtBalance] = await Promise.all([
-            provider.getBalance(this.wallet.address),
-            new ethers.Contract(chain.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
-            new ethers.Contract(chain.tokens.USDT.address, tokenAbi, provider).balanceOf(this.wallet.address)
-          ]);
-          results[chainName] = {
-            usdc: parseFloat(ethers.formatUnits(usdcBalance, chain.tokens.USDC.decimals)),
-            usdt: parseFloat(ethers.formatUnits(usdtBalance, chain.tokens.USDT.decimals)),
-            native: parseFloat(ethers.formatEther(nativeBalance))
-          };
+          if (chainName === "tempo_moderato") {
+            const [nativeBalance, pathUSD, alphaUSD, betaUSD, thetaUSD] = await Promise.all([
+              provider.getBalance(this.wallet.address),
+              new ethers.Contract(tempoTokens.pathUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new ethers.Contract(tempoTokens.alphaUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new ethers.Contract(tempoTokens.betaUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new ethers.Contract(tempoTokens.thetaUSD, tokenAbi, provider).balanceOf(this.wallet.address)
+            ]);
+            results[chainName] = {
+              usdc: parseFloat(ethers.formatUnits(pathUSD, 6)),
+              // pathUSD as default USDC
+              usdt: parseFloat(ethers.formatUnits(alphaUSD, 6)),
+              // alphaUSD as default USDT
+              native: parseFloat(ethers.formatEther(nativeBalance)),
+              tempo: {
+                pathUSD: parseFloat(ethers.formatUnits(pathUSD, 6)),
+                alphaUSD: parseFloat(ethers.formatUnits(alphaUSD, 6)),
+                betaUSD: parseFloat(ethers.formatUnits(betaUSD, 6)),
+                thetaUSD: parseFloat(ethers.formatUnits(thetaUSD, 6))
+              }
+            };
+          } else {
+            const [nativeBalance, usdcBalance, usdtBalance] = await Promise.all([
+              provider.getBalance(this.wallet.address),
+              new ethers.Contract(chain.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
+              new ethers.Contract(chain.tokens.USDT.address, tokenAbi, provider).balanceOf(this.wallet.address)
+            ]);
+            results[chainName] = {
+              usdc: parseFloat(ethers.formatUnits(usdcBalance, chain.tokens.USDC.decimals)),
+              usdt: parseFloat(ethers.formatUnits(usdtBalance, chain.tokens.USDT.decimals)),
+              native: parseFloat(ethers.formatEther(nativeBalance))
+            };
+          }
         } catch (err) {
           results[chainName] = { usdc: 0, usdt: 0, native: 0 };
         }
@@ -576,28 +1402,135 @@ Please specify: --chain base, --chain polygon, or --chain base_sepolia`
     );
     return results;
   }
+  /**
+   * Pay for a service using MPP (Machine Payments Protocol)
+   * 
+   * This implements the MPP flow manually for EOA wallets:
+   * 1. Request service → get 402 with WWW-Authenticate
+   * 2. Parse payment requirements
+   * 3. Execute transfer on Tempo chain
+   * 4. Retry with transaction hash as credential
+   * 
+   * @param url - Full URL of the MPP-enabled endpoint
+   * @param options - Request options (body, headers)
+   * @returns Response from the service
+   */
+  async payWithMPP(url, options = {}) {
+    if (!this.wallet || !this.walletData) {
+      throw new Error("Client not initialized. Run: npx moltspay init");
+    }
+    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] Making MPP request to: ${url}`);
+    console.log(`[MoltsPay] Using account: ${account.address}`);
+    const initResponse = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        ...options.headers
+      },
+      body: options.body ? JSON.stringify(options.body) : void 0
+    });
+    if (initResponse.status !== 402) {
+      if (initResponse.ok) {
+        return initResponse.json();
+      }
+      const errorText = await initResponse.text();
+      throw new Error(`Request failed (${initResponse.status}): ${errorText}`);
+    }
+    const wwwAuth = initResponse.headers.get("www-authenticate");
+    if (!wwwAuth || !wwwAuth.toLowerCase().includes("payment")) {
+      throw new Error("No WWW-Authenticate Payment challenge in 402 response");
+    }
+    console.log(`[MoltsPay] Got 402, parsing payment challenge...`);
+    const parseAuthParam = (header, key) => {
+      const match = header.match(new RegExp(`${key}="([^"]+)"`, "i"));
+      return match ? match[1] : null;
+    };
+    const challengeId = parseAuthParam(wwwAuth, "id");
+    const method = parseAuthParam(wwwAuth, "method");
+    const realm = parseAuthParam(wwwAuth, "realm");
+    const requestB64 = parseAuthParam(wwwAuth, "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);
+    console.log(`[MoltsPay] Payment request:`, paymentRequest);
+    const { amount, currency, recipient, methodDetails } = paymentRequest;
+    const chainId = methodDetails?.chainId || 42431;
+    console.log(`[MoltsPay] Executing transfer on Tempo (chainId: ${chainId})...`);
+    console.log(`[MoltsPay] Amount: ${amount}, To: ${recipient}`);
+    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 sent: ${txHash}`);
+    console.log(`[MoltsPay] Waiting for confirmation...`);
+    await publicClient.waitForTransactionReceipt({ hash: txHash });
+    console.log(`[MoltsPay] Transaction confirmed!`);
+    const challenge = {
+      id: challengeId,
+      realm,
+      method: "tempo",
+      intent: "charge",
+      request: paymentRequest
+    };
+    const credential = {
+      challenge,
+      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(/=+$/, "");
+    console.log(`[MoltsPay] Retrying with payment credential...`);
+    const paidResponse = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Payment ${credentialB64}`,
+        ...options.headers
+      },
+      body: options.body ? JSON.stringify(options.body) : void 0
+    });
+    if (!paidResponse.ok) {
+      const errorText = await paidResponse.text();
+      throw new Error(`Payment verification failed (${paidResponse.status}): ${errorText}`);
+    }
+    console.log(`[MoltsPay] Payment verified! Service completed.`);
+    return paidResponse.json();
+  }
 };
 
 // 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";
@@ -608,9 +1541,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;
@@ -800,23 +1733,462 @@ var CDPFacilitator = class extends BaseFacilitator {
     };
   }
   /**
-   * Check if a chain ID is testnet
+   * Check if a chain ID is testnet
+   */
+  static isTestnet(chainId) {
+    return TESTNET_CHAIN_IDS.includes(chainId);
+  }
+  /**
+   * Get configuration summary (for logging)
+   */
+  getConfigSummary() {
+    const hasCredentials = !!(this.apiKeyId && this.apiKeySecret);
+    const networks = this.supportedNetworks.join(", ");
+    return `CDP Facilitator (networks: ${networks}, credentials: ${hasCredentials ? "yes" : "no"})`;
+  }
+};
+
+// src/facilitators/tempo.ts
+init_esm_shims();
+var TRANSFER_EVENT_TOPIC = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+var TempoFacilitator = class extends BaseFacilitator {
+  name = "tempo";
+  displayName = "Tempo Testnet";
+  supportedNetworks = ["eip155:42431"];
+  // Tempo Moderato
+  rpcUrl;
+  constructor() {
+    super();
+    this.rpcUrl = CHAINS.tempo_moderato.rpc;
+  }
+  async healthCheck() {
+    const start = Date.now();
+    try {
+      const response = await fetch(this.rpcUrl, {
+        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 !== 42431) {
+        return { healthy: false, error: `Wrong chainId: ${chainId}` };
+      }
+      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 { success: false, error: `Settlement failed: ${error}` };
+    }
+  }
+  /**
+   * 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 receipt = await this.getTransactionReceipt(txHash, config.rpc);
+      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_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();
+      if (toAddress !== expected.to.toLowerCase()) {
+        return { valid: false, error: `Wrong recipient: ${toAddress}` };
+      }
+      const amount = BigInt(transferLog.data);
+      if (amount < BigInt(expected.amount)) {
+        return { valid: false, error: `Insufficient amount: ${amount}` };
+      }
+      return {
+        valid: true,
+        details: {
+          txHash,
+          from: "0x" + transferLog.topics[1].slice(26),
+          to: toAddress,
+          amount: amount.toString(),
+          token: transferLog.address
+        }
+      };
+    } catch (error) {
+      return { valid: false, error: `Verification failed: ${error}` };
+    }
+  }
+  // ==================== Private Methods ====================
+  /**
+   * Get the server's spender address (public, for 402 responses)
+   * Returns cached value computed at construction time.
    */
-  static isTestnet(chainId) {
-    return TESTNET_CHAIN_IDS.includes(chainId);
+  getSpenderAddress() {
+    return this.spenderAddress;
   }
-  /**
-   * Get configuration summary (for logging)
-   */
-  getConfigSummary() {
-    const hasCredentials = !!(this.apiKeyId && this.apiKeySecret);
-    const networks = this.supportedNetworks.join(", ");
-    return `CDP Facilitator (networks: ${networks}, credentials: ${hasCredentials ? "yes" : "no"})`;
+  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 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({
+        jsonrpc: "2.0",
+        method: "eth_getTransactionReceipt",
+        params: [txHash],
+        id: 1
+      })
+    });
+    const data = await response.json();
+    return data.result;
   }
 };
 
 // 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();
@@ -824,7 +2196,21 @@ var FacilitatorRegistry = class {
   roundRobinIndex = 0;
   constructor(selection) {
     this.registerFactory("cdp", (config) => new CDPFacilitator(config));
-    this.selection = selection || { primary: "cdp", strategy: "failover" };
+    this.registerFactory("tempo", () => new TempoFacilitator());
+    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
@@ -1048,6 +2434,9 @@ var X402_VERSION3 = 2;
 var PAYMENT_REQUIRED_HEADER2 = "x-payment-required";
 var PAYMENT_HEADER2 = "x-payment";
 var PAYMENT_RESPONSE_HEADER = "x-payment-response";
+var MPP_AUTH_HEADER = "authorization";
+var MPP_WWW_AUTH_HEADER = "www-authenticate";
+var MPP_RECEIPT_HEADER = "payment-receipt";
 var TOKEN_ADDRESSES = {
   "eip155:8453": {
     USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
@@ -1061,13 +2450,47 @@ var TOKEN_ADDRESSES = {
   "eip155:137": {
     USDC: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
     USDT: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F"
+  },
+  "eip155:42431": {
+    // Tempo Moderato testnet - TIP-20 stablecoins
+    USDC: "0x20c0000000000000000000000000000000000000",
+    // 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"
+  "polygon": "eip155:137",
+  "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": {
@@ -1084,6 +2507,21 @@ var TOKEN_DOMAINS = {
   "eip155:137": {
     USDC: { name: "USD Coin", version: "2" },
     USDT: { name: "(PoS) Tether USD", version: "2" }
+  },
+  // Tempo Moderato testnet - TIP-20 stablecoins
+  "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) {
@@ -1099,9 +2537,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;
@@ -1132,7 +2570,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,
@@ -1141,9 +2579,11 @@ var MoltsPayServer = class {
     };
     this.useMainnet = process.env.USE_MAINNET?.toLowerCase() === "true";
     this.networkId = this.useMainnet ? "eip155:8453" : "eip155:84532";
+    const defaultFallback = ["tempo", "bnb", "solana"];
+    const envFallback = process.env.FACILITATOR_FALLBACK?.split(",").filter(Boolean);
     const facilitatorConfig = options.facilitators || {
       primary: process.env.FACILITATOR_PRIMARY || "cdp",
-      fallback: process.env.FACILITATOR_FALLBACK?.split(",").filter(Boolean),
+      fallback: envFallback || defaultFallback,
       strategy: process.env.FACILITATOR_STRATEGY || "failover",
       config: {
         cdp: { useMainnet: this.useMainnet }
@@ -1182,12 +2622,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"]
         };
       });
@@ -1196,7 +2644,7 @@ var MoltsPayServer = class {
     const network = CHAIN_TO_NETWORK[chain] || this.networkId;
     return [{
       network,
-      wallet: provider.wallet,
+      wallet: getWalletForChain(chain),
       tokens: ["USDC"]
     }];
   }
@@ -1237,8 +2685,8 @@ var MoltsPayServer = class {
   async handleRequest(req, res) {
     res.setHeader("Access-Control-Allow-Origin", "*");
     res.setHeader("Access-Control-Allow-Methods", "GET, POST, OPTIONS");
-    res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Payment");
-    res.setHeader("Access-Control-Expose-Headers", "X-Payment-Required, X-Payment-Response");
+    res.setHeader("Access-Control-Allow-Headers", "Content-Type, X-Payment, Authorization");
+    res.setHeader("Access-Control-Expose-Headers", "X-Payment-Required, X-Payment-Response, WWW-Authenticate, Payment-Receipt");
     if (req.method === "OPTIONS") {
       res.writeHead(204);
       res.end();
@@ -1267,7 +2715,16 @@ 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);
+      if (skill && (req.method === "POST" || req.method === "GET")) {
+        const body = req.method === "POST" ? await this.readBody(req) : {};
+        const authHeader = req.headers[MPP_AUTH_HEADER];
+        const x402Header = req.headers[PAYMENT_HEADER2];
+        return await this.handleMPPRequest(skill, body, authHeader, x402Header, res);
       }
       this.sendJson(res, 404, { error: "Not found" });
     } catch (err) {
@@ -1296,7 +2753,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: {
@@ -1409,6 +2868,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;
@@ -1423,16 +2897,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) {
@@ -1452,6 +2929,187 @@ var MoltsPayServer = class {
       payment: settlement?.success ? { transaction: settlement.transaction, status: "settled", facilitator: settlement.facilitator } : { status: "pending" }
     }, responseHeaders);
   }
+  /**
+   * Handle MPP (Machine Payments Protocol) request
+   * Supports both x402 and MPP protocols on service endpoints
+   */
+  async handleMPPRequest(skill, body, authHeader, x402Header, res) {
+    const config = skill.config;
+    const params = body || {};
+    if (x402Header) {
+      return await this.handleExecute({ service: config.id, params }, x402Header, res);
+    }
+    if (authHeader && authHeader.toLowerCase().startsWith("payment ")) {
+      return await this.handleMPPPayment(skill, params, authHeader, res);
+    }
+    return this.sendMPPPaymentRequired(config, res);
+  }
+  /**
+   * Handle MPP payment verification and service execution
+   */
+  async handleMPPPayment(skill, params, authHeader, res) {
+    const config = skill.config;
+    const credentialMatch = authHeader.match(/Payment\s+(.+)/i);
+    if (!credentialMatch) {
+      return this.sendJson(res, 400, { error: "Invalid Authorization header format" });
+    }
+    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] Failed to parse MPP credential:", err);
+      return this.sendJson(res, 400, { error: "Invalid payment credential encoding" });
+    }
+    let txHash;
+    if (mppCredential.payload?.type === "hash" && mppCredential.payload?.hash) {
+      txHash = mppCredential.payload.hash;
+    } else if (mppCredential.payload?.type === "transaction") {
+      return this.sendJson(res, 400, {
+        error: "Transaction type not supported. Please use push mode (hash type)."
+      });
+    }
+    if (!txHash) {
+      return this.sendJson(res, 400, { error: "Missing transaction hash in credential" });
+    }
+    let chainId = mppCredential.challenge?.request?.methodDetails?.chainId;
+    if (!chainId && mppCredential.source) {
+      const chainMatch = mppCredential.source.match(/eip155:(\d+)/);
+      if (chainMatch) chainId = parseInt(chainMatch[1], 10);
+    }
+    chainId = chainId || 42431;
+    const network = `eip155:${chainId}`;
+    if (!this.isNetworkAccepted(network)) {
+      return this.sendJson(res, 402, {
+        error: `Network not accepted: ${network}`
+      });
+    }
+    const requirements = this.buildPaymentRequirements(
+      config,
+      network,
+      this.getWalletForNetwork(network),
+      "USDC"
+    );
+    const paymentPayload = {
+      x402Version: X402_VERSION3,
+      scheme: "exact",
+      network,
+      payload: {
+        txHash,
+        chainId
+      }
+    };
+    console.log(`[MoltsPay] Verifying MPP payment: txHash=${txHash}, chainId=${chainId}`);
+    const verification = await this.registry.verify(paymentPayload, requirements);
+    if (!verification.valid) {
+      return this.sendJson(res, 402, {
+        error: `Payment verification failed: ${verification.error}`
+      });
+    }
+    console.log(`[MoltsPay] Payment verified! Executing service: ${config.id}`);
+    let result;
+    try {
+      result = await skill.handler(params);
+    } catch (err) {
+      console.error(`[MoltsPay] Skill execution error:`, err);
+      return this.sendJson(res, 500, {
+        error: `Service execution failed: ${err.message}`
+      });
+    }
+    const receipt = {
+      success: true,
+      txHash,
+      network,
+      facilitator: verification.facilitator
+    };
+    const receiptEncoded = Buffer.from(JSON.stringify(receipt)).toString("base64");
+    res.writeHead(200, {
+      "Content-Type": "application/json",
+      [MPP_RECEIPT_HEADER]: receiptEncoded
+    });
+    res.end(JSON.stringify({
+      success: true,
+      result,
+      payment: {
+        txHash,
+        status: "verified",
+        facilitator: verification.facilitator
+      }
+    }, null, 2));
+  }
+  /**
+   * Return 402 with both x402 and MPP payment requirements
+   */
+  sendMPPPaymentRequired(config, res) {
+    const acceptedTokens = getAcceptedCurrencies(config);
+    const providerChains = this.getProviderChains();
+    const accepts = [];
+    for (const chainConfig of providerChains) {
+      for (const token of acceptedTokens) {
+        if (chainConfig.tokens.includes(token)) {
+          accepts.push(this.buildPaymentRequirements(config, chainConfig.network, chainConfig.wallet, token));
+        }
+      }
+    }
+    const x402PaymentRequired = {
+      x402Version: X402_VERSION3,
+      accepts,
+      acceptedCurrencies: acceptedTokens,
+      resource: {
+        url: `/${config.id}`,
+        description: `${config.name} - $${config.price} ${config.currency}`
+      }
+    };
+    const x402Encoded = Buffer.from(JSON.stringify(x402PaymentRequired)).toString("base64");
+    const tempoChain = providerChains.find((c) => c.network === "eip155:42431");
+    let mppWwwAuth = "";
+    if (tempoChain) {
+      const challengeId = this.generateChallengeId();
+      const amountInUnits = Math.floor(config.price * 1e6).toString();
+      const tokenAddress = TOKEN_ADDRESSES["eip155:42431"]?.USDC || "0x20c0000000000000000000000000000000000000";
+      const mppRequest = {
+        amount: amountInUnits,
+        currency: tokenAddress,
+        methodDetails: {
+          chainId: 42431,
+          feePayer: true
+        },
+        recipient: tempoChain.wallet
+      };
+      const mppRequestEncoded = Buffer.from(JSON.stringify(mppRequest)).toString("base64");
+      const expiresAt = new Date(Date.now() + 5 * 60 * 1e3).toISOString();
+      mppWwwAuth = `Payment id="${challengeId}", realm="${this.manifest.provider.name}", method="tempo", intent="charge", request="${mppRequestEncoded}", description="${config.name}", expires="${expiresAt}"`;
+    }
+    const headers = {
+      "Content-Type": "application/problem+json",
+      [PAYMENT_REQUIRED_HEADER2]: x402Encoded
+    };
+    if (mppWwwAuth) {
+      headers[MPP_WWW_AUTH_HEADER] = mppWwwAuth;
+    }
+    res.writeHead(402, headers);
+    res.end(JSON.stringify({
+      type: "https://paymentauth.org/problems/payment-required",
+      title: "Payment Required",
+      status: 402,
+      detail: `Payment is required (${config.name}).`,
+      service: config.id,
+      price: config.price,
+      currency: config.currency,
+      acceptedCurrencies: acceptedTokens
+    }, null, 2));
+  }
+  /**
+   * Generate a unique challenge ID for MPP
+   */
+  generateChallengeId() {
+    const bytes = new Uint8Array(24);
+    for (let i = 0; i < bytes.length; i++) {
+      bytes[i] = Math.floor(Math.random() * 256);
+    }
+    return Buffer.from(bytes).toString("base64url");
+  }
   /**
    * Return 402 with x402 payment requirements (v2 format)
    * Includes requirements for all chains and all accepted currencies
@@ -1527,7 +3185,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,
@@ -1536,6 +3194,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
@@ -1601,31 +3280,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",
@@ -1637,6 +3327,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);
@@ -1672,7 +3365,6 @@ var MoltsPayServer = class {
     console.log(`[MoltsPay] /proxy: Verified by ${verifyResult.facilitator}`);
     const { execute, service, params } = body;
     if (execute && service) {
-      console.log(`[MoltsPay] /proxy: Executing skill first (pay on success): ${service}`);
       const skill = this.skills.get(service);
       if (!skill) {
         console.log(`[MoltsPay] /proxy: Service not found: ${service} - NOT settling`);
@@ -1682,6 +3374,32 @@ var MoltsPayServer = class {
           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 {
@@ -1691,73 +3409,199 @@ var MoltsPayServer = class {
             (_, reject) => setTimeout(() => reject(new Error(`Skill timeout after ${timeoutSeconds}s`)), timeoutSeconds * 1e3)
           )
         ]);
-        console.log(`[MoltsPay] /proxy: Skill succeeded, now settling payment...`);
+        console.log(`[MoltsPay] /proxy: Skill succeeded`);
       } catch (err) {
-        console.error(`[MoltsPay] /proxy: Skill failed: ${err.message} - NOT settling`);
+        console.error(`[MoltsPay] /proxy: Skill failed: ${err.message}`);
         return this.sendJson(res, 500, {
           success: false,
-          paymentSettled: false,
-          error: `Service execution failed: ${err.message}`
+          paymentSettled: isSolana ? true : false,
+          error: `Service execution failed: ${err.message}`,
+          note: isSolana ? "Payment was settled before execution. Contact support for refund." : void 0
         });
       }
-      let settlement2 = null;
+      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" });
+    }
+    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" });
+    }
+    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 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, {
+        error: `Payment verification failed: ${verification.error}`
+      });
+    }
+    console.log(`[MoltsPay] /proxy MPP: Payment verified by ${verification.facilitator}`);
+    const { execute, service, params } = body;
+    if (execute && service) {
+      console.log(`[MoltsPay] /proxy MPP: Executing skill: ${service}`);
+      const skill = this.skills.get(service);
+      if (!skill) {
+        return this.sendJson(res, 404, {
+          success: false,
+          paymentSettled: true,
+          // Payment already happened on Tempo
+          error: `Service not found: ${service}`
+        });
+      }
+      const timeoutSeconds = parseInt(process.env.SKILL_TIMEOUT_SECONDS || "1200");
+      let result;
       try {
-        settlement2 = await this.registry.settle(payment, requirements);
-        console.log(`[MoltsPay] /proxy: Payment settled by ${settlement2.facilitator}: ${settlement2.transaction || "pending"}`);
+        result = await Promise.race([
+          skill.handler(params || {}),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error(`Skill timeout after ${timeoutSeconds}s`)), timeoutSeconds * 1e3)
+          )
+        ]);
       } 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
+        console.error(`[MoltsPay] /proxy MPP: Skill failed: ${err.message}`);
+        return this.sendJson(res, 500, {
+          success: false,
+          paymentSettled: true,
+          error: `Service execution failed: ${err.message}`
         });
       }
       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
     });
   }
@@ -1772,7 +3616,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,
@@ -1782,6 +3626,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
@@ -1826,11 +3681,114 @@ async function printQRCode(url) {
 
 // src/cli/index.ts
 import * as readline from "readline";
+if (!globalThis.crypto) {
+  globalThis.crypto = webcrypto;
+}
+function getVersion() {
+  const locations = [
+    join5(__dirname, "../../package.json"),
+    join5(__dirname, "../package.json"),
+    join5(process.cwd(), "node_modules/moltspay/package.json")
+  ];
+  for (const loc of locations) {
+    try {
+      if (existsSync5(loc)) {
+        const pkg = JSON.parse(readFileSync5(loc, "utf-8"));
+        if (pkg.name === "moltspay") return pkg.version;
+      }
+    } catch {
+    }
+  }
+  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({
@@ -1844,20 +3802,50 @@ function prompt(question) {
     });
   });
 }
-program.name("moltspay").description("MoltsPay - Payment infrastructure for AI Agents").version("1.0.0");
-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.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_DIR2).action(async (options) => {
   let chain = options.chain;
-  const supportedChains = ["base", "polygon", "base_sepolia"];
+  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) {
@@ -1879,13 +3867,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");
@@ -1920,37 +3916,77 @@ 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{1F4DD} Get testnet USDC from these faucets:");
-    console.log("   \u2022 Circle Faucet: https://faucet.circle.com/");
-    console.log("   \u2022 Base Sepolia: https://www.coinbase.com/faucets/base-ethereum-sepolia-faucet\n");
-    console.log(`\u{1F4A1} Send USDC to: ${client.address}
+    console.log("\u{1F4A1} Use the MoltsPay faucet to get free testnet USDC:\n");
+    console.log("   npx moltspay faucet\n");
+    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 {
@@ -1959,7 +3995,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
       })
@@ -1977,8 +4013,94 @@ program.command("fund <amount>").description("Fund wallet with USDC via Coinbase
     console.log(`\u274C ${error.message}`);
   }
 });
-program.command("faucet").description("Request testnet USDC from MoltsPay faucet (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", "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) {
     const client = new MoltsPayClient({ configDir: options.configDir });
     if (client.isInitialized) {
@@ -1993,37 +4115,110 @@ program.command("faucet").description("Request testnet USDC from MoltsPay faucet
     return;
   }
   console.log("\n\u{1F6B0} MoltsPay Testnet Faucet\n");
-  console.log(`   Requesting 1 USDC on Base Sepolia...`);
-  console.log(`   Address: ${address}
+  if (chain === "tempo_moderato") {
+    console.log(`   Requesting testnet tokens on Tempo Moderato...`);
+    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 })
-    });
-    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}`);
-      return;
+    try {
+      const TEMPO_FAUCET_API = "https://docs.tempo.xyz/api/faucet";
+      const response = await fetch(TEMPO_FAUCET_API, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ address })
+      });
+      const result = await response.json();
+      if (response.ok && result.data && result.data.length > 0) {
+        console.log(`\u2705 Received testnet tokens!
+`);
+        console.log(`   Tokens: pathUSD, AlphaUSD, BetaUSD, ThetaUSD (1M each)`);
+        console.log(`   Transactions:`);
+        for (const tx of result.data) {
+          console.log(`     https://explore.testnet.tempo.xyz/tx/${tx.hash}`);
+        }
+        console.log("\n\u{1F4A1} Use these tokens to test MPP payments:");
+        console.log(`   npx moltspay pay <service-url> <service-id> --chain tempo_moderato
+`);
+      } else {
+        console.log(`\u274C ${result.error || "Faucet request failed"}`);
+        console.log("\n   Try again later or use Tempo Wallet: https://wallet.tempo.xyz\n");
+      }
+    } catch (error) {
+      console.log(`\u274C ${error.message}`);
+      console.log("\n   Try Tempo Wallet instead: https://wallet.tempo.xyz\n");
     }
-    console.log(`\u2705 Received ${result.amount} USDC!
+  } else if (chain === "bnb_testnet") {
+    console.log(`   Requesting 1 USDC on BNB Testnet...`);
+    console.log(`   Address: ${address}
 `);
-    console.log(`   Transaction: ${result.transaction}`);
-    console.log(`   Explorer: ${result.explorer}`);
-    console.log(`   Faucet balance: ${result.faucet_balance} USDC remaining
+    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}
 `);
-    console.log("\u{1F4A1} Use this USDC to test x402 payments:");
-    console.log(`   npx moltspay pay <service-url> <service-id> --chain base_sepolia
+        return;
+      }
+      console.log(`\u2705 Received ${result.amount} ${result.token || "USDC"} on ${result.chain_name || "BNB Testnet"}!
 `);
-  } catch (error) {
-    console.log(`\u274C ${error.message}`);
+      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}
+`);
+    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: "base_sepolia" })
+      });
+      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}`);
+        return;
+      }
+      console.log(`\u2705 Received ${result.amount} USDC!
+`);
+      console.log(`   Transaction: ${result.transaction}`);
+      console.log(`   Explorer: ${result.explorer}`);
+      console.log(`   Faucet balance: ${result.faucet_balance} USDC remaining
+`);
+      console.log("\u{1F4A1} Use this USDC to test x402 payments:");
+      console.log(`   npx moltspay pay <service-url> <service-id> --chain base_sepolia
+`);
+    } catch (error) {
+      console.log(`\u274C ${error.message}`);
+    }
   }
 });
-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) {
@@ -2040,29 +4235,138 @@ 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}`);
     console.log("");
     console.log("   Balances:");
     for (const [chainName, balance] of Object.entries(allBalances)) {
-      const chainLabel = chainName.charAt(0).toUpperCase() + chainName.slice(1);
-      console.log(`     ${chainLabel.padEnd(10)} ${balance.usdc.toFixed(2)} USDC | ${balance.usdt.toFixed(2)} USDT`);
+      let chainLabel;
+      if (chainName === "base_sepolia") {
+        chainLabel = "Base Sepolia";
+      } else if (chainName === "tempo_moderato") {
+        chainLabel = "Tempo Moderato";
+      } else {
+        chainLabel = chainName.charAt(0).toUpperCase() + chainName.slice(1);
+      }
+      if (chainName === "tempo_moderato" && balance.tempo) {
+        const tempo = balance.tempo;
+        const nativeStr = balance.native > 1e12 ? balance.native.toExponential(2) : balance.native.toFixed(2);
+        console.log(`     ${chainLabel}:`);
+        console.log(`       Native:    ${nativeStr} TEMPO (for gas)`);
+        console.log(`       pathUSD:   ${tempo.pathUSD.toFixed(2)}`);
+        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");
@@ -2071,8 +4375,8 @@ program.command("list").description("List recent transactions").option("--days <
   const days = parseInt(options.days) || 7;
   const limit = parseInt(options.limit) || 20;
   const chain = options.chain?.toLowerCase() || "all";
-  if (!["base", "polygon", "base_sepolia", "all"].includes(chain)) {
-    console.log("\u274C Invalid chain. Use: base, polygon, base_sepolia, or all");
+  if (!["base", "polygon", "base_sepolia", "tempo_moderato", "all"].includes(chain)) {
+    console.log("\u274C Invalid chain. Use: base, polygon, base_sepolia, tempo_moderato, or all");
     return;
   }
   const wallet = client.address;
@@ -2092,9 +4396,16 @@ program.command("list").description("List recent transactions").option("--days <
       api: "https://base-sepolia.blockscout.com/api/v2",
       usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
       name: "Base Sepolia"
+    },
+    // Tempo explorer doesn't have public API yet
+    tempo_moderato: {
+      api: "",
+      // No API available
+      usdc: "0x20c0000000000000000000000000000000000000",
+      name: "Tempo Moderato"
     }
   };
-  const chainsToQuery = chain === "all" ? ["base", "polygon", "base_sepolia"] : [chain];
+  const chainsToQuery = chain === "all" ? ["base", "polygon", "base_sepolia", "tempo_moderato"] : [chain];
   console.log(`
 \u{1F4DC} Transactions (last ${days} day${days > 1 ? "s" : ""})
 `);
@@ -2102,27 +4413,136 @@ program.command("list").description("List recent transactions").option("--days <
   for (const c of chainsToQuery) {
     const explorer = explorers[c];
     try {
-      const url = `${explorer.api}/addresses/${wallet}/token-transfers?type=ERC-20&token=${explorer.usdc}`;
-      const response = await fetch(url);
-      const data = await response.json();
-      if (data.items && Array.isArray(data.items)) {
-        for (const tx of data.items) {
-          const timestamp = new Date(tx.timestamp).getTime();
-          if (timestamp < cutoffTime) continue;
-          const isIncoming = tx.to.hash.toLowerCase() === wallet.toLowerCase();
-          const decimals = parseInt(tx.total.decimals) || 6;
-          allTxns.push({
-            chain: c,
-            timestamp,
-            type: isIncoming ? "IN" : "OUT",
-            amount: parseInt(tx.total.value) / Math.pow(10, decimals),
-            other: isIncoming ? tx.from.hash : tx.to.hash,
-            hash: tx.transaction_hash
-          });
+      if (c === "tempo_moderato") {
+        const tempoTokens = [
+          { address: "0x20c0000000000000000000000000000000000000", name: "pathUSD" },
+          { address: "0x20c0000000000000000000000000000000000001", name: "alphaUSD" },
+          { address: "0x20c0000000000000000000000000000000000002", name: "betaUSD" },
+          { address: "0x20c0000000000000000000000000000000000003", name: "thetaUSD" }
+        ];
+        const transferTopic = "0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef";
+        const walletTopic = "0x000000000000000000000000" + wallet.toLowerCase().slice(2);
+        let latestBlock = 0;
+        for (let attempt = 0; attempt < 3; attempt++) {
+          try {
+            const blockRes = await fetch("https://rpc.moderato.tempo.xyz", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({ jsonrpc: "2.0", method: "eth_blockNumber", params: [], id: 1 })
+            });
+            const blockData = await blockRes.json();
+            if (blockData.result) {
+              latestBlock = parseInt(blockData.result, 16);
+              break;
+            }
+          } catch (e) {
+            if (attempt === 2) throw e;
+            await new Promise((r) => setTimeout(r, 500));
+          }
+        }
+        if (latestBlock === 0) {
+          console.log("   \u26A0\uFE0F  Tempo Moderato: Could not get latest block");
+          continue;
+        }
+        const maxBlocks = 1e5;
+        const blocksPerDay = 172800;
+        const requestedBlocks = blocksPerDay * days;
+        const actualBlocks = Math.min(requestedBlocks, maxBlocks);
+        const fromBlock = "0x" + Math.max(0, latestBlock - actualBlocks).toString(16);
+        const toBlock = "0x" + latestBlock.toString(16);
+        if (requestedBlocks > maxBlocks) {
+          console.log(`   \u2139\uFE0F  Tempo: querying last ~14 hours (RPC limit: 100k blocks)`);
+        }
+        for (const token of tempoTokens) {
+          try {
+            const inRes = await fetch("https://rpc.moderato.tempo.xyz", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                jsonrpc: "2.0",
+                method: "eth_getLogs",
+                params: [{ fromBlock, toBlock, address: token.address, topics: [transferTopic, null, walletTopic] }],
+                id: 1
+              })
+            });
+            const inData = await inRes.json();
+            if (inData.error) {
+              console.log(`   \u26A0\uFE0F  ${token.name}: ${inData.error.message}`);
+              continue;
+            }
+            if (inData.result && Array.isArray(inData.result)) {
+              for (const log of inData.result) {
+                const timestamp = parseInt(log.blockTimestamp, 16) * 1e3;
+                if (timestamp < cutoffTime) continue;
+                const amount = parseInt(log.data, 16) / 1e6;
+                const from = "0x" + log.topics[1].slice(26);
+                allTxns.push({
+                  chain: c,
+                  timestamp,
+                  type: "IN",
+                  amount,
+                  other: from,
+                  hash: log.transactionHash,
+                  token: token.name
+                });
+              }
+            }
+            const outRes = await fetch("https://rpc.moderato.tempo.xyz", {
+              method: "POST",
+              headers: { "Content-Type": "application/json" },
+              body: JSON.stringify({
+                jsonrpc: "2.0",
+                method: "eth_getLogs",
+                params: [{ fromBlock, toBlock, address: token.address, topics: [transferTopic, walletTopic, null] }],
+                id: 1
+              })
+            });
+            const outData = await outRes.json();
+            if (outData.result && Array.isArray(outData.result)) {
+              for (const log of outData.result) {
+                const timestamp = parseInt(log.blockTimestamp, 16) * 1e3;
+                if (timestamp < cutoffTime) continue;
+                const amount = parseInt(log.data, 16) / 1e6;
+                const to = "0x" + log.topics[2].slice(26);
+                allTxns.push({
+                  chain: c,
+                  timestamp,
+                  type: "OUT",
+                  amount,
+                  other: to,
+                  hash: log.transactionHash,
+                  token: token.name
+                });
+              }
+            }
+          } catch (tokenError) {
+            continue;
+          }
+        }
+      } else {
+        const url = `${explorer.api}/addresses/${wallet}/token-transfers?type=ERC-20&token=${explorer.usdc}`;
+        const response = await fetch(url);
+        const data = await response.json();
+        if (data.items && Array.isArray(data.items)) {
+          for (const tx of data.items) {
+            const timestamp = new Date(tx.timestamp).getTime();
+            if (timestamp < cutoffTime) continue;
+            const isIncoming = tx.to.hash.toLowerCase() === wallet.toLowerCase();
+            const decimals = parseInt(tx.total.decimals) || 6;
+            allTxns.push({
+              chain: c,
+              timestamp,
+              type: isIncoming ? "IN" : "OUT",
+              amount: parseInt(tx.total.value) / Math.pow(10, decimals),
+              other: isIncoming ? tx.from.hash : tx.to.hash,
+              hash: tx.transaction_hash
+            });
+          }
         }
       }
     } catch (error) {
-      console.log(`   \u26A0\uFE0F  ${explorer.name}: API error`);
+      const errMsg = error instanceof Error ? error.message : String(error);
+      console.log(`   \u26A0\uFE0F  ${explorer.name}: ${errMsg}`);
     }
   }
   allTxns.sort((a, b) => b.timestamp - a.timestamp);
@@ -2135,8 +4555,12 @@ program.command("list").description("List recent transactions").option("--days <
       const color = tx.type === "IN" ? "\x1B[32m" : "\x1B[31m";
       const reset = "\x1B[0m";
       const date = new Date(tx.timestamp).toISOString().slice(5, 16).replace("T", " ");
-      const chainTag = chain === "all" ? `[${tx.chain.toUpperCase()}] ` : "";
-      console.log(`   ${color}${sign}${tx.amount.toFixed(2)} USDC${reset} | ${chainTag}${tx.type === "IN" ? "from" : "to"} ${tx.other.slice(0, 10)}...${tx.other.slice(-4)} | ${date}`);
+      let chainLabel = tx.chain.toUpperCase();
+      if (tx.chain === "tempo_moderato") chainLabel = "TEMPO";
+      else if (tx.chain === "base_sepolia") chainLabel = "BASE_SEPOLIA";
+      const chainTag = chain === "all" ? `[${chainLabel}] ` : "";
+      const tokenName = tx.token || "USDC";
+      console.log(`   ${color}${sign}${tx.amount.toFixed(2)} ${tokenName}${reset} | ${chainTag}${tx.type === "IN" ? "from" : "to"} ${tx.other.slice(0, 10)}...${tx.other.slice(-4)} | ${date}`);
     }
     const inTotal = allTxns.filter((t) => t.type === "IN").reduce((s, t) => s + t.amount, 0);
     const outTotal = allTxns.filter((t) => t.type === "OUT").reduce((s, t) => s + t.amount, 0);
@@ -2145,39 +4569,88 @@ program.command("list").description("List recent transactions").option("--days <
 `);
   }
 });
-program.command("services <url>").description("List services from a provider").option("--json", "Output as JSON").action(async (url, options) => {
+program.command("services [url]").description("List services from registry or a specific provider").option("-q, --query <keyword>", "Search by keyword (name, description, tags)").option("--max-price <price>", "Maximum price in USD").option("--type <type>", "Filter by type: api_service | file_download").option("--tag <tag>", "Filter by tag").option("--json", "Output as JSON").action(async (url, options) => {
+  const MOLTSPAY_REGISTRY = "https://moltspay.com";
   try {
-    const client = new MoltsPayClient();
-    const services = await client.getServices(url);
+    let services;
+    let isRegistry = false;
+    if (url) {
+      const client = new MoltsPayClient();
+      services = await client.getServices(url);
+    } else {
+      isRegistry = true;
+      const params = new URLSearchParams();
+      if (options.query) params.set("q", options.query);
+      if (options.maxPrice) params.set("maxPrice", options.maxPrice);
+      if (options.type) params.set("type", options.type);
+      if (options.tag) params.set("tag", options.tag);
+      const queryString = params.toString();
+      const registryUrl = `${MOLTSPAY_REGISTRY}/registry/services${queryString ? "?" + queryString : ""}`;
+      const res = await fetch(registryUrl);
+      if (!res.ok) {
+        throw new Error(`Registry request failed: ${res.status}`);
+      }
+      services = await res.json();
+    }
     if (options.json) {
       console.log(JSON.stringify(services, null, 2));
     } else {
-      if (services.provider) {
-        console.log(`
-\u{1F3EA} ${services.provider.name}
+      const serviceList = services.services || [];
+      if (isRegistry) {
+        if (options.query) {
+          console.log(`
+\u{1F50D} Search: "${options.query}" (${serviceList.length} results)
+`);
+        } else {
+          const filters = [];
+          if (options.maxPrice) filters.push(`max $${options.maxPrice}`);
+          if (options.type) filters.push(options.type);
+          if (options.tag) filters.push(`#${options.tag}`);
+          const filterStr = filters.length > 0 ? ` (${filters.join(", ")})` : "";
+          console.log(`
+\u{1F50D} MoltsPay Registry${filterStr} - ${serviceList.length} services
 `);
-        console.log(`   ${services.provider.description || ""}`);
-        console.log(`   Wallet: ${services.provider.wallet}`);
-        const chains = services.provider.chains ? Array.isArray(services.provider.chains) ? services.provider.chains.map((c) => typeof c === "string" ? c : c.chain).join(", ") : services.provider.chains : services.provider.chain || "base";
-        console.log(`   Chains: ${chains}`);
+        }
+        for (const svc of serviceList) {
+          const name = (svc.name || svc.id).slice(0, 30).padEnd(30);
+          const price = `$${svc.price}`.padEnd(8);
+          const type = (svc.type || "unknown").padEnd(14);
+          const provider = `@${svc.provider?.username || "unknown"}`;
+          console.log(`   ${name} ${price} ${type} ${provider}`);
+        }
+        if (serviceList.length > 0) {
+          console.log(`
+   \u{1F4A1} Use: moltspay pay <provider-url> <service-id>
+`);
+        }
       } else {
-        console.log(`
-\u{1F3EA} MoltsPay Service Registry
+        if (services.provider) {
+          console.log(`
+\u{1F3EA} ${services.provider.name}
+`);
+          console.log(`   ${services.provider.description || ""}`);
+          console.log(`   Wallet: ${services.provider.wallet}`);
+          const chains = services.provider.chains ? Array.isArray(services.provider.chains) ? services.provider.chains.map((c) => typeof c === "string" ? c : c.chain).join(", ") : services.provider.chains : services.provider.chain || "base";
+          console.log(`   Chains: ${chains}`);
+        } else {
+          console.log(`
+\u{1F3EA} Provider Services
 `);
-        console.log(`   ${services.services?.length || 0} services available`);
-      }
-      console.log("\n\u{1F4E6} Services:\n");
-      for (const svc of services.services) {
-        const status = svc.available !== false ? "\u2705" : "\u274C";
-        console.log(`   ${status} ${svc.id || svc.name}`);
-        console.log(`      ${svc.name} - $${svc.price} ${svc.currency}`);
-        if (svc.description) {
-          console.log(`      ${svc.description}`);
+          console.log(`   ${serviceList.length} services available`);
         }
-        if (svc.provider && !services.provider) {
-          console.log(`      Provider: ${svc.provider.name || svc.provider.username}`);
+        console.log("\n\u{1F4E6} Services:\n");
+        for (const svc of serviceList) {
+          const status = svc.available !== false ? "\u2705" : "\u274C";
+          console.log(`   ${status} ${svc.id || svc.name}`);
+          console.log(`      ${svc.name} - $${svc.price} ${svc.currency}`);
+          if (svc.description) {
+            console.log(`      ${svc.description}`);
+          }
+          if (svc.provider && !services.provider) {
+            console.log(`      Provider: ${svc.provider.name || svc.provider.username}`);
+          }
+          console.log("");
         }
-        console.log("");
       }
     }
   } catch (err) {
@@ -2200,14 +4673,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 {
@@ -2216,25 +4689,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}`);
@@ -2312,8 +4785,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}`);
@@ -2326,12 +4799,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 {
       }
     };
@@ -2352,12 +4825,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
@@ -2382,7 +4855,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");
@@ -2391,8 +4864,8 @@ 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, or base_sepolia). Required if server accepts multiple chains.").option("--json", "Output raw JSON only").action(async (server, service, paramsJson, options) => {
-  const client = new MoltsPayClient();
+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, 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);
@@ -2413,21 +4886,18 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
       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");
     }
   }
-  if (!params.prompt) {
-    console.error("\u274C Missing prompt. Use --prompt or pass JSON params");
-    process.exit(1);
-  }
+  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"].includes(chain)) {
-    console.error(`\u274C Unknown chain: ${chain}. Supported: base, polygon, base_sepolia`);
+  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);
@@ -2481,9 +4951,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}`);
@@ -2493,7 +4963,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");