get_domain_records

Fetch ENS text records for a domain to retrieve associated data like avatar, email, URL, and social profiles using Grove's blockchain data access.

Instructions

Get ENS text records for a domain (e.g., avatar, email, url, twitter, github)

Input Schema

TableJSON Schema

Name	Required	Description	Default
`domain`	Yes	ENS domain name
`keys`	Yes	Text record keys to fetch (e.g., ["avatar", "email", "url", "com.twitter", "com.github"])

Implementation Reference

src/handlers/domain-handlers.ts:43-61 (registration)

Tool registration object defining the 'get_domain_records' tool, including its name, description, and input schema for domain and keys.

{
  name: 'get_domain_records',
  description: 'Get ENS text records for a domain (e.g., avatar, email, url, twitter, github)',
  inputSchema: {
    type: 'object',
    properties: {
      domain: {
        type: 'string',
        description: 'ENS domain name',
      },
      keys: {
        type: 'array',
        items: { type: 'string' },
        description: 'Text record keys to fetch (e.g., ["avatar", "email", "url", "com.twitter", "com.github"])',
      },
    },
    required: ['domain', 'keys'],
  },
},

src/handlers/domain-handlers.ts:111-126 (handler)

Handler case in handleDomainTool function that parses input arguments and delegates execution to DomainResolverService.getDomainRecords, formats the result as MCP response.

case 'get_domain_records': {
  const domain = args?.domain as string;
  const keys = args?.keys as string[];

  const result = await domainResolver.getDomainRecords(domain, keys);

  return {
    content: [
      {
        type: 'text',
        text: JSON.stringify(result, null, 2),
      },
    ],
    isError: !result.success,
  };
}

src/services/domain-resolver.ts:219-300 (helper)

Core helper function implementing ENS text record retrieval: computes namehash, fetches resolver from ENS registry, performs parallel eth_call to resolver.text() for each key, decodes values.

async getDomainRecords(domain: string, keys: string[]): Promise<EndpointResponse> {
  if (!domain.endsWith('.eth')) {
    return {
      success: false,
      error: 'Domain records currently only supported for ENS (.eth) domains',
    };
  }

  try {
    const namehash = this.namehash(domain);

    // Get resolver address first
    const resolverData = this.encodeResolverCall(namehash);
    const resolverResult = await this.blockchainService.callRPCMethod(
      'ethereum-mainnet',
      'eth_call',
      [
        {
          to: DomainResolverService.ENS_REGISTRY,
          data: resolverData,
        },
        'latest',
      ]
    );

    if (!resolverResult.success || !resolverResult.data) {
      return {
        success: false,
        error: `Failed to get resolver for ${domain}`,
      };
    }

    const resolverAddress = '0x' + resolverResult.data.slice(-40);

    if (resolverAddress === '0x0000000000000000000000000000000000000000') {
      return {
        success: false,
        error: `No resolver set for ${domain}`,
      };
    }

    // Fetch all text records in parallel
    const records = await Promise.all(
      keys.map(async (key) => {
        const textData = this.encodeTextCall(namehash, key);
        const result = await this.blockchainService.callRPCMethod(
          'ethereum-mainnet',
          'eth_call',
          [
            {
              to: resolverAddress,
              data: textData,
            },
            'latest',
          ]
        );

        return {
          key,
          value: result.success ? this.decodeString(result.data) : null,
        };
      })
    );

    return {
      success: true,
      data: {
        domain,
        records,
      },
      metadata: {
        timestamp: new Date().toISOString(),
        endpoint: 'ethereum-mainnet',
      },
    };
  } catch (error) {
    return {
      success: false,
      error: error instanceof Error ? error.message : 'Failed to fetch domain records',
    };
  }
}

src/index.ts:88-101 (registration)

Main server initialization collects all tools including domain tools via registerDomainHandlers and uses the list for ListToolsRequestHandler.

const tools: Tool[] = [
  ...registerBlockchainHandlers(server, blockchainService),
  ...registerDomainHandlers(server, domainResolver),
  ...registerTransactionHandlers(server, advancedBlockchain),
  ...registerTokenHandlers(server, advancedBlockchain),
  ...registerMultichainHandlers(server, advancedBlockchain),
  ...registerContractHandlers(server, advancedBlockchain),
  ...registerUtilityHandlers(server, advancedBlockchain),
  ...registerEndpointHandlers(server, endpointManager),
  ...registerSolanaHandlers(server, solanaService),
  ...registerCosmosHandlers(server, cosmosService),
  ...registerSuiHandlers(server, suiService),
  ...registerDocsHandlers(server, docsManager),
];

src/index.ts:114-127 (handler)

Top-level CallToolRequestHandler dispatches tool execution to specific handlers including handleDomainTool for domain tools.

let result =
  (await handleBlockchainTool(name, args, blockchainService)) ||
  (await handleDomainTool(name, args, domainResolver)) ||
  (await handleTransactionTool(name, args, advancedBlockchain)) ||
  (await handleTokenTool(name, args, advancedBlockchain)) ||
  (await handleMultichainTool(name, args, advancedBlockchain)) ||
  (await handleContractTool(name, args, advancedBlockchain)) ||
  (await handleUtilityTool(name, args, advancedBlockchain)) ||
  (await handleEndpointTool(name, args, endpointManager)) ||
  (await handleSolanaTool(name, args, solanaService)) ||
  (await handleCosmosTool(name, args, cosmosService)) ||
  (await handleSuiTool(name, args, suiService)) ||
  (await handleDocsTool(name, args, docsManager));

Grove's MCP Server for Pocket Network