web3-tools-mcp 2.0.2 → 3.1.0

package/src/tools/gas.ts

@@ -1,219 +0,0 @@
-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.',
-    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)
-
-      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
-      })
-    }
-  ),
-
-  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)
-
-      // 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)
-    }
-  )
-}

package/src/tools/logs.ts

@@ -1,293 +0,0 @@
-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 { 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,
-  hypersyncApiKey?: string,
-  address?: string,
-  fromBlock?: string,
-  toBlock?: string,
-  eventArgs?: Record<string, unknown>
-) {
-  const hypersyncUrl = getClientManager().getHypersyncUrl(chainName)
-  if (!hypersyncUrl) {
-    throw new Error(`Hypersync not supported for chain: ${chainName}`)
-  }
-
-  const client = HypersyncClient.new({
-    url: hypersyncUrl,
-    bearerToken: hypersyncApiKey
-  })
-
-  const abiItem = parseAbiItem(eventAbi) as AbiEvent
-  const eventSignature = toEventSignature(abiItem)
-  const topic0 = keccak256(toBytes(eventSignature))
-
-  // Build topics array for filtering
-  const topics: (string | string[] | null)[] = [topic0]
-
-  // Add indexed parameter filtering if eventArgs provided
-  if (eventArgs && Object.keys(eventArgs).length > 0) {
-    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
-
-      topics.push(argValue === undefined ? null : toTopic(argValue))
-    }
-  }
-
-  const query = {
-    fieldSelection: {
-      log: [
-        LogField.Address,
-        LogField.Topic0,
-        LogField.Topic1,
-        LogField.Topic2,
-        LogField.Topic3,
-        LogField.Data,
-        LogField.BlockNumber,
-        LogField.BlockHash,
-        LogField.TransactionHash,
-        LogField.TransactionIndex,
-        LogField.LogIndex
-      ]
-    },
-    fromBlock: fromBlock ? Number.parseInt(fromBlock, 10) : 0,
-    toBlock: toBlock ? Number.parseInt(toBlock, 10) : undefined,
-    logs: [
-      {
-        address: address ? [address] : undefined,
-        // 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]))
-      }
-    ]
-  }
-
-  const res = await client.get(query)
-
-  // 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 Hex,
-          blockNumber: log.blockNumber ? BigInt(log.blockNumber) : 0n,
-          data,
-          logIndex: log.logIndex,
-          topics,
-          transactionHash: log.transactionHash as Hex,
-          transactionIndex: log.transactionIndex,
-          eventName: abiItem.name,
-          args: args ?? {}
-        }
-      } catch (error) {
-        console.warn('Failed to decode log:', error)
-        return null
-      }
-    })
-    .filter((log): log is NonNullable<typeof log> => log !== null)
-
-  return decodedLogs
-}
-
-export default {
-  get_logs: createTool(
-    'Query Contract Events',
-    'Search and decode contract events with filtering. Uses viem with hypersync fallback. Specify address and block ranges for best performance.',
-    z.object({
-      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)")'),
-      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()]))]))
-        .optional()
-        .describe('Filter by indexed parameters: {"from": "0x123...", "to": "0x456..."}')
-    }),
-    async (args) => {
-      const clientManager = getClientManager()
-      const config = (clientManager as any).config
-
-      // First try with regular viem client
-      try {
-        const client = clientManager.getClient(args.chain as ChainName)
-        const abiItem = parseAbiItem(args.eventAbi) as AbiEvent
-
-        // Determine block range
-        const fromBlockNum = args.fromBlock ? BigInt(args.fromBlock) : undefined
-        const toBlockNum = args.toBlock ? BigInt(args.toBlock) : undefined
-
-        // Prepare getLogs parameters
-        const getLogsParams: {
-          address?: Address
-          event: AbiEvent
-          fromBlock?: bigint
-          toBlock?: bigint
-          args?: Record<string, unknown>
-        } = {
-          event: abiItem,
-          fromBlock: fromBlockNum,
-          toBlock: toBlockNum
-        }
-
-        // Add address filter if provided
-        if (args.address && isAddress(args.address)) {
-          getLogsParams.address = args.address as Address
-        }
-
-        // Add event argument filters if provided
-        if (args.eventArgs && Object.keys(args.eventArgs).length > 0) {
-          // Convert event arguments to proper types based on ABI
-          const convertedEventArgs = convertEventArgsToTypes(args.eventArgs, abiItem.inputs)
-          getLogsParams.args = convertedEventArgs
-        }
-
-        // Use client.getLogs with proper typing
-        const logs = await client.getLogs(getLogsParams)
-
-        // Convert logs to serializable format
-        const serializedLogs = logs.map((log) => {
-          const baseLogData = {
-            address: log.address,
-            blockHash: log.blockHash,
-            blockNumber: log.blockNumber?.toString(),
-            data: log.data,
-            logIndex: log.logIndex,
-            topics: log.topics,
-            transactionHash: log.transactionHash,
-            transactionIndex: log.transactionIndex
-          }
-
-          return {
-            ...baseLogData,
-            decoded: {
-              eventName: log.eventName,
-              args: log.args
-            }
-          }
-        })
-
-        return formatResponse({
-          logs: serializedLogs,
-          eventSignature: toEventSignature(abiItem),
-          chain: args.chain,
-          fromBlock: fromBlockNum?.toString() || 'latest',
-          toBlock: toBlockNum?.toString() || 'latest',
-          count: logs.length,
-          dataSource: 'viem',
-          filters: {
-            address: args.address || null,
-            eventArgs: args.eventArgs || null
-          }
-        })
-      } catch (viemError) {
-        // If viem fails and we have hypersync support for this chain, try hypersync as fallback
-        if (clientManager.getHypersyncUrl(args.chain as ChainName)) {
-          console.warn(`Viem getLogs failed for ${args.chain}, trying hypersync fallback:`, viemError)
-
-          try {
-            const hypersyncLogs = await getLogsWithHypersync(
-              args.chain as ChainName,
-              args.eventAbi,
-              config.hypersyncApiKey,
-              args.address,
-              args.fromBlock,
-              args.toBlock,
-              args.eventArgs
-            )
-
-            const abiItem = parseAbiItem(args.eventAbi) as AbiEvent
-            const fromBlockNum = args.fromBlock ? BigInt(args.fromBlock) : undefined
-            const toBlockNum = args.toBlock ? BigInt(args.toBlock) : undefined
-
-            // Convert hypersync logs to the same format as viem logs
-            const serializedLogs = hypersyncLogs.map((log) => {
-              const baseLogData = {
-                address: log.address,
-                blockHash: log.blockHash,
-                blockNumber: log.blockNumber?.toString(),
-                data: log.data,
-                logIndex: log.logIndex,
-                topics: log.topics,
-                transactionHash: log.transactionHash,
-                transactionIndex: log.transactionIndex
-              }
-
-              return {
-                ...baseLogData,
-                decoded: {
-                  eventName: log.eventName,
-                  args: log.args
-                }
-              }
-            })
-
-            return formatResponse({
-              logs: serializedLogs,
-              eventSignature: toEventSignature(abiItem),
-              chain: args.chain,
-              fromBlock: fromBlockNum?.toString() || 'latest',
-              toBlock: toBlockNum?.toString() || 'latest',
-              count: hypersyncLogs.length,
-              dataSource: 'hypersync',
-              filters: {
-                address: args.address || null,
-                eventArgs: args.eventArgs || null
-              }
-            })
-          } catch (hypersyncError) {
-            throw new Error(`Both viem and hypersync failed. Viem error: ${viemError}. Hypersync error: ${hypersyncError}`)
-          }
-        } else {
-          // No hypersync fallback available for this chain
-          throw new Error(`Failed to get logs with viem (hypersync not available for ${args.chain}): ${viemError}`)
-        }
-      }
-    }
-  )
-}