@t402/mcp 2.8.0 → 2.8.1

package/dist/cjs/server/index.d.ts

@@ -20,6 +20,11 @@ declare class T402McpServer {
      * Initialize the WDK instance from seed phrase
      */
     initWdk(): Promise<void>;
+    /**
+     * Clear sensitive data from memory.
+     * Should be called on server shutdown to minimize key exposure window.
+     */
+    cleanup(): void;
     /** TON MCP bridge configuration */
     private tonBridgeConfig;
     /**

package/dist/cjs/server/index.js

@@ -1180,10 +1180,10 @@ var import_zod7 = require("zod");
 var wdkGetWalletInputSchema = import_zod7.z.object({});
 async function executeWdkGetWallet(_input, wdk) {
   const signer = await wdk.getSigner("ethereum");
-  const chains9 = wdk.getConfiguredChains();
+  const chains10 = wdk.getConfiguredChains();
   return {
     evmAddress: signer.address,
-    chains: chains9.length > 0 ? chains9 : ["ethereum"]
+    chains: chains10.length > 0 ? chains10 : ["ethereum"]
   };
 }
 function executeWdkGetWalletDemo() {
@@ -1215,14 +1215,14 @@ function findTokenFormatted(tokens, symbol) {
 }
 async function executeWdkGetBalances(input, wdk) {
   const balances = await wdk.getAggregatedBalances();
-  const chains9 = balances.chains.filter((c) => !input.chains || input.chains.includes(c.chain)).map((c) => ({
+  const chains10 = balances.chains.filter((c) => !input.chains || input.chains.includes(c.chain)).map((c) => ({
     chain: c.chain,
     usdt0: findTokenFormatted(c.tokens, "USDT0"),
     usdc: findTokenFormatted(c.tokens, "USDC"),
     native: (0, import_viem6.formatUnits)(c.native, 18)
   }));
   return {
-    chains: chains9,
+    chains: chains10,
     totalUsdt0: (0, import_viem6.formatUnits)(balances.totalUsdt0, 6),
     totalUsdc: (0, import_viem6.formatUnits)(balances.totalUsdc, 6)
   };
@@ -1422,22 +1422,37 @@ async function executeAutoPay(input, wdk) {
       }
     };
   }
-  const chains9 = input.preferredChain ? [input.preferredChain] : ["ethereum", "arbitrum", "base"];
+  const chains10 = input.preferredChain ? [input.preferredChain] : ["ethereum", "arbitrum", "base"];
   const { T402Protocol } = await import("@t402/wdk-protocol");
-  const protocol = await T402Protocol.create(wdk, { chains: chains9 });
-  const { response, receipt } = await protocol.fetch(input.url);
-  if (receipt && input.maxAmount) {
-    const paidAmount = parseFloat(receipt.amount) / 1e6;
+  const protocol = await T402Protocol.create(wdk, { chains: chains10 });
+  if (input.maxAmount) {
     const maxAmount = parseFloat(input.maxAmount);
-    if (paidAmount > maxAmount) {
-      return {
-        success: false,
-        statusCode: 402,
-        body: "",
-        error: `Payment amount (${paidAmount}) exceeds max allowed (${maxAmount})`
-      };
+    const preflightResponse = await fetch(input.url);
+    if (preflightResponse.status === 402) {
+      const requirementsHeader = preflightResponse.headers.get("x-payment") || preflightResponse.headers.get("x-payment-requirements");
+      if (requirementsHeader) {
+        try {
+          const requirements = JSON.parse(requirementsHeader);
+          const reqArray = Array.isArray(requirements) ? requirements : [requirements];
+          for (const req of reqArray) {
+            if (req.amount) {
+              const reqAmount = parseFloat(req.amount) / 1e6;
+              if (reqAmount > maxAmount) {
+                return {
+                  success: false,
+                  statusCode: 402,
+                  body: "",
+                  error: `Required payment amount (${reqAmount}) exceeds max allowed (${maxAmount})`
+                };
+              }
+            }
+          }
+        } catch {
+        }
+      }
     }
   }
+  const { response, receipt } = await protocol.fetch(input.url);
   const contentType = response.headers.get("content-type") ?? void 0;
   let body = "";
   try {
@@ -2290,6 +2305,71 @@ function formatNetworkFeeComparison(result) {
   return lines.join("\n");
 }
 
+// src/tools/signMessage.ts
+var import_zod19 = require("zod");
+var signMessageInputSchema = import_zod19.z.object({
+  chain: import_zod19.z.enum([
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "ink",
+    "berachain",
+    "unichain"
+  ]).describe("Blockchain network context for signing"),
+  message: import_zod19.z.string().min(1).describe("Message to sign")
+});
+
+// src/tools/verifySignature.ts
+var import_zod20 = require("zod");
+var import_viem11 = require("viem");
+var verifySignatureInputSchema = import_zod20.z.object({
+  chain: import_zod20.z.enum([
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "ink",
+    "berachain",
+    "unichain"
+  ]).describe("Blockchain network context for verification"),
+  message: import_zod20.z.string().min(1).describe("The original message that was signed"),
+  signature: import_zod20.z.string().regex(/^0x[a-fA-F0-9]+$/).describe("The signature to verify (hex string)"),
+  address: import_zod20.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("The expected signer address")
+});
+
+// src/tools/getTransferHistory.ts
+var import_zod21 = require("zod");
+var import_viem12 = require("viem");
+var chains9 = __toESM(require("viem/chains"));
+var getTransferHistoryInputSchema = import_zod21.z.object({
+  network: import_zod21.z.enum([
+    "ethereum",
+    "base",
+    "arbitrum",
+    "optimism",
+    "polygon",
+    "avalanche",
+    "ink",
+    "berachain",
+    "unichain"
+  ]).describe("Blockchain network to query"),
+  address: import_zod21.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Wallet address to get transfer history for"),
+  token: import_zod21.z.enum(["USDC", "USDT", "USDT0"]).optional().describe("Filter by specific token. If not provided, queries all supported stablecoins."),
+  limit: import_zod21.z.number().int().min(1).max(100).optional().describe("Maximum number of transfers to return (default: 10, max: 100)")
+});
+
+// src/tools/getHistoricalPrice.ts
+var import_zod22 = require("zod");
+var getHistoricalPriceInputSchema = import_zod22.z.object({
+  token: import_zod22.z.string().min(1).describe('Token symbol (e.g., "ETH", "USDC", "USDT", "MATIC", "AVAX")'),
+  days: import_zod22.z.number().int().min(1).max(365).optional().describe("Number of days of history to retrieve (default: 7, max: 365)")
+});
+
 // src/tools/quoteStore.ts
 var import_crypto = require("crypto");
 var DEFAULT_TTL_MS = 5 * 60 * 1e3;
@@ -2336,17 +2416,17 @@ function deleteQuote(quoteId) {
 }
 
 // src/tools/wdkQuoteSwap.ts
-var import_zod19 = require("zod");
-var import_viem11 = require("viem");
-var wdkQuoteSwapInputSchema = import_zod19.z.object({
-  fromToken: import_zod19.z.string().describe('Token to swap from (e.g., "ETH", "USDC")'),
-  toToken: import_zod19.z.string().describe('Token to swap to (e.g., "USDT0", "USDC")'),
-  amount: import_zod19.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount to swap (e.g., '1.0')"),
-  chain: import_zod19.z.string().describe('Chain to execute swap on (e.g., "ethereum", "arbitrum")')
+var import_zod23 = require("zod");
+var import_viem13 = require("viem");
+var wdkQuoteSwapInputSchema = import_zod23.z.object({
+  fromToken: import_zod23.z.string().describe('Token to swap from (e.g., "ETH", "USDC")'),
+  toToken: import_zod23.z.string().describe('Token to swap to (e.g., "USDT0", "USDC")'),
+  amount: import_zod23.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount to swap (e.g., '1.0')"),
+  chain: import_zod23.z.string().describe('Chain to execute swap on (e.g., "ethereum", "arbitrum")')
 });
 async function executeWdkQuoteSwap(input, wdk) {
   const decimals = ["USDC", "USDT", "USDT0"].includes(input.fromToken.toUpperCase()) ? 6 : 18;
-  const amountBigInt = (0, import_viem11.parseUnits)(input.amount, decimals);
+  const amountBigInt = (0, import_viem13.parseUnits)(input.amount, decimals);
   const quote = await wdk.getSwapQuote(input.chain, input.fromToken, amountBigInt);
   const outputDecimals = ["USDC", "USDT", "USDT0"].includes(input.toToken.toUpperCase()) ? 6 : 18;
   const outputDivisor = 10 ** outputDecimals;
@@ -2420,11 +2500,11 @@ function formatSwapQuoteResult(result) {
 }
 
 // src/tools/wdkExecuteSwap.ts
-var import_zod20 = require("zod");
-var import_viem12 = require("viem");
-var wdkExecuteSwapInputSchema = import_zod20.z.object({
-  quoteId: import_zod20.z.string().uuid().describe("Quote ID from wdk/quoteSwap"),
-  confirmed: import_zod20.z.boolean().optional().describe("Set to true to confirm and execute this swap")
+var import_zod24 = require("zod");
+var import_viem14 = require("viem");
+var wdkExecuteSwapInputSchema = import_zod24.z.object({
+  quoteId: import_zod24.z.string().uuid().describe("Quote ID from wdk/quoteSwap"),
+  confirmed: import_zod24.z.boolean().optional().describe("Set to true to confirm and execute this swap")
 });
 async function executeWdkExecuteSwap(input, wdk) {
   const quote = getQuote(input.quoteId);
@@ -2443,7 +2523,7 @@ async function executeWdkExecuteSwap(input, wdk) {
     };
   }
   const decimals = ["USDC", "USDT", "USDT0"].includes(fromToken.toUpperCase()) ? 6 : 18;
-  const amountBigInt = (0, import_viem12.parseUnits)(fromAmount, decimals);
+  const amountBigInt = (0, import_viem14.parseUnits)(fromAmount, decimals);
   const result = await wdk.swapAndPay({
     chain,
     fromToken,
@@ -2497,12 +2577,12 @@ function formatExecuteSwapResult(result) {
 }
 
 // src/tools/quoteBridge.ts
-var import_zod21 = require("zod");
-var quoteBridgeInputSchema = import_zod21.z.object({
-  fromChain: import_zod21.z.enum(["ethereum", "arbitrum", "ink", "berachain", "unichain"]).describe("Source chain to bridge from"),
-  toChain: import_zod21.z.enum(["ethereum", "arbitrum", "ink", "berachain", "unichain"]).describe("Destination chain to bridge to"),
-  amount: import_zod21.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount of USDT0 to bridge (e.g., '100' for 100 USDT0)"),
-  recipient: import_zod21.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Recipient address on destination chain")
+var import_zod25 = require("zod");
+var quoteBridgeInputSchema = import_zod25.z.object({
+  fromChain: import_zod25.z.enum(["ethereum", "arbitrum", "ink", "berachain", "unichain"]).describe("Source chain to bridge from"),
+  toChain: import_zod25.z.enum(["ethereum", "arbitrum", "ink", "berachain", "unichain"]).describe("Destination chain to bridge to"),
+  amount: import_zod25.z.string().regex(/^\d+(\.\d+)?$/).describe("Amount of USDT0 to bridge (e.g., '100' for 100 USDT0)"),
+  recipient: import_zod25.z.string().regex(/^0x[a-fA-F0-9]{40}$/).describe("Recipient address on destination chain")
 });
 async function executeQuoteBridge(input, rpcUrls) {
   const feeResult = await executeGetBridgeFee(input, rpcUrls);
@@ -2570,10 +2650,10 @@ function formatBridgeQuoteResult(result) {
 }
 
 // src/tools/executeBridgeFromQuote.ts
-var import_zod22 = require("zod");
-var executeBridgeFromQuoteInputSchema = import_zod22.z.object({
-  quoteId: import_zod22.z.string().uuid().describe("Quote ID from t402/quoteBridge"),
-  confirmed: import_zod22.z.boolean().optional().describe("Set to true to confirm and execute this bridge")
+var import_zod26 = require("zod");
+var executeBridgeFromQuoteInputSchema = import_zod26.z.object({
+  quoteId: import_zod26.z.string().uuid().describe("Quote ID from t402/quoteBridge"),
+  confirmed: import_zod26.z.boolean().optional().describe("Set to true to confirm and execute this bridge")
 });
 async function executeExecuteBridgeFromQuote(input, options) {
   const quote = getQuote(input.quoteId);
@@ -2632,22 +2712,22 @@ function executeExecuteBridgeFromQuoteDemo(input) {
 }
 
 // src/tools/unified.ts
-var import_zod23 = require("zod");
-var smartPayInputSchema = import_zod23.z.object({
-  url: import_zod23.z.string().url().describe("URL of the 402-protected resource"),
-  maxBridgeFee: import_zod23.z.string().regex(/^\d+(\.\d+)?$/).optional().describe("Maximum acceptable bridge fee in native token (optional)"),
-  preferredNetwork: import_zod23.z.string().optional().describe("Preferred network for payment (optional)"),
-  confirmed: import_zod23.z.boolean().optional().describe("Set to true to confirm and execute this payment")
+var import_zod27 = require("zod");
+var smartPayInputSchema = import_zod27.z.object({
+  url: import_zod27.z.string().url().describe("URL of the 402-protected resource"),
+  maxBridgeFee: import_zod27.z.string().regex(/^\d+(\.\d+)?$/).optional().describe("Maximum acceptable bridge fee in native token (optional)"),
+  preferredNetwork: import_zod27.z.string().optional().describe("Preferred network for payment (optional)"),
+  confirmed: import_zod27.z.boolean().optional().describe("Set to true to confirm and execute this payment")
 });
-var paymentPlanInputSchema = import_zod23.z.object({
-  paymentRequired: import_zod23.z.object({
-    scheme: import_zod23.z.string().optional(),
-    network: import_zod23.z.string().optional(),
-    maxAmountRequired: import_zod23.z.string().optional(),
-    resource: import_zod23.z.string().optional(),
-    description: import_zod23.z.string().optional(),
-    payTo: import_zod23.z.string().optional(),
-    maxDeadline: import_zod23.z.number().optional()
+var paymentPlanInputSchema = import_zod27.z.object({
+  paymentRequired: import_zod27.z.object({
+    scheme: import_zod27.z.string().optional(),
+    network: import_zod27.z.string().optional(),
+    maxAmountRequired: import_zod27.z.string().optional(),
+    resource: import_zod27.z.string().optional(),
+    description: import_zod27.z.string().optional(),
+    payTo: import_zod27.z.string().optional(),
+    maxDeadline: import_zod27.z.number().optional()
   }).passthrough().describe("The 402 PaymentRequired response")
 });
 var UNIFIED_TOOL_DEFINITIONS = {
@@ -2702,14 +2782,14 @@ async function executeSmartPay(input, wdk) {
     };
   }
   const steps = [];
-  const chains9 = input.preferredNetwork ? [input.preferredNetwork] : ["ethereum", "arbitrum", "base"];
+  const chains10 = input.preferredNetwork ? [input.preferredNetwork] : ["ethereum", "arbitrum", "base"];
   steps.push({
     action: "check_balance",
     status: "success",
-    detail: `Checking balances on ${chains9.join(", ")}`
+    detail: `Checking balances on ${chains10.join(", ")}`
   });
   const { T402Protocol } = await import("@t402/wdk-protocol");
-  const protocol = await T402Protocol.create(wdk, { chains: chains9 });
+  const protocol = await T402Protocol.create(wdk, { chains: chains10 });
   steps.push({
     action: "fetch",
     status: "success",
@@ -3270,6 +3350,131 @@ var TOOL_DEFINITIONS = {
       },
       required: ["quoteId"]
     }
+  },
+  "t402/signMessage": {
+    name: "t402/signMessage",
+    description: "Sign a message using the configured wallet. Returns an EIP-191 personal signature. Requires a configured private key.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        chain: {
+          type: "string",
+          enum: [
+            "ethereum",
+            "base",
+            "arbitrum",
+            "optimism",
+            "polygon",
+            "avalanche",
+            "ink",
+            "berachain",
+            "unichain"
+          ],
+          description: "Blockchain network context for signing"
+        },
+        message: {
+          type: "string",
+          description: "Message to sign"
+        }
+      },
+      required: ["chain", "message"]
+    }
+  },
+  "t402/verifySignature": {
+    name: "t402/verifySignature",
+    description: "Verify an EIP-191 signed message. Checks whether a signature was produced by the claimed address. No wallet configuration needed \u2014 this is a read-only verification.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        chain: {
+          type: "string",
+          enum: [
+            "ethereum",
+            "base",
+            "arbitrum",
+            "optimism",
+            "polygon",
+            "avalanche",
+            "ink",
+            "berachain",
+            "unichain"
+          ],
+          description: "Blockchain network context for verification"
+        },
+        message: {
+          type: "string",
+          description: "The original message that was signed"
+        },
+        signature: {
+          type: "string",
+          pattern: "^0x[a-fA-F0-9]+$",
+          description: "The signature to verify (hex string)"
+        },
+        address: {
+          type: "string",
+          pattern: "^0x[a-fA-F0-9]{40}$",
+          description: "The expected signer address"
+        }
+      },
+      required: ["chain", "message", "signature", "address"]
+    }
+  },
+  "t402/getTransferHistory": {
+    name: "t402/getTransferHistory",
+    description: "Get recent ERC-20 stablecoin transfer history for a wallet address. Queries on-chain Transfer events for USDC, USDT, and USDT0. Returns sent and received transfers sorted by most recent.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        network: {
+          type: "string",
+          enum: [
+            "ethereum",
+            "base",
+            "arbitrum",
+            "optimism",
+            "polygon",
+            "avalanche",
+            "ink",
+            "berachain",
+            "unichain"
+          ],
+          description: "Blockchain network to query"
+        },
+        address: {
+          type: "string",
+          pattern: "^0x[a-fA-F0-9]{40}$",
+          description: "Wallet address to get transfer history for"
+        },
+        token: {
+          type: "string",
+          enum: ["USDC", "USDT", "USDT0"],
+          description: "Filter by specific token. If not provided, queries all supported stablecoins."
+        },
+        limit: {
+          type: "number",
+          description: "Maximum number of transfers to return (default: 10, max: 100)"
+        }
+      },
+      required: ["network", "address"]
+    }
+  },
+  "t402/getHistoricalPrice": {
+    name: "t402/getHistoricalPrice",
+    description: "Get historical price data for a token over a specified period via CoinGecko. Returns price data points, high/low, and percentage change. Useful for trend analysis.",
+    inputSchema: {
+      type: "object",
+      properties: {
+        token: {
+          type: "string",
+          description: 'Token symbol (e.g., "ETH", "USDC", "USDT", "MATIC", "AVAX", "BTC", "SOL")'
+        },
+        days: {
+          type: "number",
+          description: "Number of days of history to retrieve (default: 7, max: 365)"
+        }
+      },
+      required: ["token"]
+    }
   }
 };
 var WDK_TOOL_DEFINITIONS = {
@@ -3549,6 +3754,19 @@ var T402McpServer = class {
       console.error("Warning: Failed to initialize WDK. WDK tools will not be available.");
     }
   }
+  /**
+   * Clear sensitive data from memory.
+   * Should be called on server shutdown to minimize key exposure window.
+   */
+  cleanup() {
+    if (this.config.privateKey) {
+      this.config.privateKey = "";
+    }
+    if (this.config.seedPhrase) {
+      this.config.seedPhrase = "";
+    }
+    this.wdk = null;
+  }
   /**
    * Register TON bridge tools
    *
@@ -4058,6 +4276,16 @@ var T402McpServer = class {
    */
   async run() {
     await this.initWdk();
+    const onExit = () => this.cleanup();
+    process.on("exit", onExit);
+    process.on("SIGINT", () => {
+      onExit();
+      process.exit(0);
+    });
+    process.on("SIGTERM", () => {
+      onExit();
+      process.exit(0);
+    });
     const transport = new import_stdio.StdioServerTransport();
     await this.server.connect(transport);
     console.error("t402 MCP Server running on stdio");