@towns-protocol/contracts 0.0.455 → 1.0.2

package/src/domains/facets/l1/L1ResolverFacet.sol

@@ -0,0 +1,100 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IExtendedResolver} from "@ensdomains/ens-contracts/resolvers/profiles/IExtendedResolver.sol";
+
+// libraries
+import {L1ResolverMod} from "./L1ResolverMod.sol";
+
+// contracts
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+
+contract L1ResolverFacet is IExtendedResolver, OwnableBase, Facet {
+    using L1ResolverMod for L1ResolverMod.Layout;
+
+    /// @notice Initializes the resolver with a gateway URL and signer
+    /// @param gatewayUrl The URL of the CCIP gateway
+    /// @param gatewaySigner The address of the gateway signer
+    function __L1Resolver_init(
+        string calldata gatewayUrl,
+        address gatewaySigner
+    ) external onlyInitializing {
+        _addInterface(type(IExtendedResolver).interfaceId);
+        __L1Resolver_init_unchained(gatewayUrl, gatewaySigner);
+    }
+
+    function __L1Resolver_init_unchained(
+        string calldata gatewayUrl,
+        address gatewaySigner
+    ) internal {
+        L1ResolverMod.Layout storage $ = L1ResolverMod.getStorage();
+        $.setGatewayURL(gatewayUrl);
+        $.setGatewaySigner(gatewaySigner);
+        $.setNameWrapper();
+    }
+
+    /// @notice Sets the L2 registry for a given node
+    /// @param node The node to set the L2 registry for
+    /// @param chainId The chain ID of the L2 registry
+    /// @param registryAddress The address of the L2 registry
+    function setL2Registry(bytes32 node, uint64 chainId, address registryAddress) external {
+        L1ResolverMod.getStorage().setL2Registry(node, chainId, registryAddress);
+    }
+
+    /// @notice Sets the gateway URL
+    /// @param gatewayUrl The URL of the CCIP gateway
+    function setGatewayURL(string calldata gatewayUrl) external onlyOwner {
+        L1ResolverMod.getStorage().setGatewayURL(gatewayUrl);
+    }
+
+    /// @notice Sets the gateway signer
+    /// @param gatewaySigner The address of the gateway signer
+    function setGatewaySigner(address gatewaySigner) external onlyOwner {
+        L1ResolverMod.getStorage().setGatewaySigner(gatewaySigner);
+    }
+
+    /// @inheritdoc IExtendedResolver
+    /// @dev Always reverts with OffchainLookup to trigger CCIP-Read
+    function resolve(
+        bytes calldata name,
+        bytes calldata data
+    ) external view returns (bytes memory) {
+        return L1ResolverMod.getStorage().resolve(name, data, this.resolveWithProof.selector);
+    }
+
+    /// @notice Callback for CCIP-Read to verify and return the resolved data
+    /// @param response The response from the gateway (result, expires, sig)
+    /// @param extraData The original request data for signature verification
+    /// @return The verified resolved data
+    function resolveWithProof(
+        bytes calldata response,
+        bytes calldata extraData
+    ) external view returns (bytes memory) {
+        return L1ResolverMod.getStorage().resolveWithProof(response, extraData);
+    }
+
+    /// @notice Returns the L2 registry for a given node
+    /// @param node The node to get the L2 registry for
+    /// @return chainId The chain ID of the L2 registry
+    /// @return registryAddress The address of the L2 registry
+    function getL2Registry(
+        bytes32 node
+    ) external view returns (uint64 chainId, address registryAddress) {
+        L1ResolverMod.L2Registry memory registry = L1ResolverMod.getStorage().registryByNode[node];
+        return (registry.chainId, registry.registryAddress);
+    }
+
+    /// @notice Returns the gateway signer address
+    /// @return The address of the gateway signer
+    function getGatewaySigner() external view returns (address) {
+        return L1ResolverMod.getStorage().gatewaySigner;
+    }
+
+    /// @notice Returns the gateway URL
+    /// @return The URL of the CCIP gateway
+    function getGatewayURL() external view returns (string memory) {
+        return L1ResolverMod.getStorage().gatewayUrl;
+    }
+}

package/src/domains/facets/l1/L1ResolverMod.sol

@@ -0,0 +1,245 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {INameWrapper} from "@ensdomains/ens-contracts/wrapper/INameWrapper.sol";
+import {IAddrResolver} from "@ensdomains/ens-contracts/resolvers/profiles/IAddrResolver.sol";
+import {IL1ResolverService} from "./IL1ResolverService.sol";
+
+// libraries
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {NameCoder} from "@ensdomains/ens-contracts/utils/NameCoder.sol";
+import {LibString} from "solady/utils/LibString.sol";
+import {OffchainLookup} from "@ensdomains/ens-contracts/ccipRead/EIP3668.sol";
+import {SignatureCheckerLib} from "solady/utils/SignatureCheckerLib.sol";
+
+// contracts
+import {ENS} from "@ensdomains/ens-contracts/registry/ENS.sol";
+
+library L1ResolverMod {
+    using CustomRevert for bytes4;
+    using LibString for string;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          STORAGE                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    // keccak256(abi.encode(uint256(keccak256("towns.domains.resolver.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xad5af01a9aec1f0fbc422f62e21406a58de498f1c0ee36ca202bc49bd857fd00;
+
+    // ENS protocol address
+    ENS internal constant ens = ENS(0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e);
+
+    // ENS name wrapper node
+    bytes32 internal constant NAME_WRAPPER_NODE =
+        0xdee478ba2734e34d81c6adc77a32d75b29007895efa2fe60921f1c315e1ec7d9; // namewrapper.eth
+
+    /// @notice L2 registry information
+    /// @param chainId The chain ID of the L2 registry
+    /// @param registryAddress The address of the L2 registry
+    struct L2Registry {
+        uint64 chainId;
+        address registryAddress;
+    }
+
+    /// @notice Storage layout for the L1Resolver
+    /// @param gatewayUrl The URL of the CCIP gateway
+    /// @param gatewaySigner The address of the gateway signer
+    /// @param nameWrapper The name wrapper contract
+    /// @param registryByNode Mapping of node to L2 registry information
+    struct Layout {
+        string gatewayUrl;
+        address gatewaySigner;
+        INameWrapper nameWrapper;
+        mapping(bytes32 node => L2Registry l2Registry) registryByNode;
+    }
+
+    /// @notice Returns the storage layout for the L1Resolver
+    /// @return $ The storage layout
+    /// @custom:storage-location erc7201:towns.domains.resolver.storage
+    function getStorage() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_SLOT
+        }
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    event GatewayURLSet(string gatewayUrl);
+    event GatewaySignerSet(address gatewaySigner);
+    event L2RegistrySet(
+        bytes32 indexed node,
+        uint64 indexed chainId,
+        address indexed registryAddress
+    );
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           ERRORS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    error L1Resolver__InvalidGatewayURL();
+    error L1Resolver__InvalidGatewaySigner();
+    error L1Resolver__InvalidL2Registry();
+    error L1Resolver__InvalidName();
+    error L1Resolver__InvalidNameWrapper();
+    error L1Resolver__InvalidNode();
+    error L1Resolver__InvalidChainId();
+    error L1Resolver__InvalidOwner();
+    error L1Resolver__SignatureExpired();
+    error L1Resolver__InvalidSignature();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         FUNCTIONS                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    function setGatewayURL(Layout storage $, string calldata gatewayUrl) internal {
+        if (bytes(gatewayUrl).length == 0) L1Resolver__InvalidGatewayURL.selector.revertWith();
+        $.gatewayUrl = gatewayUrl;
+        emit GatewayURLSet(gatewayUrl);
+    }
+
+    function setGatewaySigner(Layout storage $, address gatewaySigner) internal {
+        if (gatewaySigner == address(0)) L1Resolver__InvalidGatewaySigner.selector.revertWith();
+        $.gatewaySigner = gatewaySigner;
+        emit GatewaySignerSet(gatewaySigner);
+    }
+
+    function setNameWrapper(Layout storage $) internal {
+        address wrapperResolver = ens.resolver(NAME_WRAPPER_NODE);
+        if (wrapperResolver == address(0)) L1Resolver__InvalidNameWrapper.selector.revertWith();
+        address wrapperAddress = IAddrResolver(wrapperResolver).addr(NAME_WRAPPER_NODE);
+        if (wrapperAddress == address(0)) L1Resolver__InvalidNameWrapper.selector.revertWith();
+        $.nameWrapper = INameWrapper(wrapperAddress);
+    }
+
+    function setL2Registry(
+        Layout storage $,
+        bytes32 node,
+        uint64 chainId,
+        address registryAddress
+    ) internal {
+        if (node == bytes32(0)) L1Resolver__InvalidNode.selector.revertWith();
+        if (chainId == 0) L1Resolver__InvalidChainId.selector.revertWith();
+        if (registryAddress == address(0)) L1Resolver__InvalidL2Registry.selector.revertWith();
+
+        address owner = ens.owner(node);
+
+        if (owner == address($.nameWrapper)) {
+            owner = $.nameWrapper.ownerOf(uint256(node));
+        }
+
+        if (owner != msg.sender) L1Resolver__InvalidOwner.selector.revertWith();
+
+        $.registryByNode[node] = L2Registry(chainId, registryAddress);
+        emit L2RegistrySet(node, chainId, registryAddress);
+    }
+
+    /// @notice Resolve a name via CCIP-Read
+    /// @dev Always reverts with OffchainLookup to trigger CCIP-Read flow
+    /// @param $ The storage layout
+    /// @param name The DNS-encoded name to resolve
+    /// @param data The resolution data (e.g., addr(bytes32) calldata)
+    /// @param callbackSelector The selector for the callback function (resolveWithProof)
+    /// @return This function always reverts, return type is for interface compatibility
+    function resolve(
+        Layout storage $,
+        bytes calldata name,
+        bytes calldata data,
+        bytes4 callbackSelector
+    ) internal view returns (bytes memory) {
+        string memory decodedName = NameCoder.decode(name); // 'sub.name.eth'
+        string[] memory parts = LibString.split(decodedName, ".");
+
+        // Require at least 2 parts (2LD + TLD)
+        if (parts.length < 2) L1Resolver__InvalidName.selector.revertWith();
+
+        // get the 2LD + TLD (final 2 parts), regardless of how many labels the name has
+        string memory parentName = string.concat(
+            parts[parts.length - 2],
+            ".",
+            parts[parts.length - 1]
+        );
+
+        bytes memory parentDnsName = NameCoder.encode(parentName);
+        bytes32 parentNode = NameCoder.namehash(parentDnsName, 0);
+
+        L2Registry memory registry = $.registryByNode[parentNode];
+        if (registry.registryAddress == address(0)) {
+            L1Resolver__InvalidL2Registry.selector.revertWith();
+        }
+
+        // Build callData for the gateway
+        bytes memory callData = abi.encodeCall(
+            IL1ResolverService.stuffedResolveCall,
+            (name, data, registry.chainId, registry.registryAddress)
+        );
+
+        // Build the gateway URL array
+        string[] memory urls = new string[](1);
+        urls[0] = $.gatewayUrl;
+
+        // Revert with OffchainLookup to trigger CCIP-Read
+        revert OffchainLookup(
+            address(this),
+            urls,
+            callData,
+            callbackSelector,
+            callData // extraData same as callData for verification
+        );
+    }
+
+    /// @notice Verifies the gateway response and returns the resolved data
+    /// @param $ The storage layout
+    /// @param response The gateway response (result, expires, sig)
+    /// @param extraData The original request data for signature verification
+    /// @return result The verified result data
+    function resolveWithProof(
+        Layout storage $,
+        bytes calldata response,
+        bytes calldata extraData
+    ) internal view returns (bytes memory result) {
+        address signer = $.gatewaySigner;
+        if (signer == address(0)) L1Resolver__InvalidGatewaySigner.selector.revertWith();
+
+        // Decode the gateway response
+        uint64 expires;
+        bytes memory sig;
+        (result, expires, sig) = abi.decode(response, (bytes, uint64, bytes));
+
+        // Check expiration
+        if (block.timestamp > expires) {
+            L1Resolver__SignatureExpired.selector.revertWith();
+        }
+
+        // Create the signature hash (matching the gateway's signing format)
+        bytes32 hash = _makeSignatureHash(
+            address(this),
+            expires,
+            keccak256(extraData),
+            keccak256(result)
+        );
+
+        // Verify signature using SignatureCheckerLib
+        // Supports both EOA (ECDSA) and smart contract wallets (ERC-1271)
+        if (!SignatureCheckerLib.isValidSignatureNow(signer, hash, sig)) {
+            L1Resolver__InvalidSignature.selector.revertWith();
+        }
+    }
+
+    /// @dev Generates a hash for signing/verifying gateway responses
+    /// @param target The address the signature is for (this contract)
+    /// @param expires The expiration timestamp
+    /// @param request The original request data
+    /// @param result The result data from the gateway
+    /// @return The hash to be signed/verified
+    function _makeSignatureHash(
+        address target,
+        uint64 expires,
+        bytes32 request,
+        bytes32 result
+    ) private pure returns (bytes32) {
+        return keccak256(abi.encodePacked(hex"1900", target, expires, request, result));
+    }
+}

package/src/domains/facets/l2/AddrResolverFacet.sol

@@ -0,0 +1,59 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IAddrResolver} from "@ensdomains/ens-contracts/resolvers/profiles/IAddrResolver.sol";
+import {IAddressResolver} from "@ensdomains/ens-contracts/resolvers/profiles/IAddressResolver.sol";
+
+// libraries
+import {AddrResolverMod} from "./modules/AddrResolverMod.sol";
+import {L2RegistryMod} from "./modules/L2RegistryMod.sol";
+import {VersionRecordMod} from "./modules/VersionRecordMod.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+
+/// @title AddrResolverFacet
+/// @notice ENS address resolver facet for storing and retrieving blockchain addresses on L2
+/// @dev Implements IAddrResolver (ETH only) and IAddressResolver (multi-coin) with versioned records
+contract AddrResolverFacet is IAddrResolver, IAddressResolver, Facet {
+    using AddrResolverMod for AddrResolverMod.Layout;
+    using VersionRecordMod for VersionRecordMod.Layout;
+
+    /// @notice Initializes the facet by registering resolver interfaces
+    function __AddrResolverFacet_init() external onlyInitializing {
+        _addInterface(type(IAddrResolver).interfaceId);
+        _addInterface(type(IAddressResolver).interfaceId);
+    }
+
+    /// @notice Sets the address for a node and coin type (SLIP-44 standard)
+    /// @param node The ENS node to update
+    /// @param coinType The SLIP-44 coin type (e.g., 60 for ETH, 0 for BTC)
+    /// @param a The address bytes to set
+    function setAddr(bytes32 node, uint256 coinType, bytes memory a) external {
+        L2RegistryMod.onlyAuthorized(node);
+        uint64 version = VersionRecordMod.getStorage().recordVersions[node];
+        AddrResolverMod.getStorage().setAddr(version, node, coinType, a);
+    }
+
+    /// @notice Sets the Ethereum address (coinType 60) for a node
+    /// @param node The ENS node to update
+    /// @param a The Ethereum address to set
+    function setAddr(bytes32 node, address a) external {
+        L2RegistryMod.onlyAuthorized(node);
+        uint64 version = VersionRecordMod.getStorage().recordVersions[node];
+        AddrResolverMod.getStorage().setAddr(version, node, a);
+    }
+
+    /// @inheritdoc IAddressResolver
+    function addr(bytes32 node, uint256 coinType) external view returns (bytes memory) {
+        uint64 version = VersionRecordMod.getStorage().recordVersions[node];
+        return AddrResolverMod.getStorage().addr(version, node, coinType);
+    }
+
+    /// @inheritdoc IAddrResolver
+    function addr(bytes32 node) external view returns (address payable) {
+        uint64 version = VersionRecordMod.getStorage().recordVersions[node];
+        return AddrResolverMod.getStorage().addr(version, node);
+    }
+}

package/src/domains/facets/l2/ContentHashResolverFacet.sol

@@ -0,0 +1,41 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IContentHashResolver} from "@ensdomains/ens-contracts/resolvers/profiles/IContentHashResolver.sol";
+
+// libraries
+import {ContentHashResolverMod} from "./modules/ContentHashResolverMod.sol";
+import {L2RegistryMod} from "./modules/L2RegistryMod.sol";
+import {VersionRecordMod} from "./modules/VersionRecordMod.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+
+/// @title ContentHashResolverFacet
+/// @notice ENS content hash resolver facet for storing IPFS/IPNS/Swarm hashes on L2
+/// @dev Implements IContentHashResolver with versioned records
+contract ContentHashResolverFacet is IContentHashResolver, Facet {
+    using ContentHashResolverMod for ContentHashResolverMod.Layout;
+    using VersionRecordMod for VersionRecordMod.Layout;
+
+    /// @notice Initializes the facet by registering resolver interface
+    function __ContentHashResolverFacet_init() external onlyInitializing {
+        _addInterface(type(IContentHashResolver).interfaceId);
+    }
+
+    /// @notice Sets the content hash for a node
+    /// @param node The ENS node to update
+    /// @param hash The content hash bytes (IPFS, IPNS, Swarm, etc.)
+    function setContenthash(bytes32 node, bytes calldata hash) external {
+        L2RegistryMod.onlyAuthorized(node);
+        uint64 version = VersionRecordMod.getStorage().recordVersions[node];
+        ContentHashResolverMod.getStorage().setContenthash(version, node, hash);
+    }
+
+    /// @inheritdoc IContentHashResolver
+    function contenthash(bytes32 node) external view returns (bytes memory) {
+        uint64 version = VersionRecordMod.getStorage().recordVersions[node];
+        return ContentHashResolverMod.getStorage().contenthash(version, node);
+    }
+}

package/src/domains/facets/l2/ExtendedResolverFacet.sol

@@ -0,0 +1,38 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IExtendedResolver} from "@ensdomains/ens-contracts/resolvers/profiles/IExtendedResolver.sol";
+
+// libraries
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+
+/// @title ExtendedResolverFacet
+/// @notice Implements EIP-3668 (CCIP Read) resolve function for on-chain resolution without offchain lookup
+/// @dev Executes the encoded resolver call directly via staticcall and returns the result or propagates revert
+contract ExtendedResolverFacet is IExtendedResolver, Facet {
+    /// @notice Initializes the facet by registering the IExtendedResolver interface
+    function __ExtendedResolverFacet_init() external onlyInitializing {
+        _addInterface(type(IExtendedResolver).interfaceId);
+    }
+
+    /// @notice Resolves ENS data by executing the encoded call directly on this contract
+    /// @param data The encoded resolver function call (e.g., addr(bytes32), text(bytes32,string))
+    /// @return The result of the resolver call
+    function resolve(
+        bytes memory /* name */,
+        bytes memory data
+    ) external view returns (bytes memory) {
+        (bool success, bytes memory result) = address(this).staticcall(data);
+        if (success) {
+            return result;
+        } else {
+            // Revert with the reason provided by the call
+            assembly {
+                revert(add(result, 0x20), mload(result))
+            }
+        }
+    }
+}

package/src/domains/facets/l2/IL2Registry.sol

@@ -0,0 +1,79 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IERC721A} from "../../../diamond/facets/token/ERC721A/IERC721A.sol";
+
+// libraries
+
+// contracts
+
+/// @title IL2Registry
+/// @notice Interface for L2 ENS-compatible domain registry that mints subdomains as NFTs
+/// @dev Extends IERC721A to provide ERC721 functionality and adds domain-specific operations
+interface IL2Registry is IERC721A {
+    /// @notice Creates a subdomain under an existing domain and optionally sets resolver records
+    /// @param domainHash The parent domain's namehash
+    /// @param subdomain The subdomain label (e.g., "alice" for "alice.towns.eth")
+    /// @param owner The address that will own the subdomain NFT
+    /// @param records Encoded resolver calls to set initial records (addr, text, etc.)
+    /// @param metadata Arbitrary bytes for registrar use (e.g., expiration, tier, etc.)
+    function createSubdomain(
+        bytes32 domainHash,
+        string calldata subdomain,
+        address owner,
+        bytes[] calldata records,
+        bytes calldata metadata
+    ) external;
+
+    /// @notice Adds an address as an approved registrar that can mint subdomains
+    /// @param registrar The address to approve as a registrar
+    function addRegistrar(address registrar) external;
+
+    /// @notice Removes an address from the approved registrars list
+    /// @param registrar The address to remove
+    function removeRegistrar(address registrar) external;
+
+    /// @notice Sets or updates the metadata for a subdomain (registrar only)
+    /// @dev Metadata is arbitrary bytes that the registrar can interpret (e.g., expiration, tier, etc.)
+    /// @param node The namehash of the subdomain
+    /// @param data The metadata bytes to store
+    function setMetadata(bytes32 node, bytes calldata data) external;
+
+    /// @notice Returns the metadata bytes for a subdomain
+    /// @param node The namehash of the subdomain
+    /// @return The metadata bytes (empty if not set)
+    function getMetadata(bytes32 node) external view returns (bytes memory);
+
+    /// @notice Returns the owner of the root domain
+    /// @return The address that owns the root domain NFT
+    function domainOwner() external view returns (address);
+
+    /// @notice Returns the owner of a subdomain by its namehash
+    /// @param nameHash The namehash of the subdomain
+    /// @return The address that owns the subdomain NFT
+    function subdomainOwner(bytes32 nameHash) external view returns (address);
+
+    /// @notice Returns the namehash of the base domain
+    /// @return The namehash of the base domain
+    function baseDomainHash() external view returns (bytes32);
+
+    /// @notice Computes the namehash of a domain name
+    /// @param node The domain name (e.g., "alice.towns.eth")
+    /// @return The namehash (bytes32)
+    function namehash(string calldata node) external pure returns (bytes32);
+
+    /// @notice Decodes a DNS-encoded name to a human-readable string
+    /// @param node The DNS-encoded name bytes
+    /// @return The decoded domain name
+    function decodeName(bytes calldata node) external pure returns (string memory);
+
+    /// @notice Helper to derive a node from a parent node and label
+    /// @param domainHash The namehash of the domain, e.g. `namehash("name.eth")` for "name.eth"
+    /// @param subdomain The label of the subnode, e.g. "x" for "x.name.eth"
+    /// @return The resulting subnode, e.g. `namehash("x.name.eth")` for "x.name.eth"
+    function encodeSubdomain(
+        bytes32 domainHash,
+        string calldata subdomain
+    ) external pure returns (bytes32);
+}