moltspay 1.5.0 → 1.6.0

package/dist/mcp/index.js

@@ -33,11 +33,11 @@ var import_path3 = require("path");
 var import_mcp = require("@modelcontextprotocol/sdk/server/mcp.js");
 var import_zod = require("zod");
 
-// src/client/index.ts
+// src/client/node/index.ts
 var import_fs2 = require("fs");
 var import_os2 = require("os");
 var import_path2 = require("path");
-var import_ethers = require("ethers");
+var import_ethers2 = require("ethers");
 
 // src/chains/index.ts
 var CHAINS = {
@@ -278,16 +278,16 @@ function loadSolanaWallet(configDir = DEFAULT_CONFIG_DIR) {
 // src/facilitators/solana.ts
 var import_web33 = require("@solana/web3.js");
 var import_spl_token2 = require("@solana/spl-token");
-async function createSolanaPaymentTransaction(senderPubkey, recipientPubkey, amount, chain, feePayerPubkey) {
+async function createSolanaPaymentTransaction(senderPubkey, recipientPubkey, amount, chain, feePayerPubkey, connection) {
   const chainConfig = SOLANA_CHAINS[chain];
-  const connection = new import_web33.Connection(chainConfig.rpc, "confirmed");
+  const conn = connection ?? new import_web33.Connection(chainConfig.rpc, "confirmed");
   const mint = new import_web33.PublicKey(chainConfig.tokens.USDC.mint);
   const actualFeePayer = feePayerPubkey || senderPubkey;
   const senderATA = await (0, import_spl_token2.getAssociatedTokenAddress)(mint, senderPubkey);
   const recipientATA = await (0, import_spl_token2.getAssociatedTokenAddress)(mint, recipientPubkey);
   const transaction = new import_web33.Transaction();
   try {
-    await (0, import_spl_token2.getAccount)(connection, recipientATA);
+    await (0, import_spl_token2.getAccount)(conn, recipientATA);
   } catch {
     transaction.add(
       (0, import_spl_token2.createAssociatedTokenAccountInstruction)(
@@ -318,17 +318,178 @@ async function createSolanaPaymentTransaction(senderPubkey, recipientPubkey, amo
       // decimals
     )
   );
-  const { blockhash, lastValidBlockHeight } = await connection.getLatestBlockhash();
+  const { blockhash, lastValidBlockHeight } = await conn.getLatestBlockhash();
   transaction.recentBlockhash = blockhash;
   transaction.feePayer = actualFeePayer;
   return transaction;
 }
 
-// src/client/index.ts
-var import_web34 = require("@solana/web3.js");
+// src/client/node/index.ts
+var import_web35 = require("@solana/web3.js");
+
+// src/client/core/types.ts
 var X402_VERSION = 2;
 var PAYMENT_REQUIRED_HEADER = "x-payment-required";
 var PAYMENT_HEADER = "x-payment";
+
+// src/client/core/chain-map.ts
+var NETWORK_TO_CHAIN = {
+  "eip155:8453": "base",
+  "eip155:137": "polygon",
+  "eip155:84532": "base_sepolia",
+  "eip155:42431": "tempo_moderato",
+  "eip155:56": "bnb",
+  "eip155:97": "bnb_testnet",
+  "solana:mainnet": "solana",
+  "solana:devnet": "solana_devnet"
+};
+var CHAIN_TO_NETWORK = Object.fromEntries(
+  Object.entries(NETWORK_TO_CHAIN).map(([network, chain]) => [chain, network])
+);
+function networkToChainName(network) {
+  return NETWORK_TO_CHAIN[network] ?? null;
+}
+
+// src/client/core/base64.ts
+var BufferCtor = globalThis.Buffer;
+
+// src/client/core/eip3009.ts
+var EIP3009_TYPES = {
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
+function buildEIP3009TypedData(args) {
+  const validAfter = args.validAfter ?? "0";
+  const validBefore = args.validBefore ?? (Math.floor(Date.now() / 1e3) + 3600).toString();
+  const authorization = {
+    from: args.from,
+    to: args.to,
+    value: args.value,
+    validAfter,
+    validBefore,
+    nonce: args.nonce
+  };
+  return {
+    domain: {
+      name: args.tokenName,
+      version: args.tokenVersion,
+      chainId: args.chainId,
+      verifyingContract: args.tokenAddress
+    },
+    types: EIP3009_TYPES,
+    primaryType: "TransferWithAuthorization",
+    message: authorization
+  };
+}
+
+// src/client/core/bnb-intent.ts
+var BNB_INTENT_TYPES = {
+  PaymentIntent: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "amount", type: "uint256" },
+    { name: "token", type: "address" },
+    { name: "service", type: "string" },
+    { name: "nonce", type: "uint256" },
+    { name: "deadline", type: "uint256" }
+  ]
+};
+var BNB_DOMAIN_NAME = "MoltsPay";
+var BNB_DOMAIN_VERSION = "1";
+function buildBnbIntentTypedData(args) {
+  const intent = {
+    from: args.from,
+    to: args.to,
+    amount: args.amount,
+    token: args.tokenAddress,
+    service: args.service,
+    nonce: args.nonce,
+    deadline: args.deadline
+  };
+  return {
+    domain: {
+      name: BNB_DOMAIN_NAME,
+      version: BNB_DOMAIN_VERSION,
+      chainId: args.chainId
+    },
+    types: BNB_INTENT_TYPES,
+    primaryType: "PaymentIntent",
+    message: intent
+  };
+}
+
+// src/client/node/signer.ts
+var import_ethers = require("ethers");
+var import_web34 = require("@solana/web3.js");
+var NodeSigner = class {
+  evmWallet;
+  getSolanaKeypair;
+  constructor(evmWallet, options = {}) {
+    this.evmWallet = evmWallet;
+    this.getSolanaKeypair = options.getSolanaKeypair ?? (() => null);
+  }
+  async getEvmAddress() {
+    return this.evmWallet.address;
+  }
+  async getSolanaAddress() {
+    const kp = this.getSolanaKeypair();
+    return kp ? kp.publicKey.toBase58() : null;
+  }
+  async signTypedData(envelope) {
+    const mutableTypes = {};
+    for (const [key, fields] of Object.entries(envelope.types)) {
+      mutableTypes[key] = [...fields];
+    }
+    return this.evmWallet.signTypedData(
+      envelope.domain,
+      mutableTypes,
+      envelope.message
+    );
+  }
+  async sendEvmTransaction(args) {
+    const chain = findChainByChainId(args.chainId);
+    if (!chain) {
+      throw new Error(`sendEvmTransaction: unknown chainId ${args.chainId}`);
+    }
+    const provider = new import_ethers.ethers.JsonRpcProvider(chain.rpc);
+    const connected = this.evmWallet.connect(provider);
+    const tx = await connected.sendTransaction({
+      to: args.to,
+      data: args.data,
+      value: args.value ? BigInt(args.value) : 0n
+    });
+    return tx.hash;
+  }
+  async signSolanaTransaction(args) {
+    const kp = this.getSolanaKeypair();
+    if (!kp) {
+      throw new Error("signSolanaTransaction: no Solana wallet configured");
+    }
+    const tx = import_web34.Transaction.from(Buffer.from(args.transactionBase64, "base64"));
+    if (args.partialSign) {
+      tx.partialSign(kp);
+    } else {
+      tx.sign(kp);
+    }
+    return tx.serialize({ requireAllSignatures: false }).toString("base64");
+  }
+};
+function findChainByChainId(chainId) {
+  for (const cfg of Object.values(CHAINS)) {
+    if (cfg.chainId === chainId) {
+      return cfg;
+    }
+  }
+  return void 0;
+}
+
+// src/client/node/index.ts
 var DEFAULT_CONFIG = {
   chain: "base",
   limits: {
@@ -341,6 +502,7 @@ var MoltsPayClient = class {
   config;
   walletData = null;
   wallet = null;
+  signer = null;
   todaySpending = 0;
   lastSpendingReset = 0;
   constructor(options = {}) {
@@ -349,7 +511,11 @@ var MoltsPayClient = class {
     this.walletData = this.loadWallet();
     this.loadSpending();
     if (this.walletData) {
-      this.wallet = new import_ethers.Wallet(this.walletData.privateKey);
+      this.wallet = new import_ethers2.Wallet(this.walletData.privateKey);
+      const configDir = this.configDir;
+      this.signer = new NodeSigner(this.wallet, {
+        getSolanaKeypair: () => loadSolanaWallet(configDir)
+      });
     }
   }
   /**
@@ -477,20 +643,6 @@ var MoltsPayClient = class {
     } catch {
       throw new Error("Invalid x-payment-required header");
     }
-    const networkToChainName = (network2) => {
-      if (network2 === "solana:mainnet") return "solana";
-      if (network2 === "solana:devnet") return "solana_devnet";
-      const match = network2.match(/^eip155:(\d+)$/);
-      if (!match) return null;
-      const chainId = parseInt(match[1]);
-      if (chainId === 8453) return "base";
-      if (chainId === 137) return "polygon";
-      if (chainId === 84532) return "base_sepolia";
-      if (chainId === 42431) return "tempo_moderato";
-      if (chainId === 56) return "bnb";
-      if (chainId === 97) return "bnb_testnet";
-      return null;
-    };
     const serverChains = requirements.map((r) => networkToChainName(r.network)).filter((c) => c !== null);
     const userSpecifiedChain = options.chain;
     let selectedChain;
@@ -719,14 +871,14 @@ Please specify: --chain <chain_name>`
   async handleBNBPayment(executeUrl, service, params, paymentDetails, options = {}) {
     const { to, amount, token, chainName, chain, spender } = paymentDetails;
     const tokenConfig = chain.tokens[token];
-    const provider = new import_ethers.ethers.JsonRpcProvider(chain.rpc);
+    const provider = new import_ethers2.ethers.JsonRpcProvider(chain.rpc);
     const allowance = await this.checkAllowance(tokenConfig.address, spender, provider);
     const amountWeiCheck = BigInt(Math.floor(amount * 10 ** tokenConfig.decimals));
     if (allowance < amountWeiCheck) {
       const nativeBalance = await provider.getBalance(this.wallet.address);
-      const minGasBalance = import_ethers.ethers.parseEther("0.0005");
+      const minGasBalance = import_ethers2.ethers.parseEther("0.0005");
       if (nativeBalance < minGasBalance) {
-        const nativeBNB = parseFloat(import_ethers.ethers.formatEther(nativeBalance)).toFixed(4);
+        const nativeBNB = parseFloat(import_ethers2.ethers.formatEther(nativeBalance)).toFixed(4);
         const isTestnet = chainName === "bnb_testnet";
         if (isTestnet) {
           throw new Error(
@@ -760,35 +912,21 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
       );
     }
     const amountWei = BigInt(Math.floor(amount * 10 ** tokenConfig.decimals)).toString();
-    const intent = {
+    const intentNonce = Date.now();
+    const intentDeadline = Date.now() + 36e5;
+    const envelope = buildBnbIntentTypedData({
       from: this.wallet.address,
       to,
       amount: amountWei,
-      token: tokenConfig.address,
+      tokenAddress: tokenConfig.address,
       service,
-      nonce: Date.now(),
-      // Use timestamp as nonce for simplicity
-      deadline: Date.now() + 36e5
-      // 1 hour
-    };
-    const domain = {
-      name: "MoltsPay",
-      version: "1",
+      nonce: intentNonce,
+      deadline: intentDeadline,
       chainId: chain.chainId
-    };
-    const types = {
-      PaymentIntent: [
-        { name: "from", type: "address" },
-        { name: "to", type: "address" },
-        { name: "amount", type: "uint256" },
-        { name: "token", type: "address" },
-        { name: "service", type: "string" },
-        { name: "nonce", type: "uint256" },
-        { name: "deadline", type: "uint256" }
-      ]
-    };
+    });
     console.log(`[MoltsPay] Signing BNB payment intent...`);
-    const signature = await this.wallet.signTypedData(domain, types, intent);
+    const signature = await this.signer.signTypedData(envelope);
+    const intent = envelope.message;
     const network = `eip155:${chain.chainId}`;
     const payload = {
       x402Version: 2,
@@ -849,11 +987,11 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
       throw new Error("Missing payTo address in payment requirements");
     }
     const solanaFeePayer = requirements.extra?.solanaFeePayer;
-    const feePayerPubkey = solanaFeePayer ? new import_web34.PublicKey(solanaFeePayer) : void 0;
+    const feePayerPubkey = solanaFeePayer ? new import_web35.PublicKey(solanaFeePayer) : void 0;
     if (feePayerPubkey) {
       console.log(`[MoltsPay] Gasless mode: server pays fees`);
     }
-    const recipientPubkey = new import_web34.PublicKey(requirements.payTo);
+    const recipientPubkey = new import_web35.PublicKey(requirements.payTo);
     const transaction = await createSolanaPaymentTransaction(
       solanaWallet.publicKey,
       recipientPubkey,
@@ -862,12 +1000,11 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
       feePayerPubkey
       // Optional fee payer for gasless mode
     );
-    if (feePayerPubkey) {
-      transaction.partialSign(solanaWallet);
-    } else {
-      transaction.sign(solanaWallet);
-    }
-    const signedTx = transaction.serialize({ requireAllSignatures: false }).toString("base64");
+    const unsignedBase64 = transaction.serialize({ requireAllSignatures: false, verifySignatures: false }).toString("base64");
+    const signedTx = await this.signer.signSolanaTransaction({
+      transactionBase64: unsignedBase64,
+      partialSign: !!feePayerPubkey
+    });
     console.log(`[MoltsPay] Transaction signed, sending to server...`);
     const network = chain === "solana" ? "solana:mainnet" : "solana:devnet";
     const payload = {
@@ -914,7 +1051,7 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
    * Check ERC20 allowance for a spender
    */
   async checkAllowance(tokenAddress, spender, provider) {
-    const contract = new import_ethers.ethers.Contract(
+    const contract = new import_ethers2.ethers.Contract(
       tokenAddress,
       ["function allowance(address owner, address spender) view returns (uint256)"],
       provider
@@ -925,41 +1062,29 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
    * Sign EIP-3009 transferWithAuthorization (GASLESS)
    * This only signs - no on-chain transaction, no gas needed.
    * Supports both USDC and USDT.
+   *
+   * Delegates typed-data construction to `core/eip3009.ts` and the signature
+   * itself to `this.signer`. That way Web Client (Phase 4) can reuse the same
+   * flow with an EIP-1193 signer without duplicating typed-data layout.
    */
   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));
     const tokenConfig = chain.tokens[token];
     const value = BigInt(Math.floor(amount * 10 ** tokenConfig.decimals)).toString();
-    const authorization = {
+    const nonce = import_ethers2.ethers.hexlify(import_ethers2.ethers.randomBytes(32));
+    const tokenName = domainOverride?.name || tokenConfig.eip712Name || (token === "USDC" ? "USD Coin" : "Tether USD");
+    const tokenVersion = domainOverride?.version || "2";
+    const envelope = buildEIP3009TypedData({
       from: this.wallet.address,
       to,
       value,
-      validAfter: validAfter.toString(),
-      validBefore: validBefore.toString(),
-      nonce
-    };
-    const tokenName = domainOverride?.name || tokenConfig.eip712Name || (token === "USDC" ? "USD Coin" : "Tether USD");
-    const tokenVersion = domainOverride?.version || "2";
-    const domain = {
-      name: tokenName,
-      version: tokenVersion,
+      nonce,
       chainId: chain.chainId,
-      verifyingContract: tokenConfig.address
-    };
-    const types = {
-      TransferWithAuthorization: [
-        { name: "from", type: "address" },
-        { name: "to", type: "address" },
-        { name: "value", type: "uint256" },
-        { name: "validAfter", type: "uint256" },
-        { name: "validBefore", type: "uint256" },
-        { name: "nonce", type: "bytes32" }
-      ]
-    };
-    const signature = await this.wallet.signTypedData(domain, types, authorization);
-    return { authorization, signature };
+      tokenAddress: tokenConfig.address,
+      tokenName,
+      tokenVersion
+    });
+    const signature = await this.signer.signTypedData(envelope);
+    return { authorization: envelope.message, signature };
   }
   /**
    * Check spending limits
@@ -1063,7 +1188,7 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
    */
   static init(configDir, options) {
     (0, import_fs2.mkdirSync)(configDir, { recursive: true });
-    const wallet = import_ethers.Wallet.createRandom();
+    const wallet = import_ethers2.Wallet.createRandom();
     const walletData = {
       address: wallet.address,
       privateKey: wallet.privateKey,
@@ -1095,17 +1220,17 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
     } catch {
       throw new Error(`Unknown chain: ${this.config.chain}`);
     }
-    const provider = new import_ethers.ethers.JsonRpcProvider(chain.rpc);
+    const provider = new import_ethers2.ethers.JsonRpcProvider(chain.rpc);
     const tokenAbi = ["function balanceOf(address) view returns (uint256)"];
     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)
+      new import_ethers2.ethers.Contract(chain.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
+      new import_ethers2.ethers.Contract(chain.tokens.USDT.address, tokenAbi, provider).balanceOf(this.wallet.address)
     ]);
     return {
-      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))
+      usdc: parseFloat(import_ethers2.ethers.formatUnits(usdcBalance, chain.tokens.USDC.decimals)),
+      usdt: parseFloat(import_ethers2.ethers.formatUnits(usdtBalance, chain.tokens.USDT.decimals)),
+      native: parseFloat(import_ethers2.ethers.formatEther(nativeBalance))
     };
   }
   /**
@@ -1128,38 +1253,38 @@ Run: npx moltspay approve --chain ${chainName} --spender ${spender}`
       supportedChains.map(async (chainName) => {
         try {
           const chain = getChain(chainName);
-          const provider = new import_ethers.ethers.JsonRpcProvider(chain.rpc);
+          const provider = new import_ethers2.ethers.JsonRpcProvider(chain.rpc);
           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)
+              new import_ethers2.ethers.Contract(tempoTokens.pathUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new import_ethers2.ethers.Contract(tempoTokens.alphaUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new import_ethers2.ethers.Contract(tempoTokens.betaUSD, tokenAbi, provider).balanceOf(this.wallet.address),
+              new import_ethers2.ethers.Contract(tempoTokens.thetaUSD, tokenAbi, provider).balanceOf(this.wallet.address)
             ]);
             results[chainName] = {
-              usdc: parseFloat(import_ethers.ethers.formatUnits(pathUSD, 6)),
+              usdc: parseFloat(import_ethers2.ethers.formatUnits(pathUSD, 6)),
               // pathUSD as default USDC
-              usdt: parseFloat(import_ethers.ethers.formatUnits(alphaUSD, 6)),
+              usdt: parseFloat(import_ethers2.ethers.formatUnits(alphaUSD, 6)),
               // alphaUSD as default USDT
-              native: parseFloat(import_ethers.ethers.formatEther(nativeBalance)),
+              native: parseFloat(import_ethers2.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))
+                pathUSD: parseFloat(import_ethers2.ethers.formatUnits(pathUSD, 6)),
+                alphaUSD: parseFloat(import_ethers2.ethers.formatUnits(alphaUSD, 6)),
+                betaUSD: parseFloat(import_ethers2.ethers.formatUnits(betaUSD, 6)),
+                thetaUSD: parseFloat(import_ethers2.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)
+              new import_ethers2.ethers.Contract(chain.tokens.USDC.address, tokenAbi, provider).balanceOf(this.wallet.address),
+              new import_ethers2.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))
+              usdc: parseFloat(import_ethers2.ethers.formatUnits(usdcBalance, chain.tokens.USDC.decimals)),
+              usdt: parseFloat(import_ethers2.ethers.formatUnits(usdtBalance, chain.tokens.USDT.decimals)),
+              native: parseFloat(import_ethers2.ethers.formatEther(nativeBalance))
             };
           }
         } catch (err2) {