EVM MCP Server

Instructions

Implementation Reference

• src/index.ts:301-347 (handler)

  The async handler function that performs the RPC call to eth_getBlockByNumber, processes the block information, and formats the response using helpers.

  async ({ blockNumber, includeTransactions }) => {
    try {
      const result = await makeRPCCall("eth_getBlockByNumber", [
        blockNumber,
        includeTransactions,
      ]);
      if (!result) {
        return {
          content: [
            {
              type: "text",
              text: `Block not found: ${blockNumber}`,
            },
          ],
        };
      }
  
      const blockInfo = {
        number: result.number,
        hash: result.hash,
        parentHash: result.parentHash,
        timestamp: result.timestamp,
        gasLimit: result.gasLimit,
        gasUsed: result.gasUsed,
        transactionCount: result.transactions.length,
        baseFeePerGas: result.baseFeePerGas,
      };
  
      return {
        content: [
          {
            type: "text",
            text: formatResponse(blockInfo, "Block Information"),
          },
        ],
      };
    } catch (error: any) {
      return {
        content: [
          {
            type: "text",
            text: `Error: ${error.message}`,
          },
        ],
      };
    }
  },

• src/index.ts:291-300 (schema)

  Zod schema defining the input parameters: blockNumber (string) and optional includeTransactions (boolean, default false).

  {
    blockNumber: z
      .string()
      .describe("Block number (hex) or 'latest', 'earliest', 'pending'"),
    includeTransactions: z
      .boolean()
      .optional()
      .default(false)
      .describe("Include full transaction objects"),
  },

• src/index.ts:288-348 (registration)

  The server.tool registration that defines the tool name, description, schema, and handler function.

  server.tool(
    "eth_getBlockByNumber",
    "Returns information about a block by block number",
    {
      blockNumber: z
        .string()
        .describe("Block number (hex) or 'latest', 'earliest', 'pending'"),
      includeTransactions: z
        .boolean()
        .optional()
        .default(false)
        .describe("Include full transaction objects"),
    },
    async ({ blockNumber, includeTransactions }) => {
      try {
        const result = await makeRPCCall("eth_getBlockByNumber", [
          blockNumber,
          includeTransactions,
        ]);
        if (!result) {
          return {
            content: [
              {
                type: "text",
                text: `Block not found: ${blockNumber}`,
              },
            ],
          };
        }
  
        const blockInfo = {
          number: result.number,
          hash: result.hash,
          parentHash: result.parentHash,
          timestamp: result.timestamp,
          gasLimit: result.gasLimit,
          gasUsed: result.gasUsed,
          transactionCount: result.transactions.length,
          baseFeePerGas: result.baseFeePerGas,
        };
  
        return {
          content: [
            {
              type: "text",
              text: formatResponse(blockInfo, "Block Information"),
            },
          ],
        };
      } catch (error: any) {
        return {
          content: [
            {
              type: "text",
              text: `Error: ${error.message}`,
            },
          ],
        };
      }
    },
  );

• src/index.ts:89-96 (helper)

  Generic helper function used to make RPC calls to the Ethereum provider, invoked within the handler.

  async function makeRPCCall(method: string, params: any[] = []): Promise<any> {
    try {
      const result = await provider.send(method, params);
      return result;
    } catch (error: any) {
      throw new Error(`RPC call failed: ${error.message}`);
    }
  }

• src/index.ts:32-57 (helper)

  Helper function to format the response data into a markdown-friendly string, used in the handler.

  function formatResponse(data: any, title: string): string {
    let result = `**${title}**\n\n`;
  
    if (typeof data === "object" && data !== null) {
      if (Array.isArray(data)) {
        // Handle arrays
        result += `**Count:** ${data.length}\n\n`;
        data.forEach((item, index) => {
          result += `**${index + 1}.**\n`;
          if (typeof item === "object" && item !== null) {
            result += formatObject(item, "  ");
          } else {
            result += `  ${item}\n`;
          }
          result += "\n";
        });
      } else {
        // Handle objects
        result += formatObject(data, "");
      }
    } else {
      result += `${data}\n`;
    }
  
    return result;
  }