get_domain_records

Instructions

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));