moltspay 1.2.1 → 1.3.0

package/dist/cli/index.mjs

@@ -7,14 +7,19 @@ 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";
@@ -107,6 +112,35 @@ 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
   }
 };
 function getChain(name) {
@@ -545,30 +579,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"];
     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,6 +639,121 @@ 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 } = await import("viem/accounts");
+    const { createWalletClient, createPublicClient, http } = await import("viem");
+    const { tempoModerato } = await import("viem/chains");
+    const { Actions } = await import("viem/tempo");
+    const privateKey = this.walletData.privateKey;
+    const account = privateKeyToAccount(privateKey);
+    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
@@ -815,6 +993,127 @@ var CDPFacilitator = class extends BaseFacilitator {
   }
 };
 
+// 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/registry.ts
 init_esm_shims();
 var FacilitatorRegistry = class {
@@ -824,7 +1123,8 @@ 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.selection = selection || { primary: "cdp", fallback: ["tempo"], strategy: "failover" };
   }
   /**
    * Register a new facilitator factory
@@ -1048,6 +1348,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,12 +1364,20 @@ var TOKEN_ADDRESSES = {
   "eip155:137": {
     USDC: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
     USDT: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F"
+  },
+  "eip155:42431": {
+    // Tempo Moderato testnet - TIP-20 stablecoins
+    USDC: "0x20c0000000000000000000000000000000000000",
+    // pathUSD
+    USDT: "0x20c0000000000000000000000000000000000001"
+    // alphaUSD
   }
 };
 var CHAIN_TO_NETWORK = {
   "base": "eip155:8453",
   "base_sepolia": "eip155:84532",
-  "polygon": "eip155:137"
+  "polygon": "eip155:137",
+  "tempo_moderato": "eip155:42431"
 };
 var TOKEN_DOMAINS = {
   // Base mainnet
@@ -1084,6 +1395,11 @@ 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" }
   }
 };
 function getTokenDomain(network, token) {
@@ -1141,9 +1457,11 @@ var MoltsPayServer = class {
     };
     this.useMainnet = process.env.USE_MAINNET?.toLowerCase() === "true";
     this.networkId = this.useMainnet ? "eip155:8453" : "eip155:84532";
+    const defaultFallback = ["tempo"];
+    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 }
@@ -1237,8 +1555,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();
@@ -1269,6 +1587,14 @@ var MoltsPayServer = class {
         const paymentHeader = req.headers[PAYMENT_HEADER2];
         return await this.handleProxy(body, paymentHeader, 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) {
       console.error("[MoltsPay] Error:", err);
@@ -1452,6 +1778,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
@@ -1826,6 +2333,26 @@ async function printQRCode(url) {
 
 // src/cli/index.ts
 import * as readline from "readline";
+if (!globalThis.crypto) {
+  globalThis.crypto = webcrypto;
+}
+function getVersion() {
+  const locations = [
+    join4(__dirname, "../../package.json"),
+    join4(__dirname, "../package.json"),
+    join4(process.cwd(), "node_modules/moltspay/package.json")
+  ];
+  for (const loc of locations) {
+    try {
+      if (existsSync4(loc)) {
+        const pkg = JSON.parse(readFileSync4(loc, "utf-8"));
+        if (pkg.name === "moltspay") return pkg.version;
+      }
+    } catch {
+    }
+  }
+  return "0.0.0";
+}
 var program = new Command();
 var DEFAULT_CONFIG_DIR = join4(homedir2(), ".moltspay");
 var PID_FILE = join4(DEFAULT_CONFIG_DIR, "server.pid");
@@ -1844,7 +2371,7 @@ function prompt(question) {
     });
   });
 }
-program.name("moltspay").description("MoltsPay - Payment infrastructure for AI Agents").version("1.0.0");
+program.name("moltspay").description("MoltsPay - Payment infrastructure for AI Agents").version(getVersion());
 program.command("init").description("Initialize MoltsPay client (create wallet, set limits)").option("--chain <chain>", "Blockchain to use", "base").option("--max-per-tx <amount>", "Max amount per transaction").option("--max-per-day <amount>", "Max amount per day").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).action(async (options) => {
   console.log("\n\u{1F510} MoltsPay Client Setup\n");
   if (existsSync4(join4(options.configDir, "wallet.json"))) {
@@ -1853,7 +2380,7 @@ program.command("init").description("Initialize MoltsPay client (create wallet,
     return;
   }
   let chain = options.chain;
-  const supportedChains = ["base", "polygon", "base_sepolia"];
+  const supportedChains = ["base", "polygon", "base_sepolia", "tempo_moderato"];
   if (!supportedChains.includes(chain)) {
     console.error(`\u274C Unknown chain: ${chain}. Supported: ${supportedChains.join(", ")}`);
     process.exit(1);
@@ -1941,11 +2468,9 @@ program.command("fund <amount>").description("Fund wallet with USDC via Coinbase
     console.log(`   Wallet: ${client.address}`);
     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;
   }
   console.log("\n\u{1F4B3} Fund your agent wallet\n");
@@ -1977,8 +2502,13 @@ 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("faucet").description("Request testnet tokens from faucet (Base Sepolia or Tempo Moderato)").option("--chain <chain>", "Chain to get tokens on (base_sepolia or tempo_moderato)", "base_sepolia").option("--address <address>", "Wallet address (defaults to your wallet)").option("--config-dir <dir>", "Config directory", DEFAULT_CONFIG_DIR).action(async (options) => {
   let address = options.address;
+  const chain = options.chain?.toLowerCase() || "base_sepolia";
+  if (!["base_sepolia", "tempo_moderato"].includes(chain)) {
+    console.log("\u274C Invalid chain. Use: base_sepolia or tempo_moderato");
+    return;
+  }
   if (!address) {
     const client = new MoltsPayClient({ configDir: options.configDir });
     if (client.isInitialized) {
@@ -1993,34 +2523,67 @@ 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 {
+    console.log(`   Requesting 1 USDC on Base Sepolia...`);
+    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 })
+      });
+      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("\u{1F4A1} Use this USDC to test x402 payments:");
-    console.log(`   npx moltspay pay <service-url> <service-id> --chain base_sepolia
+      console.log(`   Transaction: ${result.transaction}`);
+      console.log(`   Explorer: ${result.explorer}`);
+      console.log(`   Faucet balance: ${result.faucet_balance} USDC remaining
 `);
-  } catch (error) {
-    console.log(`\u274C ${error.message}`);
+      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) => {
@@ -2052,8 +2615,26 @@ program.command("status").description("Show wallet status and balance").option("
     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 {
+        console.log(`     ${chainLabel.padEnd(14)} ${balance.usdc.toFixed(2)} USDC | ${balance.usdt.toFixed(2)} USDT`);
+      }
     }
     console.log("");
     console.log("   Spending Limits:");
@@ -2071,8 +2652,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 +2673,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 +2690,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 +2832,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 +2846,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)
 `);
-        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 {
+          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
+`);
+        }
+        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.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(`   ${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(`   ${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) {
@@ -2391,8 +3141,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, or tempo_moderato).").option("--config-dir <dir>", "Config directory with wallet.json", DEFAULT_CONFIG_DIR).option("--json", "Output raw JSON only").action(async (server, service, paramsJson, options) => {
+  const client = new MoltsPayClient({ configDir: options.configDir });
   if (!client.isInitialized) {
     console.error("\u274C Wallet not initialized. Run: npx moltspay init");
     process.exit(1);
@@ -2421,13 +3171,9 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
       params.image_base64 = imageData.toString("base64");
     }
   }
-  if (!params.prompt) {
-    console.error("\u274C Missing prompt. Use --prompt or pass JSON params");
-    process.exit(1);
-  }
   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 && !["base", "polygon", "base_sepolia", "tempo_moderato"].includes(chain)) {
+    console.error(`\u274C Unknown chain: ${chain}. Supported: base, polygon, base_sepolia, tempo_moderato`);
     process.exit(1);
   }
   const imageDisplay = params.image_url || (params.image_base64 ? `[local file: ${options.image}]` : null);
@@ -2458,10 +3204,22 @@ program.command("pay <server> <service> [params]").description("Pay for a servic
     console.log("");
   }
   try {
-    const result = await client.pay(server, service, params, {
-      token,
-      chain
-    });
+    let result;
+    if (chain === "tempo_moderato") {
+      if (!options.json) {
+        console.log("   Protocol: MPP (Machine Payments Protocol)");
+        console.log("");
+      }
+      const mppUrl = server.includes(service) ? server : `${server}/${service}`;
+      result = await client.payWithMPP(mppUrl, {
+        body: params
+      });
+    } else {
+      result = await client.pay(server, service, params, {
+        token,
+        chain
+      });
+    }
     if (options.json) {
       console.log(JSON.stringify(result));
     } else {