search_addresses_json

Instructions

Implementation Reference

• index.js:690-691 (handler)

  The handler case within the handleToolCall switch statement that dispatches the tool call to the ChainFETCH API endpoint for JSON-based address searching.

  case 'search_addresses_json':
    return await this.makeRequest('/api/v1/ethereum/addresses/json_search', 'GET', args, null, token);

• index.js:63-106 (schema)

  The input schema defining all parameters for the JSON search tool, supporting comprehensive filtering with parameters like ETH balance ranges, contract status, transaction counts, pagination, etc.

  inputSchema: {
    type: 'object',
    properties: {
      eth_balance_min: {
        type: 'string',
        description: 'Minimum ETH balance (in ETH, e.g., "1.5")',
      },
      eth_balance_max: {
        type: 'string',
        description: 'Maximum ETH balance (in ETH, e.g., "10.0")',
      },
      is_contract: {
        type: 'boolean',
        description: 'Whether the address is a contract',
      },
      is_verified: {
        type: 'boolean',
        description: 'Whether the address is verified',
      },
      has_token_transfers: {
        type: 'boolean',
        description: 'Whether the address has token transfers',
      },
      transactions_count_min: {
        type: 'integer',
        description: 'Minimum transactions count',
      },
      transactions_count_max: {
        type: 'integer',
        description: 'Maximum transactions count',
      },
      limit: {
        type: 'integer',
        description: 'Number of results to return (default: 10, max: 50)',
        default: 10,
      },
      offset: {
        type: 'integer',
        description: 'Number of results to skip for pagination (default: 0)',
        default: 0,
      },
    },
    required: [],
  },

• index.js:60-107 (registration)

  Registration of the tool in the listTools response, including name, description, and full input schema.

  {
    name: 'search_addresses_json',
    description: 'JSON search for addresses with 150+ parameters for comprehensive filtering',
    inputSchema: {
      type: 'object',
      properties: {
        eth_balance_min: {
          type: 'string',
          description: 'Minimum ETH balance (in ETH, e.g., "1.5")',
        },
        eth_balance_max: {
          type: 'string',
          description: 'Maximum ETH balance (in ETH, e.g., "10.0")',
        },
        is_contract: {
          type: 'boolean',
          description: 'Whether the address is a contract',
        },
        is_verified: {
          type: 'boolean',
          description: 'Whether the address is verified',
        },
        has_token_transfers: {
          type: 'boolean',
          description: 'Whether the address has token transfers',
        },
        transactions_count_min: {
          type: 'integer',
          description: 'Minimum transactions count',
        },
        transactions_count_max: {
          type: 'integer',
          description: 'Maximum transactions count',
        },
        limit: {
          type: 'integer',
          description: 'Number of results to return (default: 10, max: 50)',
          default: 10,
        },
        offset: {
          type: 'integer',
          description: 'Number of results to skip for pagination (default: 0)',
          default: 0,
        },
      },
      required: [],
    },
  },

• index.js:634-682 (helper)

  Shared helper method that performs authenticated HTTP requests to the ChainFETCH API, handling query parameters, authentication, and error handling. This is the core logic executed for the tool.

  async makeRequest(endpoint, method = 'GET', params = {}, body = null, token = null) {
    const chainfetchToken = token || process.env.CHAINFETCH_API_TOKEN;
    
    if (!chainfetchToken) {
      throw new McpError(
        ErrorCode.InvalidRequest,
        'CHAINFETCH_API_TOKEN is required'
      );
    }
  
    const url = new URL(`${API_BASE_URL}${endpoint}`);
    
    // Add query parameters for GET requests
    if (method === 'GET' && Object.keys(params).length > 0) {
      Object.entries(params).forEach(([key, value]) => {
        if (value !== undefined && value !== null) {
          if (Array.isArray(value)) {
            value.forEach(v => url.searchParams.append(`${key}[]`, v));
          } else {
            url.searchParams.append(key, value.toString());
          }
        }
      });
    }
  
    const fetchOptions = {
      method,
      headers: {
        'Authorization': `Bearer ${chainfetchToken}`,
        'Content-Type': 'application/json',
      },
    };
  
    if (body && method !== 'GET') {
      fetchOptions.body = JSON.stringify(body);
    }
  
    const response = await fetch(url.toString(), fetchOptions);
    
    if (!response.ok) {
      const errorText = await response.text();
      throw new McpError(
        ErrorCode.InternalError,
        `API request failed: ${response.status} ${response.statusText} - ${errorText}`
      );
    }
  
    return await response.json();
  }