web3-tools-mcp 1.3.1 → 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/index.ts

@@ -9,6 +9,7 @@ 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,
@@ -18,7 +19,8 @@ const allToolDefinitions = {
   ...logTools,
   ...advancedTools,
   ...ensTools,
-  ...gasTools
+  ...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.`
+      })
+    }
+  )
+}
+

package/src/wallet-server.ts

@@ -0,0 +1,236 @@
+import express from 'express'
+import cors from 'cors'
+import { WebSocketServer, WebSocket } from 'ws'
+import { createServer } from 'http'
+import { fileURLToPath } from 'url'
+import { dirname, join } from 'path'
+import { exec } from 'child_process'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
+
+export interface TransactionRequest {
+  id: string
+  type: 'send_transaction' | 'sign_message' | 'sign_typed_data'
+  chain: string
+  data: unknown
+}
+
+export interface TransactionResponse {
+  id: string
+  success: boolean
+  result?: unknown
+  error?: string
+}
+
+class WalletServer {
+  private app: express.Application
+  private httpServer: ReturnType<typeof createServer>
+  private wss: WebSocketServer
+  private clients: Set<WebSocket> = new Set()
+  private pendingRequests: Map<string, {
+    resolve: (value: unknown) => void
+    reject: (error: Error) => void
+  }> = new Map()
+  private port: number
+  private isStarted = false
+
+  constructor(port = 3456) {
+    this.port = port
+    this.app = express()
+    this.httpServer = createServer(this.app)
+    this.wss = new WebSocketServer({ server: this.httpServer })
+
+    this.setupExpress()
+    this.setupWebSocket()
+  }
+
+  private setupExpress() {
+    this.app.use(cors())
+    this.app.use(express.json())
+    this.app.use(express.static(join(__dirname, '..', 'public')))
+
+    this.app.get('/', (_req, res) => {
+      res.sendFile(join(__dirname, '..', 'public', 'wallet.html'))
+    })
+
+    this.app.get('/health', (_req, res) => {
+      res.json({
+        status: 'ok',
+        clients: this.clients.size,
+        pendingRequests: this.pendingRequests.size
+      })
+    })
+  }
+
+  private setupWebSocket() {
+    this.wss.on('connection', (ws: WebSocket) => {
+      console.error('[Wallet Server] Client connected')
+      this.clients.add(ws)
+
+      ws.on('message', (data: Buffer) => {
+        try {
+          const response: TransactionResponse = JSON.parse(data.toString())
+          console.error('[Wallet Server] Received response:', response.id)
+          console.error('[Wallet Server] Response data:', JSON.stringify(response))
+
+          const pending = this.pendingRequests.get(response.id)
+          if (pending) {
+            if (response.success) {
+              pending.resolve(response.result)
+            } else {
+              pending.reject(new Error(response.error || 'Transaction failed'))
+            }
+            this.pendingRequests.delete(response.id)
+          }
+        } catch (error) {
+          console.error('[Wallet Server] Error parsing message:', error)
+        }
+      })
+
+      ws.on('close', () => {
+        console.error('[Wallet Server] Client disconnected')
+        this.clients.delete(ws)
+      })
+
+      ws.on('error', (error) => {
+        console.error('[Wallet Server] WebSocket error:', error)
+        this.clients.delete(ws)
+      })
+    })
+  }
+
+  async start() {
+    if (this.isStarted) {
+      return
+    }
+
+    return new Promise<void>((resolve, reject) => {
+      this.httpServer.listen(this.port, () => {
+        this.isStarted = true
+        console.error(`[Wallet Server] Running on http://localhost:${this.port}`)
+        resolve()
+      }).on('error', (error: NodeJS.ErrnoException) => {
+        if (error.code === 'EADDRINUSE') {
+          console.error(`[Wallet Server] Port ${this.port} already in use, assuming server is already running`)
+          this.isStarted = true
+          resolve()
+        } else {
+          reject(error)
+        }
+      })
+    })
+  }
+
+  async stop() {
+    return new Promise<void>((resolve) => {
+      this.clients.forEach(client => client.close())
+      this.wss.close(() => {
+        this.httpServer.close(() => {
+          this.isStarted = false
+          console.error('[Wallet Server] Stopped')
+          resolve()
+        })
+      })
+    })
+  }
+
+  openBrowser() {
+    const url = `http://localhost:${this.port}`
+    const platform = process.platform
+
+    let command: string
+    if (platform === 'darwin') {
+      command = `open "${url}"`
+    } else if (platform === 'win32') {
+      command = `start "${url}"`
+    } else {
+      command = `xdg-open "${url}"`
+    }
+
+    exec(command, (error) => {
+      if (error) {
+        console.error('[Wallet Server] Failed to open browser:', error)
+        console.error(`[Wallet Server] Please open manually: ${url}`)
+      } else {
+        console.error(`[Wallet Server] Opened browser at ${url}`)
+      }
+    })
+  }
+
+  async sendTransaction(request: TransactionRequest): Promise<unknown> {
+    if (!this.isStarted) {
+      await this.start()
+    }
+
+    // Always open/focus browser for transaction requests
+    this.openBrowser()
+
+    // Open browser if no clients connected
+    if (this.clients.size === 0) {
+      // Wait for client to connect (max 30 seconds)
+      const timeout = 30000
+      const startTime = Date.now()
+      while (this.clients.size === 0 && Date.now() - startTime < timeout) {
+        await new Promise(resolve => setTimeout(resolve, 500))
+      }
+
+      if (this.clients.size === 0) {
+        throw new Error('No wallet connected. Please open the browser and connect your wallet.')
+      }
+    }
+
+    return new Promise((resolve, reject) => {
+      this.pendingRequests.set(request.id, { resolve, reject })
+
+      // Send to first available connected client only
+      const message = JSON.stringify(request)
+      let sent = false
+      for (const client of this.clients) {
+        if (client.readyState === WebSocket.OPEN) {
+          client.send(message)
+          sent = true
+          break
+        }
+      }
+
+      if (!sent) {
+        this.pendingRequests.delete(request.id)
+        reject(new Error('No active wallet connection'))
+        return
+      }
+
+      // Timeout after 5 minutes
+      setTimeout(() => {
+        if (this.pendingRequests.has(request.id)) {
+          this.pendingRequests.delete(request.id)
+          reject(new Error('Transaction request timed out'))
+        }
+      }, 300000)
+    })
+  }
+
+  isConnected(): boolean {
+    return this.clients.size > 0
+  }
+
+  getPort(): number {
+    return this.port
+  }
+}
+
+// Singleton instance
+let walletServer: WalletServer | null = null
+
+export function getWalletServer(): WalletServer {
+  if (!walletServer) {
+    walletServer = new WalletServer()
+  }
+  return walletServer
+}
+
+export async function startWalletServer(): Promise<WalletServer> {
+  const server = getWalletServer()
+  await server.start()
+  return server
+}