moltspay 1.2.0 → 1.3.0

package/dist/client/index.d.mts

@@ -1,4 +1,4 @@
-import { T as TokenSymbol } from '../index-B3v8IWjM.mjs';
+import { T as TokenSymbol } from '../index-On9ZaGDW.mjs';
 
 /**
  * MoltsPay Client Types
@@ -78,8 +78,8 @@ interface PayOptions {
     token?: TokenSymbol;
     /** Auto-select token based on balance (default: false) */
     autoSelect?: boolean;
-    /** Chain to pay on (base or polygon, default: base) */
-    chain?: 'base' | 'polygon';
+    /** Chain to pay on (base, polygon, or base_sepolia, default: base) */
+    chain?: 'base' | 'polygon' | 'base_sepolia';
 }
 declare class MoltsPayClient {
     private configDir;
@@ -166,13 +166,36 @@ declare class MoltsPayClient {
         native: number;
     }>;
     /**
-     * Get wallet balances on all supported chains (Base + Polygon)
+     * Get wallet balances on all supported chains (Base + Polygon + Tempo)
      */
     getAllBalances(): Promise<Record<string, {
         usdc: number;
         usdt: number;
         native: number;
+        tempo?: {
+            pathUSD: number;
+            alphaUSD: number;
+            betaUSD: number;
+            thetaUSD: number;
+        };
     }>>;
+    /**
+     * 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
+     */
+    payWithMPP(url: string, options?: {
+        body?: any;
+        headers?: Record<string, string>;
+    }): Promise<any>;
 }
 
 export { type ClientConfig, MoltsPayClient, type MoltsPayClientOptions, type PayOptions, type PaymentRequired, type ProviderInfo, type ServiceInfo, type ServicesResponse, type VerifyResponse, type WalletData };

package/dist/client/index.d.ts

@@ -1,4 +1,4 @@
-import { T as TokenSymbol } from '../index-B3v8IWjM.js';
+import { T as TokenSymbol } from '../index-On9ZaGDW.js';
 
 /**
  * MoltsPay Client Types
@@ -78,8 +78,8 @@ interface PayOptions {
     token?: TokenSymbol;
     /** Auto-select token based on balance (default: false) */
     autoSelect?: boolean;
-    /** Chain to pay on (base or polygon, default: base) */
-    chain?: 'base' | 'polygon';
+    /** Chain to pay on (base, polygon, or base_sepolia, default: base) */
+    chain?: 'base' | 'polygon' | 'base_sepolia';
 }
 declare class MoltsPayClient {
     private configDir;
@@ -166,13 +166,36 @@ declare class MoltsPayClient {
         native: number;
     }>;
     /**
-     * Get wallet balances on all supported chains (Base + Polygon)
+     * Get wallet balances on all supported chains (Base + Polygon + Tempo)
      */
     getAllBalances(): Promise<Record<string, {
         usdc: number;
         usdt: number;
         native: number;
+        tempo?: {
+            pathUSD: number;
+            alphaUSD: number;
+            betaUSD: number;
+            thetaUSD: number;
+        };
     }>>;
+    /**
+     * 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
+     */
+    payWithMPP(url: string, options?: {
+        body?: any;
+        headers?: Record<string, string>;
+    }): Promise<any>;
 }
 
 export { type ClientConfig, MoltsPayClient, type MoltsPayClientOptions, type PayOptions, type PaymentRequired, type ProviderInfo, type ServiceInfo, type ServicesResponse, type VerifyResponse, type WalletData };

package/dist/client/index.js

@@ -1,7 +1,9 @@
 "use strict";
+var __create = Object.create;
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
 var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
 var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __export = (target, all) => {
   for (var name in all)
@@ -15,6 +17,14 @@ var __copyProps = (to, from, except, desc) => {
   }
   return to;
 };
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
 var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 
 // src/client/index.ts
@@ -39,12 +49,15 @@ var CHAINS = {
       USDC: {
         address: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
         decimals: 6,
-        symbol: "USDC"
+        symbol: "USDC",
+        eip712Name: "USD Coin"
+        // EIP-712 domain name
       },
       USDT: {
         address: "0xfde4C96c8593536E31F229EA8f37b2ADa2699bb2",
         decimals: 6,
-        symbol: "USDT"
+        symbol: "USDT",
+        eip712Name: "Tether USD"
       }
     },
     usdc: "0x833589fCD6eDb6E08f4c7C32D4f71b54bdA02913",
@@ -61,12 +74,15 @@ var CHAINS = {
       USDC: {
         address: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
         decimals: 6,
-        symbol: "USDC"
+        symbol: "USDC",
+        eip712Name: "USD Coin"
       },
       USDT: {
         address: "0xc2132D05D31c914a87C6611C10748AEb04B58e8F",
         decimals: 6,
-        symbol: "USDT"
+        symbol: "USDT",
+        eip712Name: "(PoS) Tether USD"
+        // Polygon uses this name
       }
     },
     usdc: "0x3c499c542cEF5E3811e1192ce70d8cC03d5c3359",
@@ -74,27 +90,6 @@ var CHAINS = {
     explorerTx: "https://polygonscan.com/tx/",
     avgBlockTime: 2
   },
-  ethereum: {
-    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/",
-    avgBlockTime: 12
-  },
   // ============ Testnet ============
   base_sepolia: {
     name: "Base Sepolia",
@@ -104,13 +99,17 @@ var CHAINS = {
       USDC: {
         address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
         decimals: 6,
-        symbol: "USDC"
+        symbol: "USDC",
+        eip712Name: "USDC"
+        // Testnet USDC uses 'USDC' not 'USD Coin'
       },
       USDT: {
         address: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
         // Same as USDC on testnet (no official USDT)
         decimals: 6,
-        symbol: "USDT"
+        symbol: "USDT",
+        eip712Name: "USDC"
+        // Uses same contract as USDC
       }
     },
     usdc: "0x036CbD53842c5426634e7929541eC2318f3dCF7e",
@@ -118,27 +117,34 @@ var CHAINS = {
     explorerTx: "https://sepolia.basescan.org/tx/",
     avgBlockTime: 2
   },
-  sepolia: {
-    name: "Sepolia",
-    chainId: 11155111,
-    rpc: "https://rpc.sepolia.org",
+  // ============ 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: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
+        address: "0x20c0000000000000000000000000000000000000",
+        // pathUSD - primary testnet stablecoin
         decimals: 6,
-        symbol: "USDC"
+        symbol: "USDC",
+        eip712Name: "pathUSD"
       },
       USDT: {
-        address: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
-        // Same as USDC on testnet
+        address: "0x20c0000000000000000000000000000000000001",
+        // alphaUSD
         decimals: 6,
-        symbol: "USDT"
+        symbol: "USDT",
+        eip712Name: "alphaUSD"
       }
     },
-    usdc: "0x1c7D4B196Cb0C7B01d743Fbc6116a902379C7238",
-    explorer: "https://sepolia.etherscan.io/address/",
-    explorerTx: "https://sepolia.etherscan.io/tx/",
-    avgBlockTime: 12
+    usdc: "0x20c0000000000000000000000000000000000000",
+    explorer: "https://explore.testnet.tempo.xyz/address/",
+    explorerTx: "https://explore.testnet.tempo.xyz/tx/",
+    avgBlockTime: 0.5
+    // ~500ms finality
   }
 };
 function getChain(name) {
@@ -301,7 +307,7 @@ Server accepts: ${serverChains.join(", ")}`
       } else {
         throw new Error(
           `Server accepts: ${serverChains.join(", ")}
-Please specify: --chain base  or  --chain polygon`
+Please specify: --chain base, --chain polygon, or --chain base_sepolia`
         );
       }
     }
@@ -343,13 +349,19 @@ Please specify: --chain base  or  --chain polygon`
     if (!payTo) {
       throw new Error("Missing payTo address in payment requirements");
     }
-    const authorization = await this.signEIP3009(payTo, amount, chain, token);
+    const domainOverride = req.extra && typeof req.extra === "object" && req.extra.name ? { name: req.extra.name, version: req.extra.version || "2" } : void 0;
+    const authorization = await this.signEIP3009(payTo, amount, chain, token, domainOverride);
     const tokenConfig = chain.tokens[token];
-    const tokenName = token === "USDC" ? "USD Coin" : "Tether USD";
+    const extra = req.extra && typeof req.extra === "object" ? req.extra : {
+      name: tokenConfig.eip712Name || "USD Coin",
+      version: "2"
+    };
     const payload = {
       x402Version: X402_VERSION,
+      scheme: "exact",
+      network,
       payload: authorization,
-      // v2 requires 'accepted' field with the requirements being fulfilled
+      // { authorization: {...}, signature: "0x..." }
       accepted: {
         scheme: "exact",
         network,
@@ -357,7 +369,7 @@ Please specify: --chain base  or  --chain polygon`
         amount: amountRaw,
         payTo,
         maxTimeoutSeconds: req.maxTimeoutSeconds || 300,
-        extra: req.extra || { name: tokenName, version: "2" }
+        extra
       }
     };
     const paymentHeader = Buffer.from(JSON.stringify(payload)).toString("base64");
@@ -387,7 +399,7 @@ Please specify: --chain base  or  --chain polygon`
    * This only signs - no on-chain transaction, no gas needed.
    * Supports both USDC and USDT.
    */
-  async signEIP3009(to, amount, chain, token = "USDC") {
+  async signEIP3009(to, amount, chain, token = "USDC", domainOverride) {
     const validAfter = 0;
     const validBefore = Math.floor(Date.now() / 1e3) + 3600;
     const nonce = import_ethers.ethers.hexlify(import_ethers.ethers.randomBytes(32));
@@ -401,10 +413,11 @@ Please specify: --chain base  or  --chain polygon`
       validBefore: validBefore.toString(),
       nonce
     };
-    const tokenName = token === "USDC" ? "USD Coin" : "Tether USD";
+    const tokenName = domainOverride?.name || tokenConfig.eip712Name || (token === "USDC" ? "USD Coin" : "Tether USD");
+    const tokenVersion = domainOverride?.version || "2";
     const domain = {
       name: tokenName,
-      version: "2",
+      version: tokenVersion,
       chainId: chain.chainId,
       verifyingContract: tokenConfig.address
     };
@@ -567,30 +580,59 @@ Please specify: --chain base  or  --chain polygon`
     };
   }
   /**
-   * 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"];
+    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 import_ethers.ethers.JsonRpcProvider(chain.rpc);
-          const [nativeBalance, usdcBalance, usdtBalance] = await Promise.all([
-            provider.getBalance(this.wallet.address),
-            new import_ethers.ethers.Contract(chain.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
-            new import_ethers.ethers.Contract(chain.tokens.USDT.address, tokenAbi, provider).balanceOf(this.wallet.address)
-          ]);
-          results[chainName] = {
-            usdc: parseFloat(import_ethers.ethers.formatUnits(usdcBalance, chain.tokens.USDC.decimals)),
-            usdt: parseFloat(import_ethers.ethers.formatUnits(usdtBalance, chain.tokens.USDT.decimals)),
-            native: parseFloat(import_ethers.ethers.formatEther(nativeBalance))
-          };
+          if (chainName === "tempo_moderato") {
+            const [nativeBalance, pathUSD, alphaUSD, betaUSD, thetaUSD] = await Promise.all([
+              provider.getBalance(this.wallet.address),
+              new import_ethers.ethers.Contract(tempoTokens.pathUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new import_ethers.ethers.Contract(tempoTokens.alphaUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new import_ethers.ethers.Contract(tempoTokens.betaUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new import_ethers.ethers.Contract(tempoTokens.thetaUSD, tokenAbi, provider).balanceOf(this.wallet.address)
+            ]);
+            results[chainName] = {
+              usdc: parseFloat(import_ethers.ethers.formatUnits(pathUSD, 6)),
+              // pathUSD as default USDC
+              usdt: parseFloat(import_ethers.ethers.formatUnits(alphaUSD, 6)),
+              // alphaUSD as default USDT
+              native: parseFloat(import_ethers.ethers.formatEther(nativeBalance)),
+              tempo: {
+                pathUSD: parseFloat(import_ethers.ethers.formatUnits(pathUSD, 6)),
+                alphaUSD: parseFloat(import_ethers.ethers.formatUnits(alphaUSD, 6)),
+                betaUSD: parseFloat(import_ethers.ethers.formatUnits(betaUSD, 6)),
+                thetaUSD: parseFloat(import_ethers.ethers.formatUnits(thetaUSD, 6))
+              }
+            };
+          } else {
+            const [nativeBalance, usdcBalance, usdtBalance] = await Promise.all([
+              provider.getBalance(this.wallet.address),
+              new import_ethers.ethers.Contract(chain.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
+              new import_ethers.ethers.Contract(chain.tokens.USDT.address, tokenAbi, provider).balanceOf(this.wallet.address)
+            ]);
+            results[chainName] = {
+              usdc: parseFloat(import_ethers.ethers.formatUnits(usdcBalance, chain.tokens.USDC.decimals)),
+              usdt: parseFloat(import_ethers.ethers.formatUnits(usdtBalance, chain.tokens.USDT.decimals)),
+              native: parseFloat(import_ethers.ethers.formatEther(nativeBalance))
+            };
+          }
         } catch (err) {
           results[chainName] = { usdc: 0, usdt: 0, native: 0 };
         }
@@ -598,6 +640,121 @@ Please specify: --chain base  or  --chain polygon`
     );
     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();
+  }
 };
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {