moltspay 0.9.3 → 0.9.6

package/dist/index.mjs

@@ -30802,16 +30802,24 @@ var X402_VERSION2 = 2;
 var PAYMENT_REQUIRED_HEADER = "x-payment-required";
 var PAYMENT_HEADER = "x-payment";
 var PAYMENT_RESPONSE_HEADER = "x-payment-response";
-var USDC_ADDRESSES = {
-  "eip155:8453": "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
-  // Base mainnet
-  "eip155:84532": "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
-  // Base Sepolia
+var TOKEN_ADDRESSES = {
+  "eip155:8453": {
+    USDC: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    USDT: "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2"
+  },
+  "eip155:84532": {
+    USDC: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+    USDT: "0x036CbD53842c5426634e7929541eC2318f3dCF7e"
+    // Same as USDC on testnet
+  }
 };
-var USDC_DOMAIN = {
-  name: "USD Coin",
-  version: "2"
+var TOKEN_DOMAINS = {
+  USDC: { name: "USD Coin", version: "2" },
+  USDT: { name: "Tether USD", version: "2" }
 };
+function getAcceptedCurrencies(config) {
+  return config.acceptedCurrencies ?? [config.currency];
+}
 function loadEnvFile2() {
   const envPaths = [
     path3.join(process.cwd(), ".env"),
@@ -30923,6 +30931,9 @@ var MoltsPayServer = class {
       if (url.pathname === "/services" && req.method === "GET") {
         return this.handleGetServices(res);
       }
+      if (url.pathname === "/.well-known/agent-services.json" && req.method === "GET") {
+        return this.handleAgentServicesDiscovery(res);
+      }
       if (url.pathname === "/health" && req.method === "GET") {
         return await this.handleHealthCheck(res);
       }
@@ -30946,6 +30957,44 @@ var MoltsPayServer = class {
       this.sendJson(res, 500, { error: err.message || "Internal error" });
     }
   }
+  /**
+   * GET /.well-known/agent-services.json - Standard discovery endpoint
+   */
+  handleAgentServicesDiscovery(res) {
+    const services = this.manifest.services.map((s) => ({
+      id: s.id,
+      name: s.name,
+      description: s.description,
+      price: s.price,
+      currency: s.currency,
+      acceptedCurrencies: getAcceptedCurrencies(s),
+      input: s.input,
+      output: s.output,
+      available: this.skills.has(s.id)
+    }));
+    this.sendJson(res, 200, {
+      version: "1.0",
+      provider: {
+        name: this.manifest.provider.name,
+        description: this.manifest.provider.description,
+        wallet: this.manifest.provider.wallet,
+        chain: this.manifest.provider.chain || "base"
+      },
+      services,
+      endpoints: {
+        services: "/services",
+        execute: "/execute",
+        health: "/health"
+      },
+      payment: {
+        protocol: "x402",
+        version: X402_VERSION2,
+        network: this.networkId,
+        schemes: ["exact"],
+        mainnet: this.useMainnet
+      }
+    });
+  }
   /**
    * GET /services - List available services
    */
@@ -30956,6 +31005,7 @@ var MoltsPayServer = class {
       description: s.description,
       price: s.price,
       currency: s.currency,
+      acceptedCurrencies: getAcceptedCurrencies(s),
       input: s.input,
       output: s.output,
       available: this.skills.has(s.id)
@@ -31022,7 +31072,14 @@ var MoltsPayServer = class {
     if (!validation.valid) {
       return this.sendJson(res, 402, { error: validation.error });
     }
-    const requirements = this.buildPaymentRequirements(skill.config);
+    const paymentToken = this.detectPaymentToken(payment);
+    if (paymentToken && !this.isTokenAccepted(skill.config, paymentToken)) {
+      const accepted = getAcceptedCurrencies(skill.config);
+      return this.sendJson(res, 402, {
+        error: `Token ${paymentToken} not accepted. Accepted: ${accepted.join(", ")}`
+      });
+    }
+    const requirements = this.buildPaymentRequirements(skill.config, paymentToken);
     console.log(`[MoltsPay] Verifying payment...`);
     const verifyResult = await this.registry.verify(payment, requirements);
     if (!verifyResult.valid) {
@@ -31032,10 +31089,16 @@ var MoltsPayServer = class {
       });
     }
     console.log(`[MoltsPay] Verified by ${verifyResult.facilitator}`);
-    console.log(`[MoltsPay] Executing skill: ${service}`);
+    const timeoutSeconds = parseInt(process.env.SKILL_TIMEOUT_SECONDS || "1200");
+    console.log(`[MoltsPay] Executing skill: ${service} (timeout: ${timeoutSeconds}s)`);
     let result;
     try {
-      result = await skill.handler(params || {});
+      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] Skill execution failed:", err.message);
       return this.sendJson(res, 500, {
@@ -31071,12 +31134,15 @@ var MoltsPayServer = class {
   }
   /**
    * Return 402 with x402 payment requirements (v2 format)
+   * Includes requirements for all accepted currencies
    */
   sendPaymentRequired(config, res) {
-    const requirements = this.buildPaymentRequirements(config);
+    const acceptedTokens = getAcceptedCurrencies(config);
+    const accepts = acceptedTokens.map((token) => this.buildPaymentRequirements(config, token));
     const paymentRequired = {
       x402Version: X402_VERSION2,
-      accepts: [requirements],
+      accepts,
+      acceptedCurrencies: acceptedTokens,
       resource: {
         url: `/execute?service=${config.id}`,
         description: `${config.name} - $${config.price} ${config.currency}`,
@@ -31091,6 +31157,7 @@ var MoltsPayServer = class {
     res.end(JSON.stringify({
       error: "Payment required",
       message: `Service requires $${config.price} ${config.currency}`,
+      acceptedCurrencies: acceptedTokens,
       x402: paymentRequired
     }, null, 2));
   }
@@ -31113,20 +31180,47 @@ var MoltsPayServer = class {
   }
   /**
    * Build payment requirements for facilitator
+   * Returns requirements for the primary currency (USDC by default)
+   * Server accepts any of the acceptedCurrencies
    */
-  buildPaymentRequirements(config) {
+  buildPaymentRequirements(config, token) {
     const amountInUnits = Math.floor(config.price * 1e6).toString();
-    const usdcAddress = USDC_ADDRESSES[this.networkId];
+    const acceptedTokens = getAcceptedCurrencies(config);
+    const selectedToken = token && acceptedTokens.includes(token) ? token : acceptedTokens[0];
+    const tokenAddresses = TOKEN_ADDRESSES[this.networkId] || {};
+    const tokenAddress = tokenAddresses[selectedToken];
+    const tokenDomain = TOKEN_DOMAINS[selectedToken] || TOKEN_DOMAINS.USDC;
     return {
       scheme: "exact",
       network: this.networkId,
-      asset: usdcAddress,
+      asset: tokenAddress,
       amount: amountInUnits,
       payTo: this.manifest.provider.wallet,
       maxTimeoutSeconds: 300,
-      extra: USDC_DOMAIN
+      extra: tokenDomain
     };
   }
+  /**
+   * Detect which token is being used in the payment
+   */
+  detectPaymentToken(payment) {
+    const asset = payment.accepted?.asset || payment.payload?.asset;
+    if (!asset) return void 0;
+    const tokenAddresses = TOKEN_ADDRESSES[this.networkId] || {};
+    for (const [symbol, address] of Object.entries(tokenAddresses)) {
+      if (address.toLowerCase() === asset.toLowerCase()) {
+        return symbol;
+      }
+    }
+    return void 0;
+  }
+  /**
+   * Check if payment token is accepted for service
+   */
+  isTokenAccepted(config, token) {
+    const accepted = getAcceptedCurrencies(config);
+    return accepted.includes(token);
+  }
   async readBody(req) {
     return new Promise((resolve, reject) => {
       let body = "";
@@ -31244,9 +31338,15 @@ var MoltsPayServer = class {
           error: `Service not found: ${service}`
         });
       }
+      const timeoutSeconds = parseInt(process.env.SKILL_TIMEOUT_SECONDS || "1200");
       let result;
       try {
-        result = await skill.handler(params || {});
+        result = await Promise.race([
+          skill.handler(params || {}),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error(`Skill timeout after ${timeoutSeconds}s`)), timeoutSeconds * 1e3)
+          )
+        ]);
         console.log(`[MoltsPay] /proxy: Skill succeeded, now settling payment...`);
       } catch (err) {
         console.error(`[MoltsPay] /proxy: Skill failed: ${err.message} - NOT settling`);
@@ -31320,18 +31420,22 @@ var MoltsPayServer = class {
   /**
    * Build payment requirements for proxy endpoint (uses provided wallet)
    */
-  buildProxyPaymentRequirements(config, wallet) {
+  buildProxyPaymentRequirements(config, wallet, token) {
     const amountInUnits = Math.floor(config.price * 1e6).toString();
-    const usdcAddress = USDC_ADDRESSES[this.networkId];
+    const acceptedTokens = getAcceptedCurrencies(config);
+    const selectedToken = token && acceptedTokens.includes(token) ? token : acceptedTokens[0];
+    const tokenAddresses = TOKEN_ADDRESSES[this.networkId] || {};
+    const tokenAddress = tokenAddresses[selectedToken];
+    const tokenDomain = TOKEN_DOMAINS[selectedToken] || TOKEN_DOMAINS.USDC;
     return {
       scheme: "exact",
       network: this.networkId,
-      asset: usdcAddress,
+      asset: tokenAddress,
       amount: amountInUnits,
       payTo: wallet,
       // Use provided wallet, not manifest
       maxTimeoutSeconds: 300,
-      extra: USDC_DOMAIN
+      extra: tokenDomain
     };
   }
   /**
@@ -31377,7 +31481,20 @@ var CHAINS = {
     name: "Base",
     chainId: 8453,
     rpc: "https://mainnet.base.org",
+    tokens: {
+      USDC: {
+        address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+        decimals: 6,
+        symbol: "USDC"
+      },
+      USDT: {
+        address: "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2",
+        decimals: 6,
+        symbol: "USDT"
+      }
+    },
     usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
+    // deprecated, for backward compat
     explorer: "https://basescan.org/address/",
     explorerTx: "https://basescan.org/tx/",
     avgBlockTime: 2
@@ -31386,6 +31503,18 @@ var CHAINS = {
     name: "Polygon",
     chainId: 137,
     rpc: "https://polygon-rpc.com",
+    tokens: {
+      USDC: {
+        address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
+        decimals: 6,
+        symbol: "USDC"
+      },
+      USDT: {
+        address: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
+        decimals: 6,
+        symbol: "USDT"
+      }
+    },
     usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
     explorer: "https://polygonscan.com/address/",
     explorerTx: "https://polygonscan.com/tx/",
@@ -31395,6 +31524,18 @@ var CHAINS = {
     name: "Ethereum",
     chainId: 1,
     rpc: "https://eth.llamarpc.com",
+    tokens: {
+      USDC: {
+        address: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
+        decimals: 6,
+        symbol: "USDC"
+      },
+      USDT: {
+        address: "0xdAC17F958D2ee523a2206206994597C13D831ec7",
+        decimals: 6,
+        symbol: "USDT"
+      }
+    },
     usdc: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
     explorer: "https://etherscan.io/address/",
     explorerTx: "https://etherscan.io/tx/",
@@ -31405,6 +31546,19 @@ var CHAINS = {
     name: "Base Sepolia",
     chainId: 84532,
     rpc: "https://sepolia.base.org",
+    tokens: {
+      USDC: {
+        address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+        decimals: 6,
+        symbol: "USDC"
+      },
+      USDT: {
+        address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
+        // Same as USDC on testnet (no official USDT)
+        decimals: 6,
+        symbol: "USDT"
+      }
+    },
     usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
     explorer: "https://sepolia.basescan.org/address/",
     explorerTx: "https://sepolia.basescan.org/tx/",
@@ -31414,6 +31568,19 @@ var CHAINS = {
     name: "Sepolia",
     chainId: 11155111,
     rpc: "https://rpc.sepolia.org",
+    tokens: {
+      USDC: {
+        address: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+        decimals: 6,
+        symbol: "USDC"
+      },
+      USDT: {
+        address: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+        // Same as USDC on testnet
+        decimals: 6,
+        symbol: "USDT"
+      }
+    },
     usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
     explorer: "https://sepolia.etherscan.io/address/",
     explorerTx: "https://sepolia.etherscan.io/tx/",
@@ -31522,8 +31689,13 @@ var MoltsPayClient = class {
    * 
    * This is GASLESS for the client - server pays gas to claim payment.
    * This is PAY-FOR-SUCCESS - payment only claimed if service succeeds.
+   * 
+   * @param serverUrl - Server URL
+   * @param service - Service ID
+   * @param params - Service parameters
+   * @param options - Payment options (token selection)
    */
-  async pay(serverUrl, service, params) {
+  async pay(serverUrl, service, params, options = {}) {
     if (!this.wallet || !this.walletData) {
       throw new Error("Client not initialized. Run: npx moltspay init");
     }
@@ -31570,12 +31742,25 @@ var MoltsPayClient = class {
     }
     const amount = Number(amountRaw) / 1e6;
     this.checkLimits(amount);
-    console.log(`[MoltsPay] Signing payment: $${amount} USDC (gasless)`);
+    let token = options.token || "USDC";
+    if (options.autoSelect) {
+      const balances = await this.getBalance();
+      if (balances.usdc >= amount) {
+        token = "USDC";
+      } else if (balances.usdt >= amount) {
+        token = "USDT";
+      } else {
+        throw new Error(`Insufficient balance: need $${amount}, have ${balances.usdc} USDC / ${balances.usdt} USDT`);
+      }
+    }
+    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");
     }
-    const authorization = await this.signEIP3009(payTo, amount, chain2);
+    const authorization = await this.signEIP3009(payTo, amount, chain2, token);
+    const tokenConfig = chain2.tokens[token];
+    const tokenName = token === "USDC" ? "USD Coin" : "Tether USD";
     const payload = {
       x402Version: X402_VERSION3,
       payload: authorization,
@@ -31583,11 +31768,11 @@ var MoltsPayClient = class {
       accepted: {
         scheme: "exact",
         network,
-        asset: req.asset || chain2.usdc,
+        asset: tokenConfig.address,
         amount: amountRaw,
         payTo,
         maxTimeoutSeconds: req.maxTimeoutSeconds || 300,
-        extra: req.extra || { name: "USD Coin", version: "2" }
+        extra: req.extra || { name: tokenName, version: "2" }
       }
     };
     const paymentHeader = Buffer.from(JSON.stringify(payload)).toString("base64");
@@ -31611,12 +31796,14 @@ var MoltsPayClient = class {
   /**
    * Sign EIP-3009 transferWithAuthorization (GASLESS)
    * This only signs - no on-chain transaction, no gas needed.
+   * Supports both USDC and USDT.
    */
-  async signEIP3009(to, amount, chain2) {
+  async signEIP3009(to, amount, chain2, token = "USDC") {
     const validAfter = 0;
     const validBefore = Math.floor(Date.now() / 1e3) + 3600;
     const nonce = ethers.hexlify(ethers.randomBytes(32));
-    const value = BigInt(Math.floor(amount * 1e6)).toString();
+    const tokenConfig = chain2.tokens[token];
+    const value = BigInt(Math.floor(amount * 10 ** tokenConfig.decimals)).toString();
     const authorization = {
       from: this.wallet.address,
       to,
@@ -31625,11 +31812,12 @@ var MoltsPayClient = class {
       validBefore: validBefore.toString(),
       nonce
     };
+    const tokenName = token === "USDC" ? "USD Coin" : "Tether USD";
     const domain = {
-      name: "USD Coin",
+      name: tokenName,
       version: "2",
       chainId: chain2.chainId,
-      verifyingContract: chain2.usdc
+      verifyingContract: tokenConfig.address
     };
     const types = {
       TransferWithAuthorization: [
@@ -31764,7 +31952,7 @@ var MoltsPayClient = class {
     return { address: wallet.address, configDir };
   }
   /**
-   * Get wallet balance
+   * Get wallet balance (USDC, USDT, and native token)
    */
   async getBalance() {
     if (!this.wallet) {
@@ -31777,12 +31965,15 @@ var MoltsPayClient = class {
       throw new Error(`Unknown chain: ${this.config.chain}`);
     }
     const provider = new ethers.JsonRpcProvider(chain2.rpc);
-    const nativeBalance = await provider.getBalance(this.wallet.address);
-    const usdcAbi = ["function balanceOf(address) view returns (uint256)"];
-    const usdc = new ethers.Contract(chain2.usdc, usdcAbi, provider);
-    const usdcBalance = await usdc.balanceOf(this.wallet.address);
+    const tokenAbi = ["function balanceOf(address) view returns (uint256)"];
+    const [nativeBalance, usdcBalance, usdtBalance] = await Promise.all([
+      provider.getBalance(this.wallet.address),
+      new ethers.Contract(chain2.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
+      new ethers.Contract(chain2.tokens.USDT.address, tokenAbi, provider).balanceOf(this.wallet.address)
+    ]);
     return {
-      usdc: parseFloat(ethers.formatUnits(usdcBalance, 6)),
+      usdc: parseFloat(ethers.formatUnits(usdcBalance, chain2.tokens.USDC.decimals)),
+      usdt: parseFloat(ethers.formatUnits(usdtBalance, chain2.tokens.USDT.decimals)),
       native: parseFloat(ethers.formatEther(nativeBalance))
     };
   }
@@ -31918,7 +32109,7 @@ init_esm_shims();
 import { ethers as ethers4 } from "ethers";
 var TRANSFER_EVENT_TOPIC = ethers4.id("Transfer(address,address,uint256)");
 async function verifyPayment(params) {
-  const { txHash, expectedAmount, expectedTo } = params;
+  const { txHash, expectedAmount, expectedTo, expectedToken } = params;
   let chain2;
   try {
     if (typeof params.chain === "number") {
@@ -31941,12 +32132,20 @@ async function verifyPayment(params) {
     if (receipt.status !== 1) {
       return { verified: false, error: "Transaction failed" };
     }
-    const usdcAddress = chain2.usdc?.toLowerCase();
-    if (!usdcAddress) {
-      return { verified: false, error: `Chain ${chain2.name} USDC address not configured` };
+    const tokenAddresses = {};
+    if (!expectedToken || expectedToken === "USDC") {
+      tokenAddresses[chain2.tokens.USDC.address.toLowerCase()] = "USDC";
+    }
+    if (!expectedToken || expectedToken === "USDT") {
+      tokenAddresses[chain2.tokens.USDT.address.toLowerCase()] = "USDT";
+    }
+    if (Object.keys(tokenAddresses).length === 0) {
+      return { verified: false, error: `No token addresses configured for ${chain2.name}` };
     }
     for (const log of receipt.logs) {
-      if (log.address.toLowerCase() !== usdcAddress) {
+      const logAddress = log.address.toLowerCase();
+      const detectedToken = tokenAddresses[logAddress];
+      if (!detectedToken) {
         continue;
       }
       if (log.topics.length < 3 || log.topics[0] !== TRANSFER_EVENT_TOPIC) {
@@ -31955,15 +32154,17 @@ async function verifyPayment(params) {
       const from = "0x" + log.topics[1].slice(-40);
       const to = "0x" + log.topics[2].slice(-40);
       const amountRaw = BigInt(log.data);
-      const amount = Number(amountRaw) / 1e6;
+      const tokenConfig = chain2.tokens[detectedToken];
+      const amount = Number(amountRaw) / 10 ** tokenConfig.decimals;
       if (expectedTo && to.toLowerCase() !== expectedTo.toLowerCase()) {
         continue;
       }
       if (amount < expectedAmount) {
         return {
           verified: false,
-          error: `Insufficient amount: received ${amount} USDC, expected ${expectedAmount} USDC`,
+          error: `Insufficient amount: received ${amount} ${detectedToken}, expected ${expectedAmount}`,
           amount,
+          token: detectedToken,
           from,
           to,
           txHash,
@@ -31973,13 +32174,15 @@ async function verifyPayment(params) {
       return {
         verified: true,
         amount,
+        token: detectedToken,
         from,
         to,
         txHash,
         blockNumber: receipt.blockNumber
       };
     }
-    return { verified: false, error: "No USDC transfer found" };
+    const tokenList = expectedToken ? expectedToken : "USDC/USDT";
+    return { verified: false, error: `No ${tokenList} transfer found` };
   } catch (e) {
     return { verified: false, error: e.message || String(e) };
   }