ethereum-tools

Implementation Reference

• tools/token-analysis.js:13-41 (registration)

  Registration of the getTokenInfo MCP tool, including input schema (address, networkId) and inline async handler that fetches data from API and formats response.

  server.tool("getTokenInfo",
    { 
      address: z.string().min(1, "Token address is required"),
      networkId: z.number().int().positive().default(1).describe("Network ID (1 for Ethereum, 101 for Solana)")
    },
    async ({ address, networkId }) => {
      try {
        // Get token info from Codex API
        const tokenInfo = await fetchTokenInfo(address, networkId);
        
        if (!tokenInfo) {
          return {
            content: [{ type: "text", text: `No token information found for ${address} on network ${networkId}` }]
          };
        }
        
        // Format the token info for display
        const response = formatTokenInfoResponse(tokenInfo);
        
        return {
          content: [{ type: "text", text: response }]
        };
      } catch (error) {
        return {
          content: [{ type: "text", text: `Error fetching token info: ${error.message}` }]
        };
      }
    }
  );

• tools/token-analysis.js:14-17 (schema)

  Zod input schema for getTokenInfo tool parameters.

  { 
    address: z.string().min(1, "Token address is required"),
    networkId: z.number().int().positive().default(1).describe("Network ID (1 for Ethereum, 101 for Solana)")
  },

• tools/token-analysis.js:18-40 (handler)

  Inline handler function for executing getTokenInfo tool logic: fetches token info, handles errors, formats and returns text response.

  async ({ address, networkId }) => {
    try {
      // Get token info from Codex API
      const tokenInfo = await fetchTokenInfo(address, networkId);
      
      if (!tokenInfo) {
        return {
          content: [{ type: "text", text: `No token information found for ${address} on network ${networkId}` }]
        };
      }
      
      // Format the token info for display
      const response = formatTokenInfoResponse(tokenInfo);
      
      return {
        content: [{ type: "text", text: response }]
      };
    } catch (error) {
      return {
        content: [{ type: "text", text: `Error fetching token info: ${error.message}` }]
      };
    }
  }

• tools/token-analysis.js:125-162 (helper)

  Core helper function that performs GraphQL query to Codex API for getTokenInfo data.

  async function fetchTokenInfo(address, networkId) {
    try {
      // Use API key from environment variable
      const apiKey = process.env.CODEX_API_KEY;
      if (!apiKey) {
        throw new Error("CODEX_API_KEY environment variable is not set");
      }
      
      const response = await axios({
        url: API_URL,
        method: 'post',
        headers: {
          'Content-Type': 'application/json',
          'Authorization': apiKey
        },
        data: {
          query: `{
            getTokenInfo(address: "${address}", networkId: ${networkId}) {
              name
              symbol
              totalSupply
              address
              circulatingSupply
            }
          }`
        }
      });
      
      if (response.data && response.data.data && response.data.data.getTokenInfo) {
        return response.data.data.getTokenInfo;
      }
      
      return null;
    } catch (error) {
      console.error('Error fetching token info:', error.response?.data || error.message);
      throw new Error(`API error: ${error.response?.data?.errors?.[0]?.message || error.message}`);
    }
  }

• tools/token-analysis.js:272-292 (helper)

  Helper function to format the raw token info into a readable text response.

  function formatTokenInfoResponse(info) {
    let response = `=== Token Information ===\n`;
    response += `Name: ${info.name || 'N/A'}\n`;
    response += `Symbol: ${info.symbol || 'N/A'}\n`;
    response += `Address: ${info.address || 'N/A'}\n`;
    response += `Total Supply: ${info.totalSupply || 'N/A'}\n`;
    response += `Circulating Supply: ${info.circulatingSupply || 'N/A'}\n`;
    
    // Calculate additional metrics if possible
    if (info.totalSupply && info.circulatingSupply) {
      const totalSupply = parseFloat(info.totalSupply);
      const circulatingSupply = parseFloat(info.circulatingSupply);
      
      if (!isNaN(totalSupply) && !isNaN(circulatingSupply) && totalSupply > 0) {
        const circulationPercentage = (circulatingSupply / totalSupply) * 100;
        response += `Circulation Percentage: ${circulationPercentage.toFixed(2)}%\n`;
      }
    }
    
    return response;
  }