UniversalResolverV2

IRegistry public immutable ROOT_REGISTRY;

constructor(
    IRegistry root,
    IGatewayProvider batchGatewayProvider
)

function findResolver(
    bytes memory name
) public view returns (
    address resolver,
    bytes32 node,
    uint256 offset
)

// Resolve "alice.eth"
bytes memory name = hex"05616c696365036574680000"; // DNS-encoded "alice.eth"

(address resolver, bytes32 node, uint256 offset) = universalResolver.findResolver(name);

if (resolver != address(0)) {
    // Found a resolver for alice.eth or eth
    // Use it to query records
}

function findCanonicalName(
    IRegistry registry
) external view returns (bytes memory)

// Get canonical name for a registry
IRegistry ethRegistry = IRegistry(0x123...);
bytes memory canonicalName = universalResolver.findCanonicalName(ethRegistry);

if (canonicalName.length > 0) {
    // Registry is canonical and has a name
    // canonicalName might be DNS-encoded "eth"
}

function findCanonicalRegistry(
    bytes calldata name
) external view returns (IRegistry)

// Check if "alice.eth" points to a canonical registry
bytes memory name = hex"05616c696365036574680000";

IRegistry registry = universalResolver.findCanonicalRegistry(name);

if (address(registry) != address(0)) {
    // This is a canonical registry for alice.eth
    // The registry's canonical name equals "alice.eth"
}

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

// Get all registries for "sub.alice.eth"
bytes memory name = hex"037375620561616c696365036574680000";

IRegistry[] memory registries = universalResolver.findRegistries(name);

// Result array structure:
// [0] = registry for "sub.alice.eth" (or null if doesn't exist)
// [1] = registry for "alice.eth" (or null if doesn't exist)
// [2] = registry for "eth"
// [3] = root registry

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

contract MyContract {
    UniversalResolverV2 public resolver;
    
    function resolveAddress(bytes memory name) external view returns (address) {
        // Find the resolver for this name
        (address resolverAddr, bytes32 node,) = resolver.findResolver(name);
        
        if (resolverAddr == address(0)) {
            return address(0);
        }
        
        // Query the resolver for the address
        return IAddrResolver(resolverAddr).addr(node);
    }
}

import {IAddressResolver} from "@ens/contracts/resolvers/profiles/IAddressResolver.sol";

function resolveMultiChainAddress(
    bytes memory name,
    uint256 coinType
) external view returns (bytes memory) {
    (address resolverAddr, bytes32 node,) = universalResolver.findResolver(name);
    
    if (resolverAddr == address(0)) {
        return "";
    }
    
    return IAddressResolver(resolverAddr).addr(node, coinType);
}

function verifyCanonicalOwnership(
    bytes memory name,
    address expectedRegistry
) external view returns (bool) {
    IRegistry actualRegistry = universalResolver.findCanonicalRegistry(name);
    return address(actualRegistry) == expectedRegistry;
}