web3-tools-mcp 1.6.0 → 2.0.0

package/src/tools/gas.ts

@@ -1,59 +1,44 @@
-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";
+import { type AbiFunction, type Address, decodeFunctionResult, encodeFunctionData, isAddress, parseAbiItem } from 'viem'
+import { z } from 'zod'
+import { getClientManager, SUPPORTED_CHAINS } from '../client.js'
+import type { ChainName } from '../types.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.",
+    '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"),
+      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.'
-        ),
+        .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)"),
+        .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}`);
+        throw new Error(`Invalid contract address: ${args.contractAddress}`)
       }
 
       if (args.from && !isAddress(args.from)) {
-        throw new Error(`Invalid from address: ${args.from}`);
+        throw new Error(`Invalid from address: ${args.from}`)
       }
 
-      const clientManager = getClientManager();
-      const client = clientManager.getClient(args.chain as ChainName);
+      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 abiItem = parseAbiItem(args.functionAbi) as AbiFunction
+        const convertedArgs = convertArgumentsToTypes(args.args || [], abiItem.inputs)
 
-        const blockTag = args.blockNumber ? BigInt(args.blockNumber) : undefined;
+        const blockTag = args.blockNumber ? BigInt(args.blockNumber) : undefined
 
         // Simulate the call
         const result = await client.call({
@@ -61,12 +46,12 @@ export default {
           data: encodeFunctionData({
             abi: [abiItem],
             functionName: abiItem.name,
-            args: convertedArgs,
+            args: convertedArgs
           }),
           account: args.from ? (args.from as Address) : undefined,
           value: args.value ? BigInt(args.value) : undefined,
-          blockNumber: blockTag,
-        });
+          blockNumber: blockTag
+        })
 
         // Also estimate gas
         const gasEstimate = await client.estimateGas({
@@ -74,21 +59,21 @@ export default {
           data: encodeFunctionData({
             abi: [abiItem],
             functionName: abiItem.name,
-            args: convertedArgs,
+            args: convertedArgs
           }),
           account: args.from ? (args.from as Address) : undefined,
           value: args.value ? BigInt(args.value) : undefined,
-          blockNumber: blockTag,
-        });
+          blockNumber: blockTag
+        })
 
         // Decode the result if the function has outputs
-        let decodedResult: unknown = result.data;
+        let decodedResult: unknown = result.data
         if (abiItem.outputs && abiItem.outputs.length > 0 && result.data) {
           decodedResult = decodeFunctionResult({
             abi: [abiItem],
             functionName: abiItem.name,
-            data: result.data,
-          });
+            data: result.data
+          })
         }
 
         return formatResponse({
@@ -99,169 +84,136 @@ export default {
           result: decodedResult,
           rawData: result.data,
           gasEstimate: gasEstimate.toString(),
-          blockNumber: args.blockNumber || "latest",
-        });
+          blockNumber: args.blockNumber || 'latest'
+        })
       } catch (error) {
         // Check if it's a revert error
-        const errorMessage = error instanceof Error ? error.message : String(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"),
-        });
+          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.",
+    '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"),
+      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)"),
+        .describe('Optional: Function arguments (only used with functionAbi)')
     }),
     async (args) => {
       if (args.to && !isAddress(args.to)) {
-        throw new Error(`Invalid to address: ${args.to}`);
+        throw new Error(`Invalid to address: ${args.to}`)
       }
 
       if (args.from && !isAddress(args.from)) {
-        throw new Error(`Invalid from address: ${args.from}`);
+        throw new Error(`Invalid from address: ${args.from}`)
       }
 
-      const clientManager = getClientManager();
-      const client = clientManager.getClient(args.chain as ChainName);
+      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,
-          });
-        }
+      let callData = args.data
 
-        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}`);
+      // 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
+      })
     }
   ),
 
   get_gas_price: createTool(
-    "Get Gas Price",
-    "Get current gas prices for a chain. Returns both legacy gasPrice and EIP-1559 fees (maxFeePerGas, maxPriorityFeePerGas).",
+    '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."),
+      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(),
-          },
-        };
+      const clientManager = getClientManager()
+      const client = clientManager.getClient(args.chain as ChainName)
+
+      // 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()
+      }
 
-        // 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(),
-          };
+      const response: any = {
+        chain: args.chain,
+        timestamp: new Date().toISOString(),
+        legacy: {
+          gasPrice: args.formatted ? formatPrice(gasPrice) : gasPrice.toString(),
+          gasPriceWei: gasPrice.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();
+      // 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()
         }
 
-        return formatResponse(response);
-      } catch (error) {
-        throw new Error(`Failed to get gas price: ${error}`);
+        // 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)
     }
-  ),
-};
+  )
+}

package/src/tools/index.ts

@@ -1,5 +1,5 @@
-import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
-import { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js'
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
+import type { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js'
 import type { ServerNotification, ServerRequest } from '@modelcontextprotocol/sdk/types.js'
 import advancedTools from './advanced.js'
 import balanceTools from './balance.js'

package/src/tools/logs.ts

@@ -2,17 +2,38 @@ import { HypersyncClient, type Log, LogField } from '@envio-dev/hypersync-client
 import {
   type AbiEvent,
   type Address,
+  decodeEventLog,
+  type Hex,
   isAddress,
   keccak256,
+  numberToHex,
+  padHex,
   parseAbiItem,
   toBytes,
   toEventSignature
 } from 'viem'
 import { z } from 'zod'
+import { getClientManager, SUPPORTED_CHAINS } from '../client.js'
 import type { ChainName } from '../types.js'
-import { getClientManager, HYPERSYNC_URLS, SUPPORTED_CHAINS } from '../client.js'
 import { convertEventArgsToTypes, createTool, formatResponse } from '../utils.js'
 
+/**
+ * A topic is always 32 bytes, so an address, a number or a short hex value has to be
+ * left-padded to fit. Passing one through unpadded is rejected outright by Hypersync.
+ */
+function toTopic(value: unknown): Hex {
+  if (typeof value === 'number' || typeof value === 'bigint') {
+    return padHex(numberToHex(value), { size: 32 })
+  }
+  if (typeof value === 'boolean') {
+    return padHex(value ? '0x01' : '0x00', { size: 32 })
+  }
+  if (typeof value === 'string' && (isAddress(value) || value.startsWith('0x'))) {
+    return padHex(value.toLowerCase() as Hex, { size: 32 })
+  }
+  throw new Error(`Cannot filter on indexed value ${JSON.stringify(value)} — expected an address, number or hex string`)
+}
+
 async function getLogsWithHypersync(
   chainName: ChainName,
   eventAbi: string,
@@ -22,7 +43,7 @@ async function getLogsWithHypersync(
   toBlock?: string,
   eventArgs?: Record<string, unknown>
 ) {
-  const hypersyncUrl = HYPERSYNC_URLS[chainName]
+  const hypersyncUrl = getClientManager().getHypersyncUrl(chainName)
   if (!hypersyncUrl) {
     throw new Error(`Hypersync not supported for chain: ${chainName}`)
   }
@@ -41,27 +62,13 @@ async function getLogsWithHypersync(
 
   // Add indexed parameter filtering if eventArgs provided
   if (eventArgs && Object.keys(eventArgs).length > 0) {
-    const indexedInputs = abiItem.inputs.filter(input => input.indexed)
+    const indexedInputs = abiItem.inputs.filter((input) => input.indexed)
 
     for (let i = 0; i < indexedInputs.length && i < 3; i++) {
       const input = indexedInputs[i]
       const argValue = input?.name ? eventArgs[input.name] : undefined
 
-      if (argValue !== undefined) {
-        // Convert the argument to the proper format for topic filtering
-        let topicValue: string
-        if (typeof argValue === 'string' && argValue.startsWith('0x')) {
-          topicValue = argValue
-        } else if (typeof argValue === 'string' && isAddress(argValue)) {
-          topicValue = argValue.toLowerCase().padStart(66, '0x000000000000000000000000')
-        } else {
-          // For other types, we'd need more sophisticated encoding
-          topicValue = String(argValue)
-        }
-        topics.push(topicValue)
-      } else {
-        topics.push(null)
-      }
+      topics.push(argValue === undefined ? null : toTopic(argValue))
     }
   }
 
@@ -81,12 +88,14 @@ async function getLogsWithHypersync(
         LogField.LogIndex
       ]
     },
-    fromBlock: fromBlock ? Number.parseInt(fromBlock) : 0,
-    toBlock: toBlock ? Number.parseInt(toBlock) : undefined,
+    fromBlock: fromBlock ? Number.parseInt(fromBlock, 10) : 0,
+    toBlock: toBlock ? Number.parseInt(toBlock, 10) : undefined,
     logs: [
       {
         address: address ? [address] : undefined,
-        topics: topics.filter(t => t !== null).map(t => (Array.isArray(t) ? t : [t]))
+        // An unfiltered position is an empty list, not a dropped entry: removing it would
+        // slide every later filter up a slot and match on the wrong parameter.
+        topics: topics.map((t) => (t === null ? [] : Array.isArray(t) ? t : [t]))
       }
     ]
   }
@@ -96,18 +105,22 @@ async function getLogsWithHypersync(
   // Convert hypersync logs to viem-compatible format
   const decodedLogs = res.data.logs
     .map((log: Log) => {
+      const topics = log.topics.filter((topic): topic is string => Boolean(topic)) as [Hex, ...Hex[]]
+      const data = (log.data ?? '0x') as Hex
+
       try {
+        const { args } = decodeEventLog({ abi: [abiItem], data, topics })
         return {
           address: log.address as Address,
-          blockHash: log.blockHash as `0x${string}`,
+          blockHash: log.blockHash as Hex,
           blockNumber: log.blockNumber ? BigInt(log.blockNumber) : 0n,
-          data: log.data as `0x${string}`,
+          data,
           logIndex: log.logIndex,
-          topics: log.topics as `0x${string}`[],
-          transactionHash: log.transactionHash as `0x${string}`,
+          topics,
+          transactionHash: log.transactionHash as Hex,
           transactionIndex: log.transactionIndex,
           eventName: abiItem.name,
-          args: {}
+          args: args ?? {}
         }
       } catch (error) {
         console.warn('Failed to decode log:', error)
@@ -127,21 +140,12 @@ export default {
       chain: z.enum(SUPPORTED_CHAINS).describe('The blockchain network to use'),
       eventAbi: z
         .string()
-        .describe(
-          'Event ABI definition (e.g., "event Transfer(address indexed from, address indexed to, uint256 value)")'
-        ),
+        .describe('Event ABI definition (e.g., "event Transfer(address indexed from, address indexed to, uint256 value)")'),
       address: z.string().optional().describe('Contract address (RECOMMENDED for performance)'),
       fromBlock: z.string().optional().describe('Start block (defaults to latest-1000)'),
       toBlock: z.string().optional().describe('End block (defaults to latest)'),
       eventArgs: z
-        .record(
-          z.union([
-            z.string(),
-            z.number(),
-            z.boolean(),
-            z.array(z.union([z.string(), z.number(), z.boolean()]))
-          ])
-        )
+        .record(z.union([z.string(), z.number(), z.boolean(), z.array(z.union([z.string(), z.number(), z.boolean()]))]))
         .optional()
         .describe('Filter by indexed parameters: {"from": "0x123...", "to": "0x456..."}')
     }),
@@ -187,7 +191,7 @@ export default {
         const logs = await client.getLogs(getLogsParams)
 
         // Convert logs to serializable format
-        const serializedLogs = logs.map(log => {
+        const serializedLogs = logs.map((log) => {
           const baseLogData = {
             address: log.address,
             blockHash: log.blockHash,
@@ -223,7 +227,7 @@ export default {
         })
       } catch (viemError) {
         // If viem fails and we have hypersync support for this chain, try hypersync as fallback
-        if (HYPERSYNC_URLS[args.chain as ChainName] && args.chain !== 'localhost') {
+        if (clientManager.getHypersyncUrl(args.chain as ChainName)) {
           console.warn(`Viem getLogs failed for ${args.chain}, trying hypersync fallback:`, viemError)
 
           try {
@@ -242,7 +246,7 @@ export default {
             const toBlockNum = args.toBlock ? BigInt(args.toBlock) : undefined
 
             // Convert hypersync logs to the same format as viem logs
-            const serializedLogs = hypersyncLogs.map(log => {
+            const serializedLogs = hypersyncLogs.map((log) => {
               const baseLogData = {
                 address: log.address,
                 blockHash: log.blockHash,
@@ -277,9 +281,7 @@ export default {
               }
             })
           } catch (hypersyncError) {
-            throw new Error(
-              `Both viem and hypersync failed. Viem error: ${viemError}. Hypersync error: ${hypersyncError}`
-            )
+            throw new Error(`Both viem and hypersync failed. Viem error: ${viemError}. Hypersync error: ${hypersyncError}`)
           }
         } else {
           // No hypersync fallback available for this chain