moltspay 0.9.7 → 1.1.0

package/dist/index.js

@@ -30438,7 +30438,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");
@@ -30853,8 +30853,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" }
@@ -30920,11 +30929,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)`);
   }
@@ -30939,6 +30954,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 chain2 = provider.chain || "base";
+    const network = CHAIN_TO_NETWORK[chain2] || this.networkId;
+    return [{
+      network,
+      wallet: provider.wallet,
+      tokens: ["USDC"]
+    }];
+  }
+  /**
+   * Get wallet address for a specific network
+   */
+  getWalletForNetwork(network) {
+    const chains = this.getProviderChains();
+    const chain2 = chains.find((c) => c.network === network);
+    return chain2?.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
    */
@@ -31121,7 +31172,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) {
@@ -31176,15 +31229,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_VERSION2,
       accepts,
       acceptedCurrencies: acceptedTokens,
+      acceptedChains,
       resource: {
         url: `/execute?service=${config.id}`,
         description: `${config.name} - $${config.price} ${config.currency}`,
@@ -31200,6 +31267,7 @@ var MoltsPayServer = class {
       error: "Payment required",
       message: `Service requires $${config.price} ${config.currency}`,
       acceptedCurrencies: acceptedTokens,
+      acceptedChains,
       x402: paymentRequired
     }, null, 2));
   }
@@ -31211,46 +31279,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;
       }
     }
@@ -31325,6 +31397,10 @@ var MoltsPayServer = class {
     if (isNaN(amountNum) || amountNum <= 0) {
       return this.sendJson(res, 400, { error: "Invalid amount" });
     }
+    const supportedChains = ["base", "polygon", "base_sepolia"];
+    if (chain2 && !supportedChains.includes(chain2)) {
+      return this.sendJson(res, 400, { error: `Unsupported chain: ${chain2}. Supported: ${supportedChains.join(", ")}` });
+    }
     const proxyConfig = {
       id: serviceId || "proxy",
       name: description || "Proxy Payment",
@@ -31336,9 +31412,9 @@ var MoltsPayServer = class {
       input: {},
       output: {}
     };
-    const requirements = this.buildProxyPaymentRequirements(proxyConfig, wallet);
+    const requirements = this.buildProxyPaymentRequirements(proxyConfig, wallet, currency, chain2);
     if (!paymentHeader) {
-      return this.sendProxyPaymentRequired(proxyConfig, wallet, memo, res);
+      return this.sendProxyPaymentRequired(proxyConfig, wallet, memo, chain2, res);
     }
     let payment;
     try {
@@ -31355,8 +31431,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 = chain2 ? CHAIN_TO_NETWORK[chain2] || 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);
@@ -31462,16 +31539,17 @@ var MoltsPayServer = class {
   /**
    * Build payment requirements for proxy endpoint (uses provided wallet)
    */
-  buildProxyPaymentRequirements(config, wallet, token) {
+  buildProxyPaymentRequirements(config, wallet, token, chain2) {
     const amountInUnits = Math.floor(config.price * 1e6).toString();
     const acceptedTokens = getAcceptedCurrencies(config);
+    const networkId = chain2 ? CHAIN_TO_NETWORK[chain2] || 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,
@@ -31483,8 +31561,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, chain2, res) {
+    const requirements = this.buildProxyPaymentRequirements(config, wallet, config.currency, chain2);
     const paymentRequired = {
       x402Version: X402_VERSION2,
       accepts: [requirements],
@@ -31544,7 +31622,7 @@ var CHAINS = {
   polygon: {
     name: "Polygon",
     chainId: 137,
-    rpc: "https://polygon-rpc.com",
+    rpc: "https://polygon-bor-rpc.publicnode.com",
     tokens: {
       USDC: {
         address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
@@ -31720,11 +31798,20 @@ var MoltsPayClient = class {
    * Get services from a provider
    */
   async getServices(serverUrl) {
-    const res = await fetch(`${serverUrl}/services`);
-    if (!res.ok) {
-      throw new Error(`Failed to get services: ${res.statusText}`);
+    const normalizedUrl = serverUrl.replace(/\/(services|api\/services|registry\/services)\/?$/, "");
+    const endpoints = ["/services", "/api/services", "/registry/services"];
+    for (const endpoint of endpoints) {
+      try {
+        const res = await fetch(`${normalizedUrl}${endpoint}`);
+        if (!res.ok) continue;
+        const contentType = res.headers.get("content-type") || "";
+        if (!contentType.includes("application/json")) continue;
+        return await res.json();
+      } catch {
+        continue;
+      }
     }
-    return res.json();
+    throw new Error(`Failed to get services: no valid endpoint found at ${normalizedUrl}`);
   }
   /**
    * Pay for a service and get the result (x402 protocol)
@@ -31742,10 +31829,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();
@@ -31772,11 +31863,41 @@ var MoltsPayClient = class {
     } catch {
       throw new Error("Invalid x-payment-required header");
     }
-    const chain2 = 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 chain2 = getChain(chainName);
     const network = `eip155:${chain2.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) {
@@ -31829,13 +31950,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_HEADER2]: paymentHeader
       },
-      body: JSON.stringify({ service, params })
+      body: JSON.stringify(paidRequestBody)
     });
     const result = await paidRes.json();
     if (!paidRes.ok) {
@@ -32004,7 +32129,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) {
@@ -32029,6 +32154,38 @@ var MoltsPayClient = class {
       native: parseFloat(import_ethers.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 chain2 = getChain(chainName);
+          const provider = new import_ethers.ethers.JsonRpcProvider(chain2.rpc);
+          const [nativeBalance, usdcBalance, usdtBalance] = await Promise.all([
+            provider.getBalance(this.wallet.address),
+            new import_ethers.ethers.Contract(chain2.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
+            new import_ethers.ethers.Contract(chain2.tokens.USDT.address, tokenAbi, provider).balanceOf(this.wallet.address)
+          ]);
+          results[chainName] = {
+            usdc: parseFloat(import_ethers.ethers.formatUnits(usdcBalance, chain2.tokens.USDC.decimals)),
+            usdt: parseFloat(import_ethers.ethers.formatUnits(usdtBalance, chain2.tokens.USDT.decimals)),
+            native: parseFloat(import_ethers.ethers.formatEther(nativeBalance))
+          };
+        } catch (err) {
+          results[chainName] = { usdc: 0, usdt: 0, native: 0 };
+        }
+      })
+    );
+    return results;
+  }
 };
 
 // src/wallet/index.ts