DNS Resolvers

ENS1 dnstxt.ens.eth <context>

contract DNSTXTResolver is ERC165, IERC7996, IExtendedDNSResolver {
    function resolve(
        bytes calldata /* name */,
        bytes calldata data,
        bytes calldata context
    ) external view returns (bytes memory result)
}

// Context from TXT record
bytes memory context = "a[60]=0x1234567890123456789012345678901234567890 t[avatar]=https://example.com/avatar.png";

// Query for address
bytes memory query = abi.encodeCall(
    IAddrResolver.addr,
    (bytes32(0)) // node doesn't matter, data is in context
);

bytes memory result = dnsResolver.resolve("", query, context);
address ethAddr = abi.decode(result, (address));
// ethAddr == 0x1234567890123456789012345678901234567890

error UnsupportedResolverProfile(bytes4 selector);
error InvalidHexData(bytes data);
error InvalidDataLength(bytes data, uint256 expected);

ENS1 <resolver-address> <context>

constructor(
    IRegistry rootRegistry,
    IGatewayProvider batchGatewayProvider
)

function resolve(
    bytes calldata name,
    bytes calldata data,
    bytes calldata context
) external view returns (bytes memory)

function rewriteNameWithContext(
    bytes calldata name,
    bytes calldata context
) public pure returns (bytes memory)

// Rewrite rule: "com" -> "base.eth"
bytes memory name = dnsEncode("alice.nick.com");
bytes memory context = "com base.eth";

bytes memory newName = aliasResolver.rewriteNameWithContext(name, context);
// newName == dnsEncode("alice.nick.base.eth")

// Replace rule: "notdot.net" -> "nick.eth"
bytes memory name = dnsEncode("notdot.net");
bytes memory context = "nick.eth";

bytes memory newName = aliasResolver.rewriteNameWithContext(name, context);
// newName == dnsEncode("nick.eth")

error NoSuffixMatch(bytes name, bytes suffix);

constructor(
    ENS ensRegistryV1,
    address dnsTLDResolverV1,
    IRegistry rootRegistry,
    DNSSEC dnssecOracle,
    IGatewayProvider oracleGatewayProvider,
    IGatewayProvider batchGatewayProvider
)

function resolve(
    bytes calldata name,
    bytes calldata data
) external view returns (bytes memory)

function getDNSSECRecords(
    bytes calldata name
) external view returns (bytes[] memory)

// Using ethers.js with CCIP-Read support
const records = await dnsTLDResolver.getDNSSECRecords(
  dnsEncode('example.com')
);

records.forEach(record => {
  console.log('TXT record:', Buffer.from(record).toString());
});

function parseDNSSECRecord(
    bytes memory txt
) public view returns (
    address resolver,
    bytes memory context
)

// Parse address literal
bytes memory txt = "ENS1 0x1234567890123456789012345678901234567890 context data";
(address resolver, bytes memory context) = dnsTLD.parseDNSSECRecord(txt);
// resolver = 0x1234567890123456789012345678901234567890
// context = "context data"

// Parse ENS name
bytes memory txt = "ENS1 dnstxt.ens.eth a[60]=0x...";
(address resolver, bytes memory context) = dnsTLD.parseDNSSECRecord(txt);
// resolver = address resolved from dnstxt.ens.eth
// context = "a[60]=0x..."

function requiresOffchain(bytes calldata name) external view returns (bool)

function getResolver(bytes calldata name) external view returns (address, bool)

function verifierMetadata(bytes calldata name) external view returns (
    address verifier,
    string[] memory gateways
)

error InvalidTXT();

; Zone file for example.com
example.com.  IN  TXT  "ENS1 dnstxt.ens.eth a[60]=0x1234567890123456789012345678901234567890 t[com.twitter]=alice"

; DNSSEC signatures (managed by DNS provider)
example.com.  IN  RRSIG  TXT ...

import {DNSTLDResolver} from "./dns/DNSTLDResolver.sol";
import {IAddrResolver} from "@ens/contracts/resolvers/profiles/IAddrResolver.sol";

contract DNSIntegration {
    DNSTLDResolver public dnsResolver;
    
    constructor(DNSTLDResolver _dnsResolver) {
        dnsResolver = _dnsResolver;
    }
    
    // Resolve using CCIP-Read
    function resolveAddress(string memory domain) external view returns (address) {
        bytes memory name = dnsEncode(domain);
        bytes memory query = abi.encodeCall(
            IAddrResolver.addr,
            (bytes32(0)) // node computed by resolver
        );
        
        bytes memory result = dnsResolver.resolve(name, query);
        return abi.decode(result, (address));
    }
}

import { ethers } from 'ethers';

// Provider must support CCIP-Read (most modern providers do)
const provider = new ethers.JsonRpcProvider(RPC_URL);

const dnsTLD = new ethers.Contract(
  DNS_TLD_RESOLVER_ADDRESS,
  DNS_TLD_RESOLVER_ABI,
  provider
);

// Resolve example.com
const name = dnsEncode('example.com');
const query = dnsTLD.interface.encodeFunctionData('addr', [ethers.ZeroHash]);

try {
  const result = await dnsTLD.resolve(name, query);
  const address = ethers.AbiCoder.defaultAbiCoder().decode(['address'], result)[0];
  console.log('Resolved address:', address);
} catch (error) {
  if (error.code === 'CALL_EXCEPTION') {
    // CCIP-Read in progress
    console.log('Fetching off-chain data...');
  }
}

<records> ::= " "* <rr>* " "*
     <rr> ::= <r> | <r> <rr>
      <r> ::= <pk> | <kv>
     <pk> ::= <u> | <u> "[" <a> "]" <u>
     <kv> ::= <k> "=" <v>
      <k> ::= <u> | <u> "[" <a> "]"
      <v> ::= "'" <q> "'" | <u>
      <q> ::= <all octets except "'" unless preceded by "\">
      <u> ::= <all octets except " ">
      <a> ::= <all octets except "]">