web3-tools-mcp 1.3.4 → 1.4.0

package/src/tools/transactions.ts

@@ -1,18 +1,59 @@
 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 { getWalletClient } from '../wallet-client.js'
+import { getClientManager, SUPPORTED_CHAINS } from '../client.js'
+import { encodeFunctionData, isAddress, parseAbiItem, parseUnits, type AbiFunction, type Address } from 'viem'
+import { randomBytes } from 'node:crypto'
+import type { ChainName } from '../types.js'
+import { buildTxPreview, type RawTx } from '../preview.js'
 import { createTool, formatResponse } from '../utils.js'
 
 function generateRequestId(): string {
   return randomBytes(16).toString('hex')
 }
 
+function requireAddress(label: string, address: string): Address {
+  if (!isAddress(address)) throw new Error(`Invalid ${label}: ${address}`)
+  return address
+}
+
+function explorerTxUrl(chain: ChainName, txHash: unknown): string {
+  return `https://${getClientManager().getEtherscanDomain(chain)}/tx/${txHash}`
+}
+
+/**
+ * Send a transaction for signing, with a decoded + simulated preview attached so the
+ * wallet page can show what it actually does instead of raw calldata.
+ */
+async function requestSignature(chain: ChainName, tx: RawTx & { data?: string }) {
+  const wallet = getWalletClient()
+  await wallet.waitForSigner()
+
+  const preview = await buildTxPreview(chain, tx, wallet.getAddress())
+
+  return {
+    txHash: await wallet.request({
+      id: generateRequestId(),
+      type: 'send_transaction',
+      chain,
+      data: { to: tx.to, value: tx.value ?? '0x0', ...(tx.data && { data: tx.data }) },
+      preview
+    }),
+    preview
+  }
+}
+
+function failure(error: unknown, message: string) {
+  return formatResponse({
+    success: false,
+    error: error instanceof Error ? error.message : String(error),
+    message
+  })
+}
+
 export default {
   send_native_token: createTool(
     'Send Native Token',
-    'Send native tokens (ETH, MATIC, BNB, etc.) to an address. Opens browser wallet for approval.',
+    'Send native tokens (ETH, MATIC, BNB, etc.) to an address. Simulates the transaction, then opens the browser wallet for approval.',
     z.object({
       chain: z.enum(SUPPORTED_CHAINS).describe('Blockchain network'),
       to: z.string().describe('Recipient address'),
@@ -20,49 +61,30 @@ export default {
       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 to = requireAddress('recipient address', args.to)
+        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)
+        const { txHash, preview } = await requestSignature(args.chain as ChainName, { to, value, data: args.data })
 
         return formatResponse({
           success: true,
           chain: args.chain,
           transactionHash: txHash,
-          to: args.to,
+          to,
           amount: args.amount,
-          message: `Successfully sent ${args.amount} native token`,
-          explorerUrl: `https://etherscan.io/tx/${txHash}`
+          simulation: preview.simulation,
+          explorerUrl: explorerTxUrl(args.chain as ChainName, txHash)
         })
       } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error)
-        return formatResponse({
-          success: false,
-          error: errorMessage,
-          message: 'Transaction failed or was rejected'
-        })
+        return failure(error, 'Transaction failed or was rejected')
       }
     }
   ),
 
   send_erc20_token: createTool(
     'Send ERC20 Token',
-    'Send ERC20 tokens to an address. Opens browser wallet for approval.',
+    'Send ERC20 tokens to an address. Simulates the transfer, then opens the browser wallet for approval.',
     z.object({
       chain: z.enum(SUPPORTED_CHAINS).describe('Blockchain network'),
       tokenAddress: z.string().describe('ERC20 token contract address'),
@@ -71,111 +93,71 @@ export default {
       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 tokenAddress = requireAddress('token address', args.tokenAddress)
+        const to = requireAddress('recipient address', args.to)
 
-        const txRequest = {
-          id: generateRequestId(),
-          type: 'send_transaction' as const,
-          chain: args.chain,
-          data: {
-            to: args.tokenAddress,
-            data,
-            value: '0x0'
-          }
-        }
+        const data = encodeFunctionData({
+          abi: [parseAbiItem('function transfer(address to, uint256 amount)')],
+          args: [to, parseUnits(args.amount, args.decimals ?? 18)]
+        })
 
-        console.error(`[Transaction] Sending ${args.amount} tokens to ${args.to} on ${args.chain}`)
-        const txHash = await walletServer.sendTransaction(txRequest)
+        const { txHash, preview } = await requestSignature(args.chain as ChainName, { to: tokenAddress, data, value: '0x0' })
 
         return formatResponse({
           success: true,
           chain: args.chain,
           transactionHash: txHash,
-          tokenAddress: args.tokenAddress,
-          to: args.to,
+          tokenAddress,
+          to,
           amount: args.amount,
-          message: `Successfully sent ${args.amount} tokens`,
-          explorerUrl: `https://etherscan.io/tx/${txHash}`
+          simulation: preview.simulation,
+          explorerUrl: explorerTxUrl(args.chain as ChainName, 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'
-        })
+        return failure(error, '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.',
+    'Call a state-changing contract function. Simulates the call, then opens the 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")')
+      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 native 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 contractAddress = requireAddress('contract address', args.contractAddress)
         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 value = args.value ? `0x${parseUnits(args.value, 18).toString(16)}` : '0x0'
 
-        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)
+        const { txHash, preview } = await requestSignature(args.chain as ChainName, { to: contractAddress, data, value })
 
         return formatResponse({
           success: true,
           chain: args.chain,
           transactionHash: txHash,
-          contractAddress: args.contractAddress,
+          contractAddress,
           functionName: abiItem.name,
-          message: `Contract call to ${abiItem.name}() successful`,
-          explorerUrl: `https://etherscan.io/tx/${txHash}`
+          simulation: preview.simulation,
+          explorerUrl: explorerTxUrl(args.chain as ChainName, 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'
-        })
+        return failure(error, 'Contract call failed or was rejected')
       }
     }
   ),
@@ -187,20 +169,13 @@ export default {
       message: z.string().describe('Message to sign')
     }),
     async (args) => {
-      const walletServer = getWalletServer()
-
       try {
-        const request = {
+        const signature = await getWalletClient().request({
           id: generateRequestId(),
-          type: 'sign_message' as const,
+          type: 'sign_message',
           chain: 'any',
-          data: {
-            message: args.message
-          }
-        }
-
-        console.error(`[Transaction] Signing message`)
-        const signature = await walletServer.sendTransaction(request)
+          data: { message: args.message }
+        })
 
         return formatResponse({
           success: true,
@@ -209,12 +184,7 @@ export default {
           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'
-        })
+        return failure(error, 'Message signing failed or was rejected')
       }
     }
   ),
@@ -224,23 +194,26 @@ export default {
     'Check if a wallet is connected to the browser interface',
     z.object({}),
     async () => {
-      const walletServer = getWalletServer()
-      const isConnected = walletServer.isConnected()
-      const port = walletServer.getPort()
+      const wallet = getWalletClient()
 
-      // Auto-open browser if no wallet connected
-      if (!isConnected) {
-        walletServer.openBrowser()
+      try {
+        await wallet.connect()
+      } catch (error) {
+        return failure(error, 'Wallet relay unavailable')
       }
 
+      if (!wallet.isConnected()) wallet.openBrowser()
+
       return formatResponse({
-        connected: isConnected,
-        walletUrl: `http://localhost:${port}`,
-        message: isConnected
+        connected: wallet.isConnected(),
+        address: wallet.getAddress(),
+        walletUrl: wallet.getUrl(),
+        openTab: wallet.getPageUrl(),
+        hosted: wallet.isRemote,
+        message: wallet.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.`
+          : `No wallet connected. Open ${wallet.getUrl()} and connect your wallet.`
       })
     }
   )
 }
-

package/src/utils.ts

@@ -35,6 +35,101 @@ export function convertBigIntToString(obj: unknown): unknown {
   return obj
 }
 
+
+// Summarize a call trace for compact output
+export interface SummarizedCall {
+  type: string
+  from: string
+  to: string
+  selector?: string
+  error?: string
+  depth: number
+}
+
+export function summarizeTrace(trace: unknown): { hasError: boolean; errorPath: SummarizedCall[] | null; summary: string } {
+  // Use ref object to avoid TypeScript closure narrowing issues
+  const result: { errorPath: SummarizedCall[]; errorMessage: string } | null = findErrorInTrace(trace)
+
+  // Generate summary
+  let summary: string
+  if (result) {
+    const lastCall = result.errorPath[result.errorPath.length - 1]
+    summary = `REVERTED at depth ${lastCall.depth}: ${lastCall.to} (${lastCall.selector || 'unknown'}) - ${result.errorMessage}`
+  } else {
+    // For successful txs, just show top-level calls
+    const topCalls: string[] = []
+    const rootCall = trace as Record<string, unknown>
+    const subcalls = rootCall.calls as Record<string, unknown>[] | undefined
+    if (subcalls) {
+      for (const sub of subcalls) {
+        const type = sub.type as string
+        if (type !== 'DELEGATECALL') {
+          const input = sub.input as string | undefined
+          const selector = input && input.length >= 10 ? input.slice(0, 10) : '?'
+          topCalls.push(`${type} ${sub.to} (${selector})`)
+        }
+      }
+    }
+    summary = `SUCCESS - ${topCalls.length} top-level calls: ${topCalls.slice(0, 5).join(', ')}${topCalls.length > 5 ? '...' : ''}`
+  }
+
+  return { 
+    hasError: result !== null, 
+    errorPath: result?.errorPath ?? null, 
+    summary 
+  }
+}
+
+function findErrorInTrace(trace: unknown): { errorPath: SummarizedCall[]; errorMessage: string } | null {
+  if (!trace || typeof trace !== 'object') return null
+
+  function findError(call: Record<string, unknown>, path: SummarizedCall[]): { errorPath: SummarizedCall[]; errorMessage: string } | null {
+    const type = (call.type as string) || 'CALL'
+    const error = (call.error as string) || (call.revertReason as string)
+    const subcalls = call.calls as Record<string, unknown>[] | undefined
+    const input = call.input as string | undefined
+
+    // Skip DELEGATECALL for cleaner output
+    if (type === 'DELEGATECALL') {
+      if (subcalls) {
+        for (const subcall of subcalls) {
+          const result = findError(subcall, path)
+          if (result) return result
+        }
+      }
+      return null
+    }
+
+    const currentCall: SummarizedCall = {
+      type,
+      from: (call.from as string) || '',
+      to: (call.to as string) || '',
+      selector: input && input.length >= 10 ? input.slice(0, 10) : undefined,
+      error: error || undefined,
+      depth: path.length
+    }
+
+    const newPath = [...path, currentCall]
+
+    // Check subcalls first (error might be deeper)
+    if (subcalls) {
+      for (const subcall of subcalls) {
+        const result = findError(subcall, newPath)
+        if (result) return result
+      }
+    }
+
+    // If this call has an error and no subcall had one, this is the source
+    if (error) {
+      return { errorPath: newPath, errorMessage: error }
+    }
+
+    return null
+  }
+
+  return findError(trace as Record<string, unknown>, [])
+}
+
 // Convert arguments to appropriate types based on ABI
 export function convertArgumentsToTypes(
   args: (string | number | boolean | null)[],