web3-tools-mcp 1.2.3 → 1.3.1

package/src/client.ts

@@ -1,5 +1,19 @@
 import { http, createPublicClient } from 'viem'
-import { arbitrum, base, celo, localhost, mainnet, optimism, polygon } from 'viem/chains'
+import {
+  arbitrum,
+  avalanche,
+  base,
+  bsc,
+  gnosis,
+  linea,
+  localhost,
+  mainnet,
+  optimism,
+  polygon,
+  sonic,
+  unichain,
+  zksync
+} from 'viem/chains'
 import type { ChainName, Config } from './types.js'
 
 // Enhanced RPC configuration with API keys
@@ -31,7 +45,7 @@ function getRpcUrl(chainName: string, config: Config): string {
       ? `https://polygon-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
       : config.infuraApiKey
         ? `https://polygon-mainnet.infura.io/v3/${config.infuraApiKey}`
-        : 'https://polygon-rpc.com/',
+        : 'https://polygon-rpc.com',
 
     optimism: config.alchemyApiKey
       ? `https://opt-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
@@ -39,7 +53,44 @@ function getRpcUrl(chainName: string, config: Config): string {
         ? `https://optimism-mainnet.infura.io/v3/${config.infuraApiKey}`
         : 'https://mainnet.optimism.io',
 
-    celo: 'https://celo.drpc.org',
+    avalanche: config.alchemyApiKey
+      ? `https://avax-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
+      : config.infuraApiKey
+        ? `https://avalanche-mainnet.infura.io/v3/${config.infuraApiKey}`
+        : 'https://api.avax.network/ext/bc/C/rpc',
+
+    bnb: config.alchemyApiKey
+      ? `https://bnb-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
+      : config.infuraApiKey
+        ? `https://bsc-mainnet.infura.io/v3/${config.infuraApiKey}`
+        : 'https://bsc-dataseed.bnbchain.org',
+
+    gnosis: config.alchemyApiKey
+      ? `https://gnosis-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
+      : 'https://rpc.gnosischain.com',
+
+    sonic: config.alchemyApiKey
+      ? `https://sonic-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
+      : 'https://rpc.soniclabs.com',
+
+    zksync: config.alchemyApiKey
+      ? `https://zksync-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
+      : config.infuraApiKey
+        ? `https://zksync-mainnet.infura.io/v3/${config.infuraApiKey}`
+        : 'https://mainnet.era.zksync.io',
+
+    linea: config.alchemyApiKey
+      ? `https://linea-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
+      : config.infuraApiKey
+        ? `https://linea-mainnet.infura.io/v3/${config.infuraApiKey}`
+        : 'https://rpc.linea.build',
+
+    unichain: config.alchemyApiKey
+      ? `https://unichain-mainnet.g.alchemy.com/v2/${config.alchemyApiKey}`
+      : config.infuraApiKey
+        ? `https://unichain-mainnet.infura.io/v3/${config.infuraApiKey}`
+        : 'https://sepolia.unichain.org',
+
     localhost: 'http://localhost:8545'
   }
 
@@ -78,10 +129,46 @@ export const CHAINS = (config: Config) => ({
       return getRpcUrl('optimism', config)
     }
   },
-  celo: {
-    chain: celo,
+  avalanche: {
+    chain: avalanche,
+    get rpc() {
+      return getRpcUrl('avalanche', config)
+    }
+  },
+  bnb: {
+    chain: bsc,
+    get rpc() {
+      return getRpcUrl('bnb', config)
+    }
+  },
+  gnosis: {
+    chain: gnosis,
+    get rpc() {
+      return getRpcUrl('gnosis', config)
+    }
+  },
+  sonic: {
+    chain: sonic,
+    get rpc() {
+      return getRpcUrl('sonic', config)
+    }
+  },
+  zksync: {
+    chain: zksync,
+    get rpc() {
+      return getRpcUrl('zksync', config)
+    }
+  },
+  linea: {
+    chain: linea,
+    get rpc() {
+      return getRpcUrl('linea', config)
+    }
+  },
+  unichain: {
+    chain: unichain,
     get rpc() {
-      return getRpcUrl('celo', config)
+      return getRpcUrl('unichain', config)
     }
   },
   localhost: {
@@ -94,15 +181,36 @@ export const CHAINS = (config: Config) => ({
 
 // Hypersync URLs for supported chains (localhost is not supported)
 export const HYPERSYNC_URLS: Partial<Record<ChainName, string>> = {
-  base: 'https://base.hypersync.xyz',
-  arbitrum: 'https://arbitrum.hypersync.xyz',
-  mainnet: 'https://eth.hypersync.xyz',
-  polygon: 'https://polygon.hypersync.xyz',
-  optimism: 'https://optimism.hypersync.xyz'
-  // celo and localhost are not supported by hypersync
+  mainnet: 'https://eth.hypersync.xyz', // Chain ID 1
+  arbitrum: 'https://arbitrum.hypersync.xyz', // Chain ID 42161
+  avalanche: 'https://avalanche.hypersync.xyz', // Chain ID 43114
+  base: 'https://base.hypersync.xyz', // Chain ID 8453
+  bnb: 'https://bsc.hypersync.xyz', // Chain ID 56
+  gnosis: 'https://gnosis.hypersync.xyz', // Chain ID 100
+  sonic: 'https://sonic.hypersync.xyz', // Chain ID 146
+  optimism: 'https://optimism.hypersync.xyz', // Chain ID 10
+  polygon: 'https://polygon.hypersync.xyz', // Chain ID 137
+  zksync: 'https://zksync.hypersync.xyz', // Chain ID 324
+  linea: 'https://linea.hypersync.xyz', // Chain ID 59144
+  unichain: 'https://unichain.hypersync.xyz' // Chain ID 130
+  // localhost is not supported by hypersync
 }
 
-export const SUPPORTED_CHAINS = ['mainnet', 'base', 'arbitrum', 'polygon', 'optimism', 'celo', 'localhost'] as const
+export const SUPPORTED_CHAINS = [
+  'mainnet',
+  'arbitrum',
+  'avalanche',
+  'base',
+  'bnb',
+  'gnosis',
+  'sonic',
+  'optimism',
+  'polygon',
+  'zksync',
+  'linea',
+  'unichain',
+  'localhost'
+] as const
 
 // Client manager
 export class ClientManager {
@@ -137,7 +245,13 @@ export class ClientManager {
       arbitrum: 'arbiscan.io',
       polygon: 'polygonscan.com',
       optimism: 'optimistic.etherscan.io',
-      celo: 'celoscan.io',
+      avalanche: 'snowtrace.io',
+      bnb: 'bscscan.com',
+      gnosis: 'gnosisscan.io',
+      sonic: 'sonicscan.org',
+      zksync: 'era.zksync.network',
+      linea: 'lineascan.build',
+      unichain: 'uniscan.xyz',
       localhost: 'etherscan.io'
     }
     return domains[chainName] || 'etherscan.io'

package/src/index.ts

@@ -35,7 +35,7 @@ ENVIRONMENT VARIABLES:
   HYPERSYNC_API_KEY             Alternative to --hypersync-api-key
 
 SUPPORTED CHAINS:
-  mainnet, base, arbitrum, polygon, optimism, celo, localhost
+  mainnet, arbitrum, avalanche, base, bnb, gnosis, sonic, optimism, polygon, zksync, linea, unichain, localhost
 
 EXAMPLES:
   # Use with npx (recommended)

package/src/tools/gas.ts

@@ -0,0 +1,267 @@
+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";
+
+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);
+
+      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,
+          });
+        }
+
+        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}`);
+      }
+    }
+  ),
+
+  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);
+
+      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(),
+          },
+        };
+
+        // 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);
+      } catch (error) {
+        throw new Error(`Failed to get gas price: ${error}`);
+      }
+    }
+  ),
+};

package/src/tools/index.ts

@@ -6,6 +6,7 @@ import balanceTools from './balance.js'
 import contractTools from './contract.js'
 import contractInfoTools from './contract-info.js'
 import ensTools from './ens.js'
+import gasTools from './gas.js'
 import logTools from './logs.js'
 import signatureTools from './signatures.js'
 
@@ -16,7 +17,8 @@ const allToolDefinitions = {
   ...balanceTools,
   ...logTools,
   ...advancedTools,
-  ...ensTools
+  ...ensTools,
+  ...gasTools
 } as const
 
 // Register all tools with the MCP server

package/src/types.ts

@@ -17,7 +17,20 @@ export interface Config {
 }
 
 // Chain names
-export type ChainName = 'mainnet' | 'base' | 'arbitrum' | 'polygon' | 'optimism' | 'celo' | 'localhost'
+export type ChainName =
+  | 'mainnet'
+  | 'arbitrum'
+  | 'avalanche'
+  | 'base'
+  | 'bnb'
+  | 'gnosis'
+  | 'sonic'
+  | 'optimism'
+  | 'polygon'
+  | 'zksync'
+  | 'linea'
+  | 'unichain'
+  | 'localhost'
 
 // Tool handler result type
 export interface ToolResult {