web3-tools-mcp 3.0.0 → 3.2.0

package/src/tools/read/ens.ts

@@ -1,9 +1,9 @@
 import { type Address, isAddress, namehash } from 'viem'
 import { normalize } from 'viem/ens'
 import { z } from 'zod'
-import { getClientManager, SUPPORTED_CHAINS } from '../../client.js'
+import { getClientManager } from '../../client.js'
 import type { ChainName } from '../../types.js'
-import { createTool, formatResponse } from '../../utils.js'
+import { createTool, formatResponse, MAX_BATCH } from '../../utils.js'
 
 // Base ENS Contract Addresses
 const BASE_ENS_CONTRACTS = {
@@ -159,32 +159,32 @@ async function getTextRecordBase(name: string, key: string): Promise<string | nu
   }
 }
 
+/** Where a name service is deployed: ENS on mainnet, Linea Names on Linea, Basenames on Base. */
+const ENS_CHAINS = ['mainnet', 'linea', 'base'] as const
+const ensChain = z
+  .enum(ENS_CHAINS)
+  .default('mainnet')
+  .describe('Where the name lives: mainnet for .eth (ENS), linea for Linea Names, base for Basenames. Defaults to mainnet.')
+
 const EnsResolveSchema = z.object({
-  chain: z
-    .enum(SUPPORTED_CHAINS)
-    .default('mainnet')
-    .describe('Blockchain network (defaults to mainnet, as ENS is primarily on Ethereum)'),
-  name: z.string().describe("ENS name to resolve to an address (e.g., 'vitalik.eth', 'example.eth')"),
-  universalResolver: z.boolean().optional().describe('Use universal resolver for cross-chain resolution (defaults to true)')
+  chain: ensChain,
+  name: z.string().describe("ENS name to resolve to an address (e.g., 'vitalik.eth', 'example.eth')")
 })
 
 const EnsReverseResolveSchema = z.object({
-  chain: z.enum(SUPPORTED_CHAINS).default('mainnet').describe('Blockchain network (defaults to mainnet)'),
-  address: z.string().describe('Ethereum address to resolve to an ENS name'),
-  universalResolver: z.boolean().optional().describe('Use universal resolver for cross-chain resolution (defaults to true)')
+  chain: ensChain,
+  address: z.string().describe('Ethereum address to resolve to an ENS name')
 })
 
 const EnsTextRecordSchema = z.object({
-  chain: z.enum(SUPPORTED_CHAINS).default('mainnet').describe('Blockchain network (defaults to mainnet)'),
+  chain: ensChain,
   name: z.string().describe('ENS name to query text records from'),
-  key: z.string().describe("Text record key (e.g., 'avatar', 'description', 'email', 'url', 'com.twitter', 'com.github')"),
-  universalResolver: z.boolean().optional().describe('Use universal resolver for cross-chain resolution (defaults to true)')
+  key: z.string().describe("Text record key (e.g., 'avatar', 'description', 'email', 'url', 'com.twitter', 'com.github')")
 })
 
 const EnsBatchResolveSchema = z.object({
-  chain: z.enum(SUPPORTED_CHAINS).default('mainnet').describe('Blockchain network (defaults to mainnet)'),
-  names: z.array(z.string()).describe('Array of ENS names to resolve to addresses in a single batch'),
-  universalResolver: z.boolean().optional().describe('Use universal resolver for cross-chain resolution (defaults to true)')
+  chain: ensChain,
+  names: z.array(z.string()).max(MAX_BATCH).describe('Array of ENS names to resolve to addresses in a single batch')
 })
 
 export default {
@@ -207,8 +207,7 @@ export default {
         const client = clientManager.getClient(args.chain as ChainName)
 
         address = await client.getEnsAddress({
-          name: normalizedName,
-          universalResolverAddress: args.universalResolver !== false ? undefined : undefined
+          name: normalizedName
         })
       }
 
@@ -253,8 +252,7 @@ export default {
         const client = clientManager.getClient(args.chain as ChainName)
 
         ensName = await client.getEnsName({
-          address: args.address as Address,
-          universalResolverAddress: args.universalResolver !== false ? undefined : undefined
+          address: args.address as Address
         })
       }
 
@@ -297,8 +295,7 @@ export default {
 
         textRecord = await client.getEnsText({
           name: normalizedName,
-          key: args.key,
-          universalResolverAddress: args.universalResolver !== false ? undefined : undefined
+          key: args.key
         })
       }
 
@@ -327,11 +324,10 @@ export default {
 
   get_ens_avatar: createTool(
     'Get ENS Avatar',
-    'Get the avatar URI for an ENS name. Returns the avatar URL if set.',
+    'Get the raw avatar text record for an ENS name: an https/ipfs URL, a data URI, or an NFT reference (eip155:1/erc721:0x…/1). It is not fetched or resolved to an image.',
     z.object({
-      chain: z.enum(SUPPORTED_CHAINS).default('mainnet').describe('Blockchain network (defaults to mainnet)'),
-      name: z.string().describe('ENS name to get avatar from'),
-      universalResolver: z.boolean().optional().describe('Use universal resolver for cross-chain resolution (defaults to true)')
+      chain: ensChain,
+      name: z.string().describe('ENS name to get avatar from')
     }),
     async (args) => {
       // Normalize the ENS name
@@ -347,10 +343,8 @@ export default {
         const clientManager = getClientManager()
         const client = clientManager.getClient(args.chain as ChainName)
 
-        avatar = await client.getEnsAvatar({
-          name: normalizedName,
-          universalResolverAddress: args.universalResolver !== false ? undefined : undefined
-        })
+        // getEnsAvatar would fetch the record's URL (or the NFT's metadata) from this server.
+        avatar = await client.getEnsText({ name: normalizedName, key: 'avatar' })
       }
 
       if (!avatar) {
@@ -394,8 +388,7 @@ export default {
             const client = clientManager.getClient(args.chain as ChainName)
 
             address = await client.getEnsAddress({
-              name: normalizedName,
-              universalResolverAddress: args.universalResolver !== false ? undefined : undefined
+              name: normalizedName
             })
           }
 

package/src/tools/read/gas.ts

@@ -4,6 +4,7 @@ import {
   decodeFunctionResult,
   encodeFunctionData,
   formatEther,
+  formatGwei,
   type Hex,
   isAddress,
   parseAbiItem,
@@ -14,12 +15,10 @@ import { z } from 'zod'
 import { getClientManager, SUPPORTED_CHAINS } from '../../client.js'
 import { enrichTransfers } from '../../preview.js'
 import type { ChainName } from '../../types.js'
-import { convertArgumentsToTypes, createTool, formatResponse } from '../../utils.js'
+import { convertArgumentsToTypes, createTool, formatResponse, MAX_BATCH, rpcReason } from '../../utils.js'
 
 /** Alchemy's bundle method takes at most this many transactions. */
 const ALCHEMY_BUNDLE_LIMIT = 3
-/** One tool call is one quota unit, so an unbounded bundle would be a way around the quota. */
-const MAX_BUNDLE = 25
 /** Where eth_simulateV1's traced native transfers say they come from. */
 const NATIVE_TOKEN = '0xeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee'
 
@@ -67,15 +66,6 @@ interface AlchemyOutcome {
   error?: { message: string }
 }
 
-/**
- * Why an RPC call failed, without the request URL — viem puts it in `message`, and with a
- * provider key configured that URL carries the key.
- */
-function rpcReason(error: unknown): string {
-  const { details, shortMessage } = error as { details?: string; shortMessage?: string }
-  return details || shortMessage || 'The RPC request failed'
-}
-
 function bundleCall(
   call: { to: string; functionAbi?: string; args?: z.infer<typeof argsSchema>; data?: string; value?: string; from?: string },
   from: string | undefined,
@@ -223,33 +213,16 @@ export default {
         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({
+        const tx = {
           to: args.contractAddress as Address,
-          data: encodeFunctionData({
-            abi: [abiItem],
-            functionName: abiItem.name,
-            args: convertedArgs
-          }),
+          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
-        })
+          blockNumber: args.blockNumber ? BigInt(args.blockNumber) : undefined
+        }
 
-        // 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
-        })
+        const result = await client.call(tx)
+        const gasEstimate = await client.estimateGas(tx)
 
         // Decode the result if the function has outputs
         let decodedResult: unknown = result.data
@@ -272,15 +245,12 @@ export default {
           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')
+          error: rpcReason(error),
+          reverted: String(error instanceof Error ? error.message : error).includes('revert')
         })
       }
     }
@@ -311,7 +281,7 @@ export default {
           })
         )
         .min(1)
-        .max(MAX_BUNDLE)
+        .max(MAX_BATCH)
         .describe('Transactions to run, in order'),
       blockNumber: z.string().optional().describe('Block to simulate on top of (defaults to latest)')
     }),
@@ -437,14 +407,7 @@ export default {
         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 formatPrice = (wei: bigint): string => `${formatGwei(wei)} Gwei`
 
       const response: any = {
         chain: args.chain,
@@ -470,7 +433,7 @@ export default {
         const standardGasLimit = 21000n
         const estimatedCost = feeData.maxFeePerGas * standardGasLimit
         response.eip1559.estimatedCostFor21kGas = args.formatted
-          ? `${(Number(estimatedCost) / 1e18).toFixed(6)} ETH`
+          ? `${formatEther(estimatedCost)} ${client.chain?.nativeCurrency.symbol ?? 'ETH'}`
           : estimatedCost.toString()
       }
 

package/src/tools/read/logs.ts

@@ -15,7 +15,7 @@ import {
 import { z } from 'zod'
 import { getClientManager, SUPPORTED_CHAINS } from '../../client.js'
 import type { ChainName } from '../../types.js'
-import { convertEventArgsToTypes, createTool, formatResponse } from '../../utils.js'
+import { convertEventArgsToTypes, createTool, formatResponse, rpcReason } from '../../utils.js'
 
 /**
  * A topic is always 32 bytes, so an address, a number or a short hex value has to be
@@ -34,15 +34,71 @@ function toTopic(value: unknown): Hex {
   throw new Error(`Cannot filter on indexed value ${JSON.stringify(value)} — expected an address, number or hex string`)
 }
 
+/** More than this is cut short, with the block to resume from. */
+export const MAX_LOGS = 1000
+
+interface DecodedLog {
+  address: Address
+  blockHash: Hex | null
+  blockNumber: bigint | null
+  data: Hex
+  logIndex: number | null | undefined
+  topics: readonly Hex[]
+  transactionHash: Hex | null
+  transactionIndex: number | null | undefined
+  eventName: string
+  args: unknown
+}
+
+function serializeLog(log: DecodedLog) {
+  return {
+    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,
+    decoded: { eventName: log.eventName, args: log.args }
+  }
+}
+
+/** Resuming from `nextBlock` may repeat logs of that block already returned. */
+export function capLogs(logs: DecodedLog[]) {
+  if (logs.length <= MAX_LOGS) return { logs: logs.map(serializeLog) }
+  return {
+    logs: logs.slice(0, MAX_LOGS).map(serializeLog),
+    truncated: true,
+    nextBlock: logs[MAX_LOGS]?.blockNumber?.toString()
+  }
+}
+
+/**
+ * The same range eth_getLogs would scan — each end defaults to the latest block — in
+ * Hypersync's terms, where `toBlock` is exclusive.
+ */
+export function hypersyncRange(fromBlock: string | undefined, toBlock: string | undefined, latest: number) {
+  return {
+    fromBlock: fromBlock ? Number(BigInt(fromBlock)) : latest,
+    toBlock: (toBlock ? Number(BigInt(toBlock)) : latest) + 1
+  }
+}
+
+/** One topic, or a list of alternatives for an OR filter. */
+export function toTopics(value: unknown): Hex | Hex[] {
+  return Array.isArray(value) ? value.map(toTopic) : toTopic(value)
+}
+
 async function getLogsWithHypersync(
   chainName: ChainName,
-  eventAbi: string,
+  abiItem: AbiEvent,
   hypersyncApiKey?: string,
   address?: string,
   fromBlock?: string,
   toBlock?: string,
   eventArgs?: Record<string, unknown>
-) {
+): Promise<DecodedLog[]> {
   const hypersyncUrl = getClientManager().getHypersyncUrl(chainName)
   if (!hypersyncUrl) {
     throw new Error(`Hypersync not supported for chain: ${chainName}`)
@@ -53,25 +109,26 @@ async function getLogsWithHypersync(
     bearerToken: hypersyncApiKey
   })
 
-  const abiItem = parseAbiItem(eventAbi) as AbiEvent
-  const eventSignature = toEventSignature(abiItem)
-  const topic0 = keccak256(toBytes(eventSignature))
+  const topic0 = keccak256(toBytes(toEventSignature(abiItem)))
 
   // Build topics array for filtering
-  const topics: (string | string[] | null)[] = [topic0]
+  const topics: (Hex | Hex[] | null)[] = [topic0]
 
   // Add indexed parameter filtering if eventArgs provided
-  if (eventArgs && Object.keys(eventArgs).length > 0) {
+  if (eventArgs) {
     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))
+      topics.push(argValue === undefined ? null : toTopics(argValue))
     }
   }
 
+  const latest = fromBlock && toBlock ? 0 : await client.getHeight()
+  const range = hypersyncRange(fromBlock, toBlock, latest)
+
   const query = {
     fieldSelection: {
       log: [
@@ -88,8 +145,7 @@ async function getLogsWithHypersync(
         LogField.LogIndex
       ]
     },
-    fromBlock: fromBlock ? Number.parseInt(fromBlock, 10) : 0,
-    toBlock: toBlock ? Number.parseInt(toBlock, 10) : undefined,
+    ...range,
     logs: [
       {
         address: address ? [address] : undefined,
@@ -100,11 +156,17 @@ async function getLogsWithHypersync(
     ]
   }
 
-  const res = await client.get(query)
+  // One response covers only part of a long range; `nextBlock` says where it stopped.
+  const logs: Log[] = []
+  for (let from = range.fromBlock; from < range.toBlock && logs.length <= MAX_LOGS; ) {
+    const res = await client.get({ ...query, fromBlock: from })
+    logs.push(...res.data.logs)
+    if (res.nextBlock <= from) break
+    from = res.nextBlock
+  }
 
-  // Convert hypersync logs to viem-compatible format
-  const decodedLogs = res.data.logs
-    .map((log: Log) => {
+  return logs
+    .map((log: Log): DecodedLog | null => {
       const topics = log.topics.filter((topic): topic is string => Boolean(topic)) as [Hex, ...Hex[]]
       const data = (log.data ?? '0x') as Hex
 
@@ -113,7 +175,7 @@ async function getLogsWithHypersync(
         return {
           address: log.address as Address,
           blockHash: log.blockHash as Hex,
-          blockNumber: log.blockNumber ? BigInt(log.blockNumber) : 0n,
+          blockNumber: log.blockNumber !== undefined ? BigInt(log.blockNumber) : null,
           data,
           logIndex: log.logIndex,
           topics,
@@ -127,165 +189,91 @@ async function getLogsWithHypersync(
         return null
       }
     })
-    .filter((log): log is NonNullable<typeof log> => log !== null)
-
-  return decodedLogs
+    .filter((log): log is DecodedLog => log !== null)
 }
 
 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.',
+    `Search and decode contract events with filtering. Uses viem with hypersync fallback. Specify address and block ranges for best performance. Returns at most ${MAX_LOGS} logs; past that, truncated is true and nextBlock says where to resume.`,
     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)'),
+      fromBlock: z.string().optional().describe('Start block (defaults to the latest block)'),
+      toBlock: z.string().optional().describe('End block, inclusive (defaults to the latest block)'),
       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..."}')
+        .describe(
+          'Filter by indexed parameters: {"from": "0x123...", "to": "0x456..."}. A list matches any of its values: {"to": ["0x1...", "0x2..."]}'
+        )
     }),
     async (args) => {
       const clientManager = getClientManager()
-      const config = (clientManager as any).config
+      const chain = args.chain as ChainName
+      const abiItem = parseAbiItem(args.eventAbi) as AbiEvent
 
-      // 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
-          }
+      if (args.address && !isAddress(args.address)) {
+        throw new Error(`Invalid contract address: ${args.address}`)
+      }
 
-          return {
-            ...baseLogData,
-            decoded: {
-              eventName: log.eventName,
-              args: log.args
-            }
-          }
-        })
+      const eventArgs =
+        args.eventArgs && Object.keys(args.eventArgs).length > 0
+          ? convertEventArgsToTypes(args.eventArgs, abiItem.inputs)
+          : undefined
+      const fromBlockNum = args.fromBlock ? BigInt(args.fromBlock) : undefined
+      const toBlockNum = args.toBlock ? BigInt(args.toBlock) : undefined
 
+      const respond = (logs: DecodedLog[], dataSource: 'viem' | 'hypersync') => {
+        const capped = capLogs(logs)
         return formatResponse({
-          logs: serializedLogs,
+          ...capped,
           eventSignature: toEventSignature(abiItem),
           chain: args.chain,
           fromBlock: fromBlockNum?.toString() || 'latest',
           toBlock: toBlockNum?.toString() || 'latest',
-          count: logs.length,
-          dataSource: 'viem',
+          count: capped.logs.length,
+          dataSource,
           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
-                }
-              }
-            })
+      try {
+        const logs = await clientManager.getClient(chain).getLogs({
+          address: args.address as Address | undefined,
+          event: abiItem,
+          args: eventArgs,
+          fromBlock: fromBlockNum,
+          toBlock: toBlockNum
+        })
+        return respond(logs as DecodedLog[], 'viem')
+      } catch (viemError) {
+        if (!clientManager.getHypersyncUrl(chain)) {
+          throw new Error(`Failed to get logs with viem (hypersync not available for ${args.chain}): ${rpcReason(viemError)}`)
+        }
+        console.warn(`Viem getLogs failed for ${args.chain}, trying hypersync fallback: ${rpcReason(viemError)}`)
 
-            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}`)
+        try {
+          const logs = await getLogsWithHypersync(
+            chain,
+            abiItem,
+            clientManager.getConfig().hypersyncApiKey,
+            args.address,
+            args.fromBlock,
+            args.toBlock,
+            eventArgs
+          )
+          return respond(logs, 'hypersync')
+        } catch (hypersyncError) {
+          throw new Error(
+            `Both viem and hypersync failed. Viem error: ${rpcReason(viemError)}. Hypersync error: ${rpcReason(hypersyncError)}`
+          )
         }
       }
     }

package/src/tools/read/signatures.ts

@@ -1,7 +1,6 @@
 import {
   type AbiEvent,
   type AbiFunction,
-  type AbiParameter,
   encodeFunctionData,
   keccak256,
   parseAbiItem,
@@ -11,7 +10,7 @@ import {
 } from 'viem'
 import { z } from 'zod'
 import type { AbiError } from '../../types.js'
-import { createTool, formatResponse } from '../../utils.js'
+import { convertArgumentsToTypes, createTool, formatResponse } from '../../utils.js'
 
 const FunctionAbiSchema = z.object({
   functionAbi: z.string().describe('Function ABI definition (e.g., "function transfer(address to, uint256 amount)")')
@@ -92,7 +91,8 @@ export default {
     async (args) => {
       const results = args.items.map((item) => {
         const abiItem = parseAbiItem(item.errorAbi) as AbiError
-        const signature = `${abiItem.name}(${abiItem.inputs.map((input: AbiParameter) => input.type).join(',')})`
+        // Formatted as a function, which an error's signature is; viem keeps an "error " prefix otherwise.
+        const signature = toFunctionSignature({ ...abiItem, type: 'function', outputs: [], stateMutability: 'nonpayable' })
         const hash = keccak256(toBytes(signature))
         const selector = hash.slice(0, 10)
 
@@ -125,7 +125,7 @@ export default {
       const data = encodeFunctionData({
         abi: [abiItem],
         functionName: abiItem.name,
-        args: args.args as readonly unknown[]
+        args: convertArgumentsToTypes(args.args, abiItem.inputs)
       })
 
       return formatResponse({