web3-tools-mcp 1.3.0 → 1.3.2

package/src/index.ts

@@ -6,6 +6,7 @@ import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { initializeClientManager } from "./client.js";
 import { registerAllTools } from "./tools/index.js";
 import { parseCommandLineArgs } from "./utils.js";
+import { startWalletServer } from "./wallet-server.js";
 
 // Parse configuration
 const config = parseCommandLineArgs();
@@ -83,11 +84,18 @@ const server = new McpServer({
 // Register all tools
 registerAllTools(server);
 
+// Start wallet server in background
+startWalletServer().catch((error) => {
+  console.error("[MCP] Wallet server failed to start:", error.message);
+  console.error("[MCP] Transaction signing features will not be available");
+});
+
 // Start server
 async function main() {
   const transport = new StdioServerTransport();
   await server.connect(transport);
   console.error("Web3 Tools MCP Server running on stdio");
+  console.error("Wallet interface available at http://localhost:3456");
 }
 
 main().catch((error) => {

package/src/tools/gas.ts

@@ -0,0 +1,267 @@
+import { type AbiFunction, type Address, isAddress, parseAbiItem, encodeFunctionData, decodeFunctionResult } from "viem";
+import { z } from "zod";
+import type { ChainName } from "../types.js";
+import { getClientManager, SUPPORTED_CHAINS } from "../client.js";
+import { convertArgumentsToTypes, createTool, formatResponse } from "../utils.js";
+
+export default {
+  simulate_contract: createTool(
+    "Simulate Contract Call",
+    "Simulate a contract call (including state-changing functions) without broadcasting. Returns simulation result and estimated gas.",
+    z.object({
+      chain: z
+        .enum(SUPPORTED_CHAINS)
+        .describe("Blockchain network to simulate on"),
+      contractAddress: z
+        .string()
+        .describe("Contract address to call"),
+      functionAbi: z
+        .string()
+        .describe(
+          'Function ABI signature (e.g., "function transfer(address to, uint256 amount)"). Can be any function type.'
+        ),
+      args: z
+        .array(z.union([z.string(), z.number(), z.boolean(), z.null()]))
+        .optional()
+        .describe("Function arguments in order matching the ABI signature"),
+      from: z
+        .string()
+        .optional()
+        .describe("Sender address (defaults to zero address)"),
+      value: z
+        .string()
+        .optional()
+        .describe("ETH value to send with the transaction (in wei as string)"),
+      blockNumber: z
+        .string()
+        .optional()
+        .describe("Block number for simulation (defaults to latest)"),
+    }),
+    async (args) => {
+      if (!isAddress(args.contractAddress)) {
+        throw new Error(`Invalid contract address: ${args.contractAddress}`);
+      }
+
+      if (args.from && !isAddress(args.from)) {
+        throw new Error(`Invalid from address: ${args.from}`);
+      }
+
+      const clientManager = getClientManager();
+      const client = clientManager.getClient(args.chain as ChainName);
+
+      try {
+        const abiItem = parseAbiItem(args.functionAbi) as AbiFunction;
+        const convertedArgs = convertArgumentsToTypes(args.args || [], abiItem.inputs);
+
+        const blockTag = args.blockNumber ? BigInt(args.blockNumber) : undefined;
+
+        // Simulate the call
+        const result = await client.call({
+          to: args.contractAddress as Address,
+          data: encodeFunctionData({
+            abi: [abiItem],
+            functionName: abiItem.name,
+            args: convertedArgs,
+          }),
+          account: args.from ? (args.from as Address) : undefined,
+          value: args.value ? BigInt(args.value) : undefined,
+          blockNumber: blockTag,
+        });
+
+        // Also estimate gas
+        const gasEstimate = await client.estimateGas({
+          to: args.contractAddress as Address,
+          data: encodeFunctionData({
+            abi: [abiItem],
+            functionName: abiItem.name,
+            args: convertedArgs,
+          }),
+          account: args.from ? (args.from as Address) : undefined,
+          value: args.value ? BigInt(args.value) : undefined,
+          blockNumber: blockTag,
+        });
+
+        // Decode the result if the function has outputs
+        let decodedResult: unknown = result.data;
+        if (abiItem.outputs && abiItem.outputs.length > 0 && result.data) {
+          decodedResult = decodeFunctionResult({
+            abi: [abiItem],
+            functionName: abiItem.name,
+            data: result.data,
+          });
+        }
+
+        return formatResponse({
+          success: true,
+          chain: args.chain,
+          contractAddress: args.contractAddress,
+          functionName: abiItem.name,
+          result: decodedResult,
+          rawData: result.data,
+          gasEstimate: gasEstimate.toString(),
+          blockNumber: args.blockNumber || "latest",
+        });
+      } catch (error) {
+        // Check if it's a revert error
+        const errorMessage = error instanceof Error ? error.message : String(error);
+
+        return formatResponse({
+          success: false,
+          chain: args.chain,
+          contractAddress: args.contractAddress,
+          error: errorMessage,
+          reverted: errorMessage.includes("revert") || errorMessage.includes("execution reverted"),
+        });
+      }
+    }
+  ),
+
+  estimate_gas: createTool(
+    "Estimate Gas",
+    "Estimate gas required for a transaction. Supports contract calls, transfers, and deployments.",
+    z.object({
+      chain: z
+        .enum(SUPPORTED_CHAINS)
+        .describe("Blockchain network"),
+      to: z
+        .string()
+        .optional()
+        .describe("Recipient address (omit for contract deployment)"),
+      from: z
+        .string()
+        .optional()
+        .describe("Sender address (optional)"),
+      value: z
+        .string()
+        .optional()
+        .describe("ETH value to send (in wei as string)"),
+      data: z
+        .string()
+        .optional()
+        .describe("Transaction data (hex string for contract calls or deployment bytecode)"),
+      functionAbi: z
+        .string()
+        .optional()
+        .describe("Optional: Function ABI signature to encode call data automatically"),
+      args: z
+        .array(z.union([z.string(), z.number(), z.boolean(), z.null()]))
+        .optional()
+        .describe("Optional: Function arguments (only used with functionAbi)"),
+    }),
+    async (args) => {
+      if (args.to && !isAddress(args.to)) {
+        throw new Error(`Invalid to address: ${args.to}`);
+      }
+
+      if (args.from && !isAddress(args.from)) {
+        throw new Error(`Invalid from address: ${args.from}`);
+      }
+
+      const clientManager = getClientManager();
+      const client = clientManager.getClient(args.chain as ChainName);
+
+      try {
+        let callData = args.data;
+
+        // If functionAbi is provided, encode the call data
+        if (args.functionAbi) {
+          const abiItem = parseAbiItem(args.functionAbi) as AbiFunction;
+          const convertedArgs = convertArgumentsToTypes(args.args || [], abiItem.inputs);
+          callData = encodeFunctionData({
+            abi: [abiItem],
+            functionName: abiItem.name,
+            args: convertedArgs,
+          });
+        }
+
+        const gasEstimate = await client.estimateGas({
+          to: args.to ? (args.to as Address) : undefined,
+          account: args.from ? (args.from as Address) : undefined,
+          value: args.value ? BigInt(args.value) : undefined,
+          data: callData as `0x${string}` | undefined,
+        });
+
+        return formatResponse({
+          success: true,
+          chain: args.chain,
+          gasEstimate: gasEstimate.toString(),
+          to: args.to,
+          from: args.from,
+          value: args.value,
+        });
+      } catch (error) {
+        throw new Error(`Gas estimation failed: ${error}`);
+      }
+    }
+  ),
+
+  get_gas_price: createTool(
+    "Get Gas Price",
+    "Get current gas prices for a chain. Returns both legacy gasPrice and EIP-1559 fees (maxFeePerGas, maxPriorityFeePerGas).",
+    z.object({
+      chain: z
+        .enum(SUPPORTED_CHAINS)
+        .describe("Blockchain network"),
+      formatted: z
+        .boolean()
+        .optional()
+        .default(true)
+        .describe("Return prices in Gwei (default: true). If false, returns wei."),
+    }),
+    async (args) => {
+      const clientManager = getClientManager();
+      const client = clientManager.getClient(args.chain as ChainName);
+
+      try {
+        // Get both legacy and EIP-1559 gas prices
+        const [gasPrice, feeData] = await Promise.all([
+          client.getGasPrice(),
+          client.estimateFeesPerGas().catch(() => null), // Some chains don't support EIP-1559
+        ]);
+
+        const formatPrice = (wei: bigint): string => {
+          if (args.formatted) {
+            // Convert to Gwei (1 Gwei = 1e9 wei)
+            const gwei = Number(wei) / 1e9;
+            return `${gwei.toFixed(2)} Gwei`;
+          }
+          return wei.toString();
+        };
+
+        const response: any = {
+          chain: args.chain,
+          timestamp: new Date().toISOString(),
+          legacy: {
+            gasPrice: args.formatted ? formatPrice(gasPrice) : gasPrice.toString(),
+            gasPriceWei: gasPrice.toString(),
+          },
+        };
+
+        // Add EIP-1559 data if available
+        if (feeData) {
+          response.eip1559 = {
+            maxFeePerGas: args.formatted
+              ? formatPrice(feeData.maxFeePerGas)
+              : feeData.maxFeePerGas.toString(),
+            maxPriorityFeePerGas: args.formatted
+              ? formatPrice(feeData.maxPriorityFeePerGas)
+              : feeData.maxPriorityFeePerGas.toString(),
+            maxFeePerGasWei: feeData.maxFeePerGas.toString(),
+            maxPriorityFeePerGasWei: feeData.maxPriorityFeePerGas.toString(),
+          };
+
+          // Calculate estimated total cost for a standard 21000 gas transaction
+          const standardGasLimit = 21000n;
+          const estimatedCost = feeData.maxFeePerGas * standardGasLimit;
+          response.eip1559.estimatedCostFor21kGas = args.formatted
+            ? `${(Number(estimatedCost) / 1e18).toFixed(6)} ETH`
+            : estimatedCost.toString();
+        }
+
+        return formatResponse(response);
+      } catch (error) {
+        throw new Error(`Failed to get gas price: ${error}`);
+      }
+    }
+  ),
+};

package/src/tools/index.ts

@@ -6,8 +6,10 @@ import balanceTools from './balance.js'
 import contractTools from './contract.js'
 import contractInfoTools from './contract-info.js'
 import ensTools from './ens.js'
+import gasTools from './gas.js'
 import logTools from './logs.js'
 import signatureTools from './signatures.js'
+import transactionTools from './transactions.js'
 
 const allToolDefinitions = {
   ...signatureTools,
@@ -16,7 +18,9 @@ const allToolDefinitions = {
   ...balanceTools,
   ...logTools,
   ...advancedTools,
-  ...ensTools
+  ...ensTools,
+  ...gasTools,
+  ...transactionTools
 } as const
 
 // Register all tools with the MCP server

package/src/tools/signatures.ts

@@ -6,7 +6,8 @@ import {
   parseAbiItem,
   toBytes,
   toEventSignature,
-  toFunctionSignature
+  toFunctionSignature,
+  encodeFunctionData
 } from 'viem'
 import { z } from 'zod'
 import type { AbiError } from '../types.js'
@@ -122,5 +123,37 @@ export default {
         throw new Error(`Failed to parse error ABI: ${error}`)
       }
     }
+  ),
+
+  encode_function_data: createTool(
+    'Encode Function Call Data',
+    'Encode a function call with parameters into transaction data. Use this before calling call_contract_write.',
+    z.object({
+      functionAbi: z.string().describe('Function ABI definition (e.g., "function transfer(address to, uint256 amount)")'),
+      args: z.array(z.union([z.string(), z.number(), z.boolean()])).describe('Function arguments in order matching the ABI signature. Automatically type-converted.')
+    }),
+    async (args) => {
+      try {
+        const abiItem = parseAbiItem(args.functionAbi) as AbiFunction
+
+        // Encode the function data
+        const data = encodeFunctionData({
+          abi: [abiItem],
+          functionName: abiItem.name,
+          args: args.args as readonly unknown[]
+        })
+
+        return formatResponse({
+          data,
+          functionName: abiItem.name,
+          functionSignature: toFunctionSignature(abiItem),
+          selector: data.slice(0, 10),
+          encodedArgs: data.slice(10),
+          message: 'Function data encoded successfully. Use this data with call_contract_write tool.'
+        })
+      } catch (error) {
+        throw new Error(`Failed to encode function data: ${error}`)
+      }
+    }
   )
 }

package/src/tools/transactions.ts

@@ -0,0 +1,246 @@
+import { z } from 'zod'
+import { getWalletServer } from '../wallet-server.js'
+import { SUPPORTED_CHAINS } from '../client.js'
+import { parseUnits, encodeFunctionData, parseAbiItem, type AbiFunction } from 'viem'
+import { randomBytes } from 'crypto'
+import { createTool, formatResponse } from '../utils.js'
+
+function generateRequestId(): string {
+  return randomBytes(16).toString('hex')
+}
+
+export default {
+  send_native_token: createTool(
+    'Send Native Token',
+    'Send native tokens (ETH, MATIC, BNB, etc.) to an address. Opens browser wallet for approval.',
+    z.object({
+      chain: z.enum(SUPPORTED_CHAINS).describe('Blockchain network'),
+      to: z.string().describe('Recipient address'),
+      amount: z.string().describe('Amount in native token (e.g., "0.1" for 0.1 ETH)'),
+      data: z.string().optional().describe('Optional hex-encoded data to include with transaction')
+    }),
+    async (args) => {
+      const walletServer = getWalletServer()
+
+      try {
+        // Parse amount to wei
+        const value = '0x' + parseUnits(args.amount, 18).toString(16)
+
+        const txRequest = {
+          id: generateRequestId(),
+          type: 'send_transaction' as const,
+          chain: args.chain,
+          data: {
+            to: args.to,
+            value,
+            ...(args.data && { data: args.data })
+          }
+        }
+
+        console.error(`[Transaction] Sending ${args.amount} native token to ${args.to} on ${args.chain}`)
+        const txHash = await walletServer.sendTransaction(txRequest)
+
+        return formatResponse({
+          success: true,
+          chain: args.chain,
+          transactionHash: txHash,
+          to: args.to,
+          amount: args.amount,
+          message: `Successfully sent ${args.amount} native token`,
+          explorerUrl: `https://etherscan.io/tx/${txHash}`
+        })
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        return formatResponse({
+          success: false,
+          error: errorMessage,
+          message: 'Transaction failed or was rejected'
+        })
+      }
+    }
+  ),
+
+  send_erc20_token: createTool(
+    'Send ERC20 Token',
+    'Send ERC20 tokens to an address. Opens browser wallet for approval.',
+    z.object({
+      chain: z.enum(SUPPORTED_CHAINS).describe('Blockchain network'),
+      tokenAddress: z.string().describe('ERC20 token contract address'),
+      to: z.string().describe('Recipient address'),
+      amount: z.string().describe('Amount in token units (e.g., "100" for 100 USDC)'),
+      decimals: z.number().optional().default(18).describe('Token decimals (default: 18)')
+    }),
+    async (args) => {
+      const walletServer = getWalletServer()
+
+      try {
+        const decimals = args.decimals || 18
+        const amountWei = parseUnits(args.amount, decimals)
+
+        // ERC20 transfer(address to, uint256 amount)
+        const data = `0xa9059cbb${args.to.slice(2).padStart(64, '0')}${amountWei.toString(16).padStart(64, '0')}`
+
+        const txRequest = {
+          id: generateRequestId(),
+          type: 'send_transaction' as const,
+          chain: args.chain,
+          data: {
+            to: args.tokenAddress,
+            data,
+            value: '0x0'
+          }
+        }
+
+        console.error(`[Transaction] Sending ${args.amount} tokens to ${args.to} on ${args.chain}`)
+        const txHash = await walletServer.sendTransaction(txRequest)
+
+        return formatResponse({
+          success: true,
+          chain: args.chain,
+          transactionHash: txHash,
+          tokenAddress: args.tokenAddress,
+          to: args.to,
+          amount: args.amount,
+          message: `Successfully sent ${args.amount} tokens`,
+          explorerUrl: `https://etherscan.io/tx/${txHash}`
+        })
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        return formatResponse({
+          success: false,
+          error: errorMessage,
+          message: 'Token transfer failed or was rejected'
+        })
+      }
+    }
+  ),
+
+  call_contract_write: createTool(
+    'Call Contract (Write)',
+    'Call a state-changing contract function (write operation). Opens browser wallet for approval.',
+    z.object({
+      chain: z.enum(SUPPORTED_CHAINS).describe('Blockchain network'),
+      contractAddress: z.string().describe('Contract address'),
+      functionAbi: z.string().describe('Function ABI definition (e.g., "function transfer(address to, uint256 amount)")'),
+      args: z.array(z.union([z.string(), z.number(), z.boolean()])).optional().describe('Function arguments in order matching the ABI signature'),
+      value: z.string().optional().describe('Optional ETH value to send with transaction (in ETH units, e.g., "0.1")')
+    }),
+    async (args) => {
+      const walletServer = getWalletServer()
+
+      try {
+        // Parse the function ABI and encode the call data
+        console.error(`[Transaction] Parsing ABI: ${args.functionAbi}`)
+        console.error(`[Transaction] Args: ${JSON.stringify(args.args)}`)
+
+        const abiItem = parseAbiItem(args.functionAbi) as AbiFunction
+        console.error(`[Transaction] Parsed function: ${abiItem.name}`)
+
+        const data = encodeFunctionData({
+          abi: [abiItem],
+          functionName: abiItem.name,
+          args: (args.args || []) as readonly unknown[]
+        })
+        console.error(`[Transaction] Encoded data: ${data}`)
+
+        const valueHex = args.value ? '0x' + parseUnits(args.value, 18).toString(16) : '0x0'
+
+        const txRequest = {
+          id: generateRequestId(),
+          type: 'send_transaction' as const,
+          chain: args.chain,
+          data: {
+            to: args.contractAddress,
+            data,
+            value: valueHex
+          }
+        }
+
+        console.error(`[Transaction] Calling ${abiItem.name}() on ${args.contractAddress} (${args.chain})`)
+        const txHash = await walletServer.sendTransaction(txRequest)
+
+        return formatResponse({
+          success: true,
+          chain: args.chain,
+          transactionHash: txHash,
+          contractAddress: args.contractAddress,
+          functionName: abiItem.name,
+          message: `Contract call to ${abiItem.name}() successful`,
+          explorerUrl: `https://etherscan.io/tx/${txHash}`
+        })
+      } catch (error) {
+        console.error(`[Transaction] Error:`, error)
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        return formatResponse({
+          success: false,
+          error: errorMessage,
+          message: 'Contract call failed or was rejected'
+        })
+      }
+    }
+  ),
+
+  sign_message: createTool(
+    'Sign Message',
+    'Sign a message with the connected wallet. Opens browser wallet for approval.',
+    z.object({
+      message: z.string().describe('Message to sign')
+    }),
+    async (args) => {
+      const walletServer = getWalletServer()
+
+      try {
+        const request = {
+          id: generateRequestId(),
+          type: 'sign_message' as const,
+          chain: 'any',
+          data: {
+            message: args.message
+          }
+        }
+
+        console.error(`[Transaction] Signing message`)
+        const signature = await walletServer.sendTransaction(request)
+
+        return formatResponse({
+          success: true,
+          message: args.message,
+          signature,
+          signatureType: 'personal_sign'
+        })
+      } catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error)
+        return formatResponse({
+          success: false,
+          error: errorMessage,
+          message: 'Message signing failed or was rejected'
+        })
+      }
+    }
+  ),
+
+  wallet_status: createTool(
+    'Wallet Status',
+    'Check if a wallet is connected to the browser interface',
+    z.object({}),
+    async () => {
+      const walletServer = getWalletServer()
+      const isConnected = walletServer.isConnected()
+      const port = walletServer.getPort()
+
+      // Auto-open browser if no wallet connected
+      if (!isConnected) {
+        walletServer.openBrowser()
+      }
+
+      return formatResponse({
+        connected: isConnected,
+        walletUrl: `http://localhost:${port}`,
+        message: isConnected
+          ? 'Wallet is connected and ready to sign transactions'
+          : `No wallet connected. Opening browser to connect... Visit http://localhost:${port} if it didn't open automatically.`
+      })
+    }
+  )
+}
+