@t402/mcp 2.8.0 → 2.8.1

package/dist/cjs/tools/index.js

@@ -63,16 +63,20 @@ __export(tools_exports, {
   executeGetBalance: () => executeGetBalance,
   executeGetBridgeFee: () => executeGetBridgeFee,
   executeGetGasPrice: () => executeGetGasPrice,
+  executeGetHistoricalPrice: () => executeGetHistoricalPrice,
   executeGetTokenPrice: () => executeGetTokenPrice,
+  executeGetTransferHistory: () => executeGetTransferHistory,
   executePay: () => executePay,
   executePayGasless: () => executePayGasless,
   executePaymentPlan: () => executePaymentPlan,
   executePaymentPlanDemo: () => executePaymentPlanDemo,
   executeQuoteBridge: () => executeQuoteBridge,
   executeQuoteBridgeDemo: () => executeQuoteBridgeDemo,
+  executeSignMessage: () => executeSignMessage,
   executeSmartPay: () => executeSmartPay,
   executeSmartPayDemo: () => executeSmartPayDemo,
   executeTonBridgeTool: () => executeTonBridgeTool,
+  executeVerifySignature: () => executeVerifySignature,
   executeWdkExecuteSwap: () => executeWdkExecuteSwap,
   executeWdkExecuteSwapDemo: () => executeWdkExecuteSwapDemo,
   executeWdkGetBalances: () => executeWdkGetBalances,
@@ -98,13 +102,17 @@ __export(tools_exports, {
   formatExecuteSwapResult: () => formatExecuteSwapResult,
   formatGasPriceResult: () => formatGasPriceResult,
   formatGaslessPaymentResult: () => formatGaslessPaymentResult,
+  formatHistoricalPriceResult: () => formatHistoricalPriceResult,
   formatNetworkFeeComparison: () => formatNetworkFeeComparison,
   formatPaymentFeeEstimate: () => formatPaymentFeeEstimate,
   formatPaymentPlanResult: () => formatPaymentPlanResult,
   formatPaymentResult: () => formatPaymentResult,
+  formatSignMessageResult: () => formatSignMessageResult,
   formatSmartPayResult: () => formatSmartPayResult,
   formatSwapQuoteResult: () => formatSwapQuoteResult,
   formatTokenPriceResult: () => formatTokenPriceResult,
+  formatTransferHistoryResult: () => formatTransferHistoryResult,
+  formatVerifySignatureResult: () => formatVerifySignatureResult,
   formatWdkBalancesResult: () => formatWdkBalancesResult,
   formatWdkSwapResult: () => formatWdkSwapResult,
   formatWdkTransferResult: () => formatWdkTransferResult,
@@ -113,15 +121,19 @@ __export(tools_exports, {
   getBalanceInputSchema: () => getBalanceInputSchema,
   getBridgeFeeInputSchema: () => getBridgeFeeInputSchema,
   getGasPriceInputSchema: () => getGasPriceInputSchema,
+  getHistoricalPriceInputSchema: () => getHistoricalPriceInputSchema,
   getQuote: () => getQuote,
   getTokenPriceInputSchema: () => getTokenPriceInputSchema,
   getTokenPrices: () => getTokenPrices,
   getTokenPricesDemo: () => getTokenPricesDemo,
+  getTransferHistoryInputSchema: () => getTransferHistoryInputSchema,
   payGaslessInputSchema: () => payGaslessInputSchema,
   payInputSchema: () => payInputSchema,
   paymentPlanInputSchema: () => paymentPlanInputSchema,
   quoteBridgeInputSchema: () => quoteBridgeInputSchema,
+  signMessageInputSchema: () => signMessageInputSchema,
   smartPayInputSchema: () => smartPayInputSchema,
+  verifySignatureInputSchema: () => verifySignatureInputSchema,
   wdkExecuteSwapInputSchema: () => wdkExecuteSwapInputSchema,
   wdkGetBalancesInputSchema: () => wdkGetBalancesInputSchema,
   wdkGetWalletInputSchema: () => wdkGetWalletInputSchema,
@@ -1268,10 +1280,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() {
@@ -1303,14 +1315,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)
   };
@@ -1510,22 +1522,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 {
@@ -2389,6 +2416,390 @@ 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")
+});
+async function executeSignMessage(_input) {
+  throw new Error(
+    "Wallet not configured. To sign messages, configure a private key via the T402_PRIVATE_KEY environment variable."
+  );
+}
+function formatSignMessageResult(result) {
+  const lines = [
+    `## Message Signed on ${result.network}`,
+    "",
+    `- **Signer:** ${result.address}`,
+    `- **Message:** ${result.message.length > 100 ? result.message.slice(0, 100) + "..." : result.message}`,
+    `- **Signature:** \`${result.signature}\``
+  ];
+  return lines.join("\n");
+}
+
+// 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")
+});
+async function executeVerifySignature(input) {
+  const { chain, message, signature, address } = input;
+  try {
+    const valid = await (0, import_viem11.verifyMessage)({
+      address,
+      message,
+      signature
+    });
+    return {
+      valid,
+      address,
+      message,
+      network: chain
+    };
+  } catch (err) {
+    return {
+      valid: false,
+      address,
+      message,
+      network: chain,
+      error: err instanceof Error ? err.message : "Unknown verification error"
+    };
+  }
+}
+function formatVerifySignatureResult(result) {
+  const status = result.valid ? "VALID" : "INVALID";
+  const lines = [
+    `## Signature Verification: ${status}`,
+    "",
+    `- **Address:** ${result.address}`,
+    `- **Network:** ${result.network}`,
+    `- **Message:** ${result.message.length > 100 ? result.message.slice(0, 100) + "..." : result.message}`,
+    `- **Result:** ${result.valid ? "Signature is valid and matches the address" : "Signature does NOT match the address"}`
+  ];
+  if (result.error) {
+    lines.push(`- **Error:** ${result.error}`);
+  }
+  return lines.join("\n");
+}
+
+// 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)")
+});
+function getViemChain8(network) {
+  switch (network) {
+    case "ethereum":
+      return chains9.mainnet;
+    case "base":
+      return chains9.base;
+    case "arbitrum":
+      return chains9.arbitrum;
+    case "optimism":
+      return chains9.optimism;
+    case "polygon":
+      return chains9.polygon;
+    case "avalanche":
+      return chains9.avalanche;
+    case "ink":
+      return chains9.ink;
+    case "berachain":
+      return chains9.berachain;
+    case "unichain":
+      return chains9.unichain;
+    default:
+      return chains9.mainnet;
+  }
+}
+var TOKEN_DECIMALS = {
+  USDC: 6,
+  USDT: 6,
+  USDT0: 6
+};
+async function executeGetTransferHistory(input, rpcUrls) {
+  const { network, address, token, limit = 10 } = input;
+  const walletAddress = address.toLowerCase();
+  const rpcUrl = rpcUrls?.[network] || DEFAULT_RPC_URLS[network];
+  const chain = getViemChain8(network);
+  const client = (0, import_viem12.createPublicClient)({
+    chain,
+    transport: (0, import_viem12.http)(rpcUrl)
+  });
+  const tokenContracts = [];
+  if (token) {
+    const addresses = token === "USDC" ? USDC_ADDRESSES : token === "USDT" ? USDT_ADDRESSES : USDT0_ADDRESSES;
+    const addr = addresses[network];
+    if (addr) {
+      tokenContracts.push({ address: addr, symbol: token });
+    }
+  } else {
+    if (USDC_ADDRESSES[network]) {
+      tokenContracts.push({ address: USDC_ADDRESSES[network], symbol: "USDC" });
+    }
+    if (USDT_ADDRESSES[network]) {
+      tokenContracts.push({ address: USDT_ADDRESSES[network], symbol: "USDT" });
+    }
+    if (USDT0_ADDRESSES[network]) {
+      tokenContracts.push({ address: USDT0_ADDRESSES[network], symbol: "USDT0" });
+    }
+  }
+  if (tokenContracts.length === 0) {
+    return {
+      network,
+      chainId: CHAIN_IDS[network],
+      address,
+      transfers: [],
+      explorerUrl: EXPLORER_URLS[network]
+    };
+  }
+  const currentBlock = await client.getBlockNumber();
+  const fromBlock = currentBlock > 50000n ? currentBlock - 50000n : 0n;
+  const transferEvent = (0, import_viem12.parseAbiItem)(
+    "event Transfer(address indexed from, address indexed to, uint256 value)"
+  );
+  const allTransfers = [];
+  for (const tokenContract of tokenContracts) {
+    const decimals = TOKEN_DECIMALS[tokenContract.symbol] ?? 6;
+    const [sentLogs, receivedLogs] = await Promise.all([
+      client.getLogs({
+        address: tokenContract.address,
+        event: transferEvent,
+        args: { from: walletAddress },
+        fromBlock,
+        toBlock: "latest"
+      }),
+      client.getLogs({
+        address: tokenContract.address,
+        event: transferEvent,
+        args: { to: walletAddress },
+        fromBlock,
+        toBlock: "latest"
+      })
+    ]);
+    for (const log of sentLogs) {
+      allTransfers.push({
+        txHash: log.transactionHash,
+        blockNumber: (log.blockNumber ?? 0n).toString(),
+        from: log.args.from ?? "",
+        to: log.args.to ?? "",
+        amount: (0, import_viem12.formatUnits)(log.args.value ?? 0n, decimals),
+        token: tokenContract.symbol,
+        tokenAddress: tokenContract.address,
+        direction: "out"
+      });
+    }
+    for (const log of receivedLogs) {
+      allTransfers.push({
+        txHash: log.transactionHash,
+        blockNumber: (log.blockNumber ?? 0n).toString(),
+        from: log.args.from ?? "",
+        to: log.args.to ?? "",
+        amount: (0, import_viem12.formatUnits)(log.args.value ?? 0n, decimals),
+        token: tokenContract.symbol,
+        tokenAddress: tokenContract.address,
+        direction: "in"
+      });
+    }
+  }
+  allTransfers.sort((a, b) => {
+    const blockA = BigInt(a.blockNumber);
+    const blockB = BigInt(b.blockNumber);
+    if (blockB > blockA) return 1;
+    if (blockB < blockA) return -1;
+    return 0;
+  });
+  return {
+    network,
+    chainId: CHAIN_IDS[network],
+    address,
+    transfers: allTransfers.slice(0, limit),
+    explorerUrl: EXPLORER_URLS[network]
+  };
+}
+function formatTransferHistoryResult(result) {
+  const lines = [
+    `## Transfer History on ${result.network} (Chain ID: ${result.chainId})`,
+    "",
+    `**Address:** ${result.address}`,
+    ""
+  ];
+  if (result.transfers.length === 0) {
+    lines.push("_No recent transfers found_");
+    return lines.join("\n");
+  }
+  lines.push(`Found ${result.transfers.length} recent transfer(s):`, "");
+  for (const tx of result.transfers) {
+    const arrow = tx.direction === "in" ? "RECEIVED" : "SENT";
+    const counterparty = tx.direction === "in" ? `from ${tx.from}` : `to ${tx.to}`;
+    lines.push(
+      `- **${arrow}** ${tx.amount} ${tx.token} ${counterparty}`,
+      `  Block: ${tx.blockNumber} | [View Tx](${result.explorerUrl}/tx/${tx.txHash})`,
+      ""
+    );
+  }
+  return lines.join("\n");
+}
+
+// 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)")
+});
+var COINGECKO_MARKET_CHART = "https://api.coingecko.com/api/v3/coins";
+var TOKEN_TO_COINGECKO_ID2 = {
+  ETH: "ethereum",
+  MATIC: "matic-network",
+  AVAX: "avalanche-2",
+  BERA: "berachain-bera",
+  USDC: "usd-coin",
+  USDT: "tether",
+  USDT0: "tether",
+  BTC: "bitcoin",
+  SOL: "solana",
+  TON: "the-open-network",
+  TRX: "tron"
+};
+async function executeGetHistoricalPrice(input, options = {}) {
+  const { token, days = 7 } = input;
+  const tokenUpper = token.toUpperCase();
+  const coinId = TOKEN_TO_COINGECKO_ID2[tokenUpper] ?? token.toLowerCase();
+  const currency = "usd";
+  if (options.demoMode) {
+    return generateDemoData(tokenUpper, coinId, days);
+  }
+  const url = `${COINGECKO_MARKET_CHART}/${coinId}/market_chart?vs_currency=${currency}&days=${days}`;
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`CoinGecko API error: ${response.status} ${response.statusText}`);
+  }
+  const data = await response.json();
+  const prices = data.prices.map(([timestamp, price]) => ({
+    timestamp,
+    date: new Date(timestamp).toISOString(),
+    price
+  }));
+  const priceValues = prices.map((p) => p.price);
+  const firstPrice = priceValues[0] ?? 0;
+  const lastPrice = priceValues[priceValues.length - 1] ?? 0;
+  const high = Math.max(...priceValues);
+  const low = Math.min(...priceValues);
+  const absolute = lastPrice - firstPrice;
+  const percentage = firstPrice > 0 ? absolute / firstPrice * 100 : 0;
+  return {
+    token: tokenUpper,
+    coinId,
+    currency,
+    days,
+    prices,
+    priceChange: {
+      absolute: Math.round(absolute * 100) / 100,
+      percentage: Math.round(percentage * 100) / 100,
+      high: Math.round(high * 100) / 100,
+      low: Math.round(low * 100) / 100
+    }
+  };
+}
+function generateDemoData(token, coinId, days) {
+  const basePrices = {
+    ETH: 3250,
+    MATIC: 0.58,
+    AVAX: 24.15,
+    BERA: 3.82,
+    USDC: 1,
+    USDT: 1,
+    USDT0: 1,
+    BTC: 62e3,
+    SOL: 145,
+    TON: 5.2,
+    TRX: 0.12
+  };
+  const basePrice = basePrices[token] ?? 1;
+  const now = Date.now();
+  const interval = days * 24 * 60 * 60 * 1e3 / Math.min(days * 24, 168);
+  const numPoints = Math.min(days * 24, 168);
+  const prices = [];
+  for (let i = 0; i < numPoints; i++) {
+    const timestamp = now - (numPoints - i) * interval;
+    const fluctuation = 1 + (Math.sin(i * 0.5) * 0.03 + Math.cos(i * 0.3) * 0.02);
+    const price = Math.round(basePrice * fluctuation * 100) / 100;
+    prices.push({
+      timestamp,
+      date: new Date(timestamp).toISOString(),
+      price
+    });
+  }
+  const priceValues = prices.map((p) => p.price);
+  const firstPrice = priceValues[0] ?? 0;
+  const lastPrice = priceValues[priceValues.length - 1] ?? 0;
+  return {
+    token,
+    coinId,
+    currency: "usd",
+    days,
+    prices,
+    priceChange: {
+      absolute: Math.round((lastPrice - firstPrice) * 100) / 100,
+      percentage: firstPrice > 0 ? Math.round((lastPrice - firstPrice) / firstPrice * 1e4) / 100 : 0,
+      high: Math.round(Math.max(...priceValues) * 100) / 100,
+      low: Math.round(Math.min(...priceValues) * 100) / 100
+    }
+  };
+}
+function formatHistoricalPriceResult(result) {
+  const lines = [
+    `## ${result.token} Price History (${result.days} day${result.days > 1 ? "s" : ""})`,
+    "",
+    `- **Current:** $${result.prices[result.prices.length - 1]?.price.toLocaleString() ?? "N/A"}`,
+    `- **High:** $${result.priceChange.high.toLocaleString()}`,
+    `- **Low:** $${result.priceChange.low.toLocaleString()}`,
+    `- **Change:** ${result.priceChange.absolute >= 0 ? "+" : ""}$${result.priceChange.absolute.toLocaleString()} (${result.priceChange.percentage >= 0 ? "+" : ""}${result.priceChange.percentage}%)`,
+    "",
+    `_${result.prices.length} data points from CoinGecko_`
+  ];
+  return lines.join("\n");
+}
+
 // src/tools/quoteStore.ts
 var import_crypto = require("crypto");
 var DEFAULT_TTL_MS = 5 * 60 * 1e3;
@@ -2438,17 +2849,17 @@ function clearQuoteStore() {
 }
 
 // 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;
@@ -2522,11 +2933,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);
@@ -2545,7 +2956,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,
@@ -2599,12 +3010,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);
@@ -2672,10 +3083,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);
@@ -2734,22 +3145,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 = {
@@ -2804,14 +3215,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",
@@ -3372,6 +3783,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 = {
@@ -3645,16 +4181,20 @@ var ERC8004_TOOL_DEFINITIONS = {
   executeGetBalance,
   executeGetBridgeFee,
   executeGetGasPrice,
+  executeGetHistoricalPrice,
   executeGetTokenPrice,
+  executeGetTransferHistory,
   executePay,
   executePayGasless,
   executePaymentPlan,
   executePaymentPlanDemo,
   executeQuoteBridge,
   executeQuoteBridgeDemo,
+  executeSignMessage,
   executeSmartPay,
   executeSmartPayDemo,
   executeTonBridgeTool,
+  executeVerifySignature,
   executeWdkExecuteSwap,
   executeWdkExecuteSwapDemo,
   executeWdkGetBalances,
@@ -3680,13 +4220,17 @@ var ERC8004_TOOL_DEFINITIONS = {
   formatExecuteSwapResult,
   formatGasPriceResult,
   formatGaslessPaymentResult,
+  formatHistoricalPriceResult,
   formatNetworkFeeComparison,
   formatPaymentFeeEstimate,
   formatPaymentPlanResult,
   formatPaymentResult,
+  formatSignMessageResult,
   formatSmartPayResult,
   formatSwapQuoteResult,
   formatTokenPriceResult,
+  formatTransferHistoryResult,
+  formatVerifySignatureResult,
   formatWdkBalancesResult,
   formatWdkSwapResult,
   formatWdkTransferResult,
@@ -3695,15 +4239,19 @@ var ERC8004_TOOL_DEFINITIONS = {
   getBalanceInputSchema,
   getBridgeFeeInputSchema,
   getGasPriceInputSchema,
+  getHistoricalPriceInputSchema,
   getQuote,
   getTokenPriceInputSchema,
   getTokenPrices,
   getTokenPricesDemo,
+  getTransferHistoryInputSchema,
   payGaslessInputSchema,
   payInputSchema,
   paymentPlanInputSchema,
   quoteBridgeInputSchema,
+  signMessageInputSchema,
   smartPayInputSchema,
+  verifySignatureInputSchema,
   wdkExecuteSwapInputSchema,
   wdkGetBalancesInputSchema,
   wdkGetWalletInputSchema,