moltspay 0.9.6 → 1.0.0

package/dist/cli/index.mjs

@@ -41,7 +41,7 @@ var CHAINS = {
   polygon: {
     name: "Polygon",
     chainId: 137,
-    rpc: "https://polygon-rpc.com",
+    rpc: "https://polygon-bor-rpc.publicnode.com",
     tokens: {
       USDC: {
         address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
@@ -217,10 +217,14 @@ var MoltsPayClient = class {
       throw new Error("Client not initialized. Run: npx moltspay init");
     }
     console.log(`[MoltsPay] Requesting service: ${service}`);
+    const requestBody = { service, params };
+    if (options.chain) {
+      requestBody.chain = options.chain;
+    }
     const initialRes = await fetch(`${serverUrl}/execute`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ service, params })
+      body: JSON.stringify(requestBody)
     });
     if (initialRes.status !== 402) {
       const data = await initialRes.json();
@@ -247,11 +251,41 @@ var MoltsPayClient = class {
     } catch {
       throw new Error("Invalid x-payment-required header");
     }
-    const chain = getChain(this.config.chain);
+    const networkToChainName = (network2) => {
+      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";
+      return null;
+    };
+    const serverChains = requirements.map((r) => networkToChainName(r.network)).filter((c) => c !== null);
+    let chainName;
+    const userSpecifiedChain = options.chain;
+    if (userSpecifiedChain) {
+      if (!serverChains.includes(userSpecifiedChain)) {
+        throw new Error(
+          `Server doesn't accept '${userSpecifiedChain}'.
+Server accepts: ${serverChains.join(", ")}`
+        );
+      }
+      chainName = userSpecifiedChain;
+    } else {
+      if (serverChains.length === 1 && serverChains[0] === "base") {
+        chainName = "base";
+      } else {
+        throw new Error(
+          `Server accepts: ${serverChains.join(", ")}
+Please specify: --chain base  or  --chain polygon`
+        );
+      }
+    }
+    const chain = getChain(chainName);
     const network = `eip155:${chain.chainId}`;
     const req = requirements.find((r) => r.scheme === "exact" && r.network === network);
     if (!req) {
-      throw new Error(`No matching payment option for ${network}`);
+      throw new Error(`Failed to find payment requirement for ${chainName}`);
     }
     const amountRaw = req.amount || req.maxAmountRequired;
     if (!amountRaw) {
@@ -270,7 +304,17 @@ var MoltsPayClient = class {
         throw new Error(`Insufficient balance: need $${amount}, have ${balances.usdc} USDC / ${balances.usdt} USDT`);
       }
     }
-    console.log(`[MoltsPay] Signing payment: $${amount} ${token} (gasless)`);
+    if (token === "USDT") {
+      const balances = await this.getBalance();
+      if (balances.native < 1e-4) {
+        throw new Error(
+          `USDT requires ETH for gas (~$0.01 on Base). Your ETH balance: ${balances.native.toFixed(6)} ETH. Please add a small amount of ETH to your wallet, or use USDC (gasless).`
+        );
+      }
+      console.log(`[MoltsPay] \u26A0\uFE0F  USDT requires gas (~$0.01). Proceeding with payment...`);
+    } else {
+      console.log(`[MoltsPay] Signing payment: $${amount} ${token} (gasless)`);
+    }
     const payTo = req.payTo || req.resource;
     if (!payTo) {
       throw new Error("Missing payTo address in payment requirements");
@@ -294,13 +338,17 @@ var MoltsPayClient = class {
     };
     const paymentHeader = Buffer.from(JSON.stringify(payload)).toString("base64");
     console.log(`[MoltsPay] Sending request with payment...`);
+    const paidRequestBody = { service, params };
+    if (options.chain) {
+      paidRequestBody.chain = options.chain;
+    }
     const paidRes = await fetch(`${serverUrl}/execute`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
         [PAYMENT_HEADER]: paymentHeader
       },
-      body: JSON.stringify({ service, params })
+      body: JSON.stringify(paidRequestBody)
     });
     const result = await paidRes.json();
     if (!paidRes.ok) {
@@ -469,7 +517,7 @@ var MoltsPayClient = class {
     return { address: wallet.address, configDir };
   }
   /**
-   * Get wallet balance (USDC, USDT, and native token)
+   * Get wallet balance (USDC, USDT, and native token) on default chain
    */
   async getBalance() {
     if (!this.wallet) {
@@ -494,6 +542,38 @@ var MoltsPayClient = class {
       native: parseFloat(ethers.formatEther(nativeBalance))
     };
   }
+  /**
+   * Get wallet balances on all supported chains (Base + Polygon)
+   */
+  async getAllBalances() {
+    if (!this.wallet) {
+      throw new Error("Client not initialized");
+    }
+    const supportedChains = ["base", "polygon"];
+    const tokenAbi = ["function balanceOf(address) view returns (uint256)"];
+    const results = {};
+    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))
+          };
+        } catch (err) {
+          results[chainName] = { usdc: 0, usdt: 0, native: 0 };
+        }
+      })
+    );
+    return results;
+  }
 };
 
 // src/server/index.ts
@@ -558,7 +638,7 @@ var CDPFacilitator = class extends BaseFacilitator {
     this.apiKeyId = config.apiKeyId || process.env.CDP_API_KEY_ID;
     this.apiKeySecret = config.apiKeySecret || process.env.CDP_API_KEY_SECRET;
     this.endpoint = this.useMainnet ? CDP_MAINNET_URL : CDP_TESTNET_URL;
-    this.supportedNetworks = this.useMainnet ? ["eip155:8453"] : ["eip155:8453", "eip155:84532"];
+    this.supportedNetworks = this.useMainnet ? ["eip155:8453", "eip155:137"] : ["eip155:8453", "eip155:84532", "eip155:137"];
     if (this.useMainnet && (!this.apiKeyId || !this.apiKeySecret)) {
       console.warn("[CDPFacilitator] WARNING: Mainnet mode but missing CDP credentials!");
       console.warn("[CDPFacilitator] Set CDP_API_KEY_ID and CDP_API_KEY_SECRET");
@@ -959,8 +1039,17 @@ var TOKEN_ADDRESSES = {
     USDC: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
     USDT: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
     // Same as USDC on testnet
+  },
+  "eip155:137": {
+    USDC: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+    USDT: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F"
   }
 };
+var CHAIN_TO_NETWORK = {
+  "base": "eip155:8453",
+  "base_sepolia": "eip155:84532",
+  "polygon": "eip155:137"
+};
 var TOKEN_DOMAINS = {
   USDC: { name: "USD Coin", version: "2" },
   USDT: { name: "Tether USD", version: "2" }
@@ -1026,11 +1115,17 @@ var MoltsPayServer = class {
     };
     this.registry = new FacilitatorRegistry(facilitatorConfig);
     const primaryFacilitator = this.registry.get(facilitatorConfig.primary);
-    const networkName = this.useMainnet ? "Base mainnet" : "Base Sepolia (testnet)";
     console.log(`[MoltsPay] Loaded ${this.manifest.services.length} services from ${servicesPath}`);
     console.log(`[MoltsPay] Provider: ${this.manifest.provider.name}`);
     console.log(`[MoltsPay] Receive wallet: ${this.manifest.provider.wallet}`);
-    console.log(`[MoltsPay] Network: ${this.networkId} (${networkName})`);
+    const chains = this.manifest.provider.chains;
+    if (chains && chains.length > 0) {
+      const chainNames = chains.map((c) => c.chain || c.network).join(", ");
+      console.log(`[MoltsPay] Chains: ${chainNames} (multi-chain enabled)`);
+    } else {
+      const networkName = this.useMainnet ? "Base mainnet" : "Base Sepolia (testnet)";
+      console.log(`[MoltsPay] Network: ${this.networkId} (${networkName})`);
+    }
     console.log(`[MoltsPay] Facilitator: ${primaryFacilitator.displayName} (${facilitatorConfig.strategy || "failover"})`);
     console.log(`[MoltsPay] Protocol: x402 (gasless for both client AND server)`);
   }
@@ -1045,6 +1140,42 @@ var MoltsPayServer = class {
     this.skills.set(serviceId, { id: serviceId, config, handler });
     return this;
   }
+  /**
+   * Get all configured chains for this provider
+   * Returns array of { network, wallet, tokens } for each chain
+   */
+  getProviderChains() {
+    const provider = this.manifest.provider;
+    if (provider.chains && provider.chains.length > 0) {
+      return provider.chains.map((c) => ({
+        network: c.network || CHAIN_TO_NETWORK[c.chain] || "eip155:8453",
+        wallet: c.wallet || provider.wallet,
+        tokens: c.tokens || ["USDC"]
+      }));
+    }
+    const chain = provider.chain || "base";
+    const network = CHAIN_TO_NETWORK[chain] || this.networkId;
+    return [{
+      network,
+      wallet: provider.wallet,
+      tokens: ["USDC"]
+    }];
+  }
+  /**
+   * Get wallet address for a specific network
+   */
+  getWalletForNetwork(network) {
+    const chains = this.getProviderChains();
+    const chain = chains.find((c) => c.network === network);
+    return chain?.wallet || this.manifest.provider.wallet;
+  }
+  /**
+   * Check if a network is accepted by this provider
+   */
+  isNetworkAccepted(network) {
+    const chains = this.getProviderChains();
+    return chains.some((c) => c.network === network);
+  }
   /**
    * Start HTTP server
    */
@@ -1227,7 +1358,9 @@ var MoltsPayServer = class {
         error: `Token ${paymentToken} not accepted. Accepted: ${accepted.join(", ")}`
       });
     }
-    const requirements = this.buildPaymentRequirements(skill.config, paymentToken);
+    const paymentNetwork = payment.accepted?.network || payment.network || this.networkId;
+    const paymentWallet = this.getWalletForNetwork(paymentNetwork);
+    const requirements = this.buildPaymentRequirements(skill.config, paymentNetwork, paymentWallet, paymentToken);
     console.log(`[MoltsPay] Verifying payment...`);
     const verifyResult = await this.registry.verify(payment, requirements);
     if (!verifyResult.valid) {
@@ -1282,15 +1415,29 @@ var MoltsPayServer = class {
   }
   /**
    * Return 402 with x402 payment requirements (v2 format)
-   * Includes requirements for all accepted currencies
+   * Includes requirements for all chains and all accepted currencies
    */
   sendPaymentRequired(config, res) {
     const acceptedTokens = getAcceptedCurrencies(config);
-    const accepts = acceptedTokens.map((token) => this.buildPaymentRequirements(config, token));
+    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 acceptedChains = providerChains.map((c) => {
+      if (c.network === "eip155:8453") return "base";
+      if (c.network === "eip155:137") return "polygon";
+      return c.network;
+    });
     const paymentRequired = {
       x402Version: X402_VERSION3,
       accepts,
       acceptedCurrencies: acceptedTokens,
+      acceptedChains,
       resource: {
         url: `/execute?service=${config.id}`,
         description: `${config.name} - $${config.price} ${config.currency}`,
@@ -1306,6 +1453,7 @@ var MoltsPayServer = class {
       error: "Payment required",
       message: `Service requires $${config.price} ${config.currency}`,
       acceptedCurrencies: acceptedTokens,
+      acceptedChains,
       x402: paymentRequired
     }, null, 2));
   }
@@ -1317,46 +1465,50 @@ var MoltsPayServer = class {
       return { valid: false, error: `Unsupported x402 version: ${payment.x402Version}` };
     }
     const scheme = payment.accepted?.scheme || payment.scheme;
-    const network = payment.accepted?.network || payment.network;
+    const network = payment.accepted?.network || payment.network || this.networkId;
     if (scheme !== "exact") {
       return { valid: false, error: `Unsupported scheme: ${scheme}` };
     }
-    if (network !== this.networkId) {
-      return { valid: false, error: `Network mismatch: expected ${this.networkId}, got ${network}` };
+    if (!this.isNetworkAccepted(network)) {
+      const acceptedChains = this.getProviderChains().map((c) => c.network).join(", ");
+      return { valid: false, error: `Network not accepted: ${network}. Accepted: ${acceptedChains}` };
     }
     return { valid: true };
   }
   /**
    * Build payment requirements for facilitator
-   * Returns requirements for the primary currency (USDC by default)
-   * Server accepts any of the acceptedCurrencies
+   * Now supports multi-chain: takes network and wallet as parameters
    */
-  buildPaymentRequirements(config, token) {
+  buildPaymentRequirements(config, network, wallet, token) {
     const amountInUnits = Math.floor(config.price * 1e6).toString();
     const acceptedTokens = getAcceptedCurrencies(config);
+    const selectedNetwork = network || this.networkId;
+    const selectedWallet = wallet || this.manifest.provider.wallet;
     const selectedToken = token && acceptedTokens.includes(token) ? token : acceptedTokens[0];
-    const tokenAddresses = TOKEN_ADDRESSES[this.networkId] || {};
+    const tokenAddresses = TOKEN_ADDRESSES[selectedNetwork] || {};
     const tokenAddress = tokenAddresses[selectedToken];
     const tokenDomain = TOKEN_DOMAINS[selectedToken] || TOKEN_DOMAINS.USDC;
     return {
       scheme: "exact",
-      network: this.networkId,
+      network: selectedNetwork,
       asset: tokenAddress,
       amount: amountInUnits,
-      payTo: this.manifest.provider.wallet,
+      payTo: selectedWallet,
       maxTimeoutSeconds: 300,
       extra: tokenDomain
     };
   }
   /**
    * Detect which token is being used in the payment
+   * Checks across all supported networks
    */
   detectPaymentToken(payment) {
     const asset = payment.accepted?.asset || payment.payload?.asset;
     if (!asset) return void 0;
-    const tokenAddresses = TOKEN_ADDRESSES[this.networkId] || {};
+    const paymentNetwork = payment.accepted?.network || payment.network || this.networkId;
+    const tokenAddresses = TOKEN_ADDRESSES[paymentNetwork] || {};
     for (const [symbol, address] of Object.entries(tokenAddresses)) {
-      if (address.toLowerCase() === asset.toLowerCase()) {
+      if (address && address.toLowerCase() === asset.toLowerCase()) {
         return symbol;
       }
     }
@@ -1431,6 +1583,10 @@ var MoltsPayServer = class {
     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",
@@ -1442,9 +1598,9 @@ var MoltsPayServer = class {
       input: {},
       output: {}
     };
-    const requirements = this.buildProxyPaymentRequirements(proxyConfig, wallet);
+    const requirements = this.buildProxyPaymentRequirements(proxyConfig, wallet, currency, chain);
     if (!paymentHeader) {
-      return this.sendProxyPaymentRequired(proxyConfig, wallet, memo, res);
+      return this.sendProxyPaymentRequired(proxyConfig, wallet, memo, chain, res);
     }
     let payment;
     try {
@@ -1461,8 +1617,9 @@ var MoltsPayServer = class {
     if (scheme !== "exact") {
       return this.sendJson(res, 402, { error: `Unsupported scheme: ${scheme}` });
     }
-    if (network !== this.networkId) {
-      return this.sendJson(res, 402, { error: `Network mismatch: expected ${this.networkId}, got ${network}` });
+    const expectedNetwork = chain ? CHAIN_TO_NETWORK[chain] || this.networkId : this.networkId;
+    if (network !== expectedNetwork) {
+      return this.sendJson(res, 402, { error: `Network mismatch: expected ${expectedNetwork}, got ${network}` });
     }
     console.log(`[MoltsPay] /proxy: Verifying payment for ${wallet}...`);
     const verifyResult = await this.registry.verify(payment, requirements);
@@ -1568,16 +1725,17 @@ var MoltsPayServer = class {
   /**
    * Build payment requirements for proxy endpoint (uses provided wallet)
    */
-  buildProxyPaymentRequirements(config, wallet, token) {
+  buildProxyPaymentRequirements(config, wallet, token, chain) {
     const amountInUnits = Math.floor(config.price * 1e6).toString();
     const acceptedTokens = getAcceptedCurrencies(config);
+    const networkId = chain ? CHAIN_TO_NETWORK[chain] || this.networkId : this.networkId;
     const selectedToken = token && acceptedTokens.includes(token) ? token : acceptedTokens[0];
-    const tokenAddresses = TOKEN_ADDRESSES[this.networkId] || {};
+    const tokenAddresses = TOKEN_ADDRESSES[networkId] || TOKEN_ADDRESSES[this.networkId] || {};
     const tokenAddress = tokenAddresses[selectedToken];
     const tokenDomain = TOKEN_DOMAINS[selectedToken] || TOKEN_DOMAINS.USDC;
     return {
       scheme: "exact",
-      network: this.networkId,
+      network: networkId,
       asset: tokenAddress,
       amount: amountInUnits,
       payTo: wallet,
@@ -1589,8 +1747,8 @@ var MoltsPayServer = class {
   /**
    * Return 402 with x402 payment requirements for proxy endpoint
    */
-  sendProxyPaymentRequired(config, wallet, memo, res) {
-    const requirements = this.buildProxyPaymentRequirements(config, wallet);
+  sendProxyPaymentRequired(config, wallet, memo, chain, res) {
+    const requirements = this.buildProxyPaymentRequirements(config, wallet, config.currency, chain);
     const paymentRequired = {
       x402Version: X402_VERSION3,
       accepts: [requirements],
@@ -1716,29 +1874,31 @@ program.command("status").description("Show wallet status and balance").option("
     return;
   }
   const config = client.getConfig();
-  let balance = { usdc: 0, usdt: 0, native: 0 };
+  let allBalances = {};
   try {
-    balance = await client.getBalance();
+    allBalances = await client.getAllBalances();
   } catch (err) {
-    console.error("Warning: Could not fetch balance:", err.message);
+    console.error("Warning: Could not fetch balances:", err.message);
   }
   if (options.json) {
     console.log(JSON.stringify({
       address: client.address,
-      chain: config.chain,
-      balance,
+      balances: allBalances,
       limits: config.limits
     }, null, 2));
   } else {
-    console.log("\n\u{1F4CA} MoltsPay Status\n");
-    console.log(`   Wallet: ${client.address}`);
-    console.log(`   Chain: ${config.chain}`);
-    console.log(`   Balance: ${balance.usdc.toFixed(2)} USDC | ${balance.usdt.toFixed(2)} USDT`);
-    console.log(`   Native: ${balance.native.toFixed(6)} ETH`);
+    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`);
+    }
     console.log("");
-    console.log("   Limits:");
-    console.log(`     Max per tx: $${config.limits.maxPerTx}`);
-    console.log(`     Max per day: $${config.limits.maxPerDay}`);
+    console.log("   Spending Limits:");
+    console.log(`     Per Transaction: $${config.limits.maxPerTx}`);
+    console.log(`     Daily:           $${config.limits.maxPerDay}`);
     console.log("");
   }
 });
@@ -1977,7 +2137,7 @@ 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("--json", "Output raw JSON only").action(async (server, service, paramsJson, options) => {
+program.command("pay <server> <service> [params]").description("Pay for a service and get the result").option("--prompt <text>", "Prompt for the service").option("--image <path>", "Image URL or local file path").option("--token <token>", "Token to pay with (USDC or USDT)", "USDC").option("--chain <chain>", "Chain to pay on (base or polygon). Required if server accepts multiple chains.").option("--json", "Output raw JSON only").action(async (server, service, paramsJson, options) => {
   const client = new MoltsPayClient();
   if (!client.isInitialized) {
     console.error("\u274C Wallet not initialized. Run: npx moltspay init");
@@ -2011,8 +2171,25 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
     console.error("\u274C Missing prompt. Use --prompt or pass JSON params");
     process.exit(1);
   }
+  const chain = options.chain?.toLowerCase();
+  if (chain && !["base", "polygon"].includes(chain)) {
+    console.error(`\u274C Unknown chain: ${chain}. Supported: base, polygon`);
+    process.exit(1);
+  }
   const imageDisplay = params.image_url || (params.image_base64 ? `[local file: ${options.image}]` : null);
   const token = (options.token || "USDC").toUpperCase();
+  if (token === "USDT") {
+    const balance = await client.getBalance();
+    if (balance.native < 1e-4) {
+      console.log("\n\u26A0\uFE0F  USDT requires a small amount of ETH for gas (~$0.01)");
+      console.log(`   Your ETH balance: ${balance.native.toFixed(6)} ETH`);
+      console.log("   Please add a tiny amount of ETH to your wallet.\n");
+      process.exit(1);
+    }
+    if (!options.json) {
+      console.log("\n\u26A0\uFE0F  Note: USDT payments require gas (~$0.01 on Base)");
+    }
+  }
   if (!options.json) {
     console.log(`
 \u{1F4B3} MoltsPay - Paying for service
@@ -2021,12 +2198,16 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
     console.log(`   Service: ${service}`);
     console.log(`   Prompt: ${params.prompt}`);
     if (imageDisplay) console.log(`   Image: ${imageDisplay}`);
+    console.log(`   Chain: ${chain || "(auto)"}`);
     console.log(`   Token: ${token}`);
     console.log(`   Wallet: ${client.address}`);
     console.log("");
   }
   try {
-    const result = await client.pay(server, service, params, { token });
+    const result = await client.pay(server, service, params, {
+      token,
+      chain
+    });
     if (options.json) {
       console.log(JSON.stringify(result));
     } else {