@towns-protocol/contracts 0.0.453 → 1.0.1

package/src/domains/facets/l2/modules/L2RegistryMod.sol

@@ -0,0 +1,286 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// libraries
+import {CustomRevert} from "src/utils/libraries/CustomRevert.sol";
+import {MinimalERC721Storage, ERC721Lib} from "@towns-protocol/diamond/src/primitive/ERC721.sol";
+import {NameCoder} from "@ensdomains/ens-contracts/utils/NameCoder.sol";
+import {Base64} from "solady/utils/Base64.sol";
+
+/// @title L2RegistryMod
+/// @notice L2 domain registry module for managing ENS-compatible subdomains as NFTs on L2
+/// @dev Provides storage and logic for minting subdomains, managing registrars, and storing DNS-encoded names
+library L2RegistryMod {
+    using CustomRevert for bytes4;
+    using ERC721Lib for MinimalERC721Storage;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          STORAGE                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    // keccak256(abi.encode(uint256(keccak256("towns.domains.facets.l2.registry.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 constant STORAGE_SLOT =
+        0xd006f5666f0513641f83237d8fe37b671902940d193477fdbf21bf0fa624e400;
+
+    /// @notice Storage layout for the L2 registry
+    /// @dev baseNode is the root domain hash (e.g., namehash("towns.eth")), names maps node to DNS-encoded name, metadata is arbitrary bytes set by registrar, registrars are approved minters, token is the ERC721 storage
+    struct Layout {
+        bytes32 baseNode;
+        mapping(bytes32 node => bytes name) names;
+        mapping(bytes32 node => bytes) metadata;
+        mapping(address registrar => bool approved) registrars;
+        MinimalERC721Storage token;
+    }
+
+    /// @notice Returns the storage layout for this module
+    function getStorage() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_SLOT
+        }
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Emitted when a name is created at any level
+    event SubnodeCreated(bytes32 indexed node, bytes name, address owner);
+
+    /// @notice Emitted when a subnode is registered at any level
+    /// @dev Same event signature as the ENS Registry
+    event NewOwner(bytes32 indexed parentNode, bytes32 indexed labelhash, address owner);
+
+    /// @notice Emitted when a registrar is added
+    event RegistrarAdded(address registrar);
+
+    /// @notice Emitted when a registrar is removed
+    event RegistrarRemoved(address registrar);
+
+    /// @notice Emitted when the base node is set
+    event BaseNodeUpdated(bytes32 baseNode);
+
+    /// @notice Emitted when metadata is set or updated for a node
+    event MetadataSet(bytes32 indexed node, bytes metadata);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           ERRORS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    error L2RegistryMod_LabelTooShort();
+    error L2RegistryMod_LabelTooLong();
+    error L2RegistryMod_NotAvailable();
+    error L2RegistryMod_NotOwnerOrRegistrar();
+    error L2RegistryMod_SetRecordsFailed();
+    error L2RegistryMod_SetRecordsInvalidNamehash();
+    error L2RegistryMod_NotOwner();
+    error L2RegistryMod_DomainAlreadyExists();
+    error L2RegistryMod_NotAuthorized();
+    error L2RegistryMod_NotRegistrar();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         FUNCTIONS                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Creates the root domain for this registry (e.g., "towns.eth") and mints it as an NFT to the owner
+    /// @dev Can only be called once per registry; sets baseNode and stores the DNS-encoded name
+    /// @param domain The full domain name (e.g., "towns.eth")
+    /// @param owner The address that will own the root domain NFT
+    /// @return domainHash The namehash of the created domain
+    function createDomain(
+        Layout storage $,
+        string calldata domain,
+        address owner
+    ) internal returns (bytes32 domainHash) {
+        bytes memory dnsEncodedName = NameCoder.encode(domain);
+        domainHash = NameCoder.namehash(dnsEncodedName, 0);
+
+        if ($.token.owners.get(uint256(domainHash)) != address(0))
+            L2RegistryMod_DomainAlreadyExists.selector.revertWith();
+
+        $.baseNode = domainHash;
+        $.names[domainHash] = dnsEncodedName;
+        $.token.mint(owner, uint256(domainHash));
+    }
+
+    /// @notice Creates a subdomain from a parent domain hash and label
+    /// @dev Only callable by the owner of the parent domain or an approved registrar. Once minted, a subdomain cannot be re-registered.
+    /// @param domainHash The hash of the domain, e.g. `namehash("name.eth")` for "name.eth"
+    /// @param subdomain The subdomain of the subdomain, e.g. "x" for "x.name.eth"
+    /// @param owner The address that will own the subdomain
+    /// @param records The encoded calldata for resolver setters
+    /// @param metadata Arbitrary bytes that registrar can use (e.g., expiration, tier, etc.)
+    /// @return subdomainHash The resulting subdomain hash, e.g. `namehash("x.name.eth")` for "x.name.eth"
+    function createSubdomain(
+        Layout storage $,
+        bytes32 domainHash,
+        string calldata subdomain,
+        address owner,
+        bytes[] calldata records,
+        bytes calldata metadata
+    ) internal returns (bytes32 subdomainHash) {
+        subdomainHash = encodeNode(domainHash, subdomain);
+        uint256 subnodeId = uint256(subdomainHash);
+
+        // Revert if subdomain already exists
+        if ($.token.owners.get(subnodeId) != address(0)) {
+            L2RegistryMod_NotAvailable.selector.revertWith();
+        }
+
+        // mint NFT and update storage
+        $.token.mint(owner, subnodeId);
+        $.names[subdomainHash] = encodeName(subdomain, $.names[domainHash]);
+        if (metadata.length > 0) $.metadata[subdomainHash] = metadata;
+
+        // delegatecall to resolver setters
+        setRecords(subdomainHash, records);
+
+        // Events
+        emit NewOwner(domainHash, keccak256(bytes(subdomain)), owner);
+        emit SubnodeCreated(subdomainHash, $.names[subdomainHash], owner);
+        if (metadata.length > 0) emit MetadataSet(subdomainHash, metadata);
+    }
+
+    /// @notice Executes multiple resolver record setter calls via delegatecall (multicall pattern)
+    /// @dev Each call's first 32 bytes after selector must match subdomainHash to prevent cross-node writes
+    /// @param subdomainHash The node hash that all records must belong to (pass bytes32(0) to skip validation)
+    /// @param data Array of encoded function calls (e.g., setAddr, setText) to execute
+    /// @return results Array of return data from each delegatecall
+    function setRecords(
+        bytes32 subdomainHash,
+        bytes[] calldata data
+    ) internal returns (bytes[] memory results) {
+        uint256 length = data.length;
+        results = new bytes[](length);
+        for (uint256 i; i < length; ++i) {
+            if (subdomainHash != bytes32(0)) {
+                if (data[i].length < 36)
+                    L2RegistryMod_SetRecordsInvalidNamehash.selector.revertWith();
+                bytes32 txNamehash = bytes32(data[i][4:36]);
+                if (txNamehash != subdomainHash)
+                    L2RegistryMod_SetRecordsInvalidNamehash.selector.revertWith();
+            }
+            (bool success, bytes memory result) = address(this).delegatecall(data[i]);
+            if (!success) L2RegistryMod_SetRecordsFailed.selector.revertWith();
+            results[i] = result;
+        }
+        return results;
+    }
+
+    /// @notice Adds an address as an approved registrar that can mint subdomains
+    function addRegistrar(Layout storage $, address registrar) internal {
+        $.registrars[registrar] = true;
+        emit RegistrarAdded(registrar);
+    }
+
+    /// @notice Removes an address from the approved registrars list
+    function removeRegistrar(Layout storage $, address registrar) internal {
+        $.registrars[registrar] = false;
+        emit RegistrarRemoved(registrar);
+    }
+
+    /// @notice Updates the base node (root domain hash) for this registry
+    function setBaseNode(Layout storage $, bytes32 baseNode) internal {
+        $.baseNode = baseNode;
+        emit BaseNodeUpdated(baseNode);
+    }
+
+    /// @notice Checks if an address is an approved registrar
+    function isRegistrar(Layout storage $, address registrar) internal view returns (bool) {
+        return $.registrars[registrar];
+    }
+
+    /// @notice Sets or updates the metadata for a node
+    /// @dev Only callable by registrar. 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(Layout storage $, bytes32 node, bytes calldata data) internal {
+        $.metadata[node] = data;
+        emit MetadataSet(node, data);
+    }
+
+    /// @notice Returns the metadata bytes for a node
+    /// @param node The namehash of the subdomain
+    /// @return The metadata bytes (empty if not set)
+    function getMetadata(Layout storage $, bytes32 node) internal view returns (bytes memory) {
+        return $.metadata[node];
+    }
+
+    /// @notice Returns the token URI for a domain NFT as a base64-encoded JSON with the decoded domain name
+    function tokenURI(Layout storage $, uint256 tokenId) internal view returns (string memory) {
+        if ($.token.ownerOf(tokenId) == address(0)) L2RegistryMod_NotOwner.selector.revertWith();
+
+        string memory json = string.concat(
+            '{"name": "',
+            NameCoder.decode($.names[bytes32(tokenId)]),
+            '"}'
+        );
+
+        return string.concat("data:application/json;base64,", Base64.encode(bytes(json)));
+    }
+
+    /// @notice Computes the namehash of a subdomain from its parent node and label (keccak256(parentNode, keccak256(label)))
+    function encodeNode(bytes32 parentNode, string calldata label) internal pure returns (bytes32) {
+        bytes32 labelhash = keccak256(bytes(label));
+        return keccak256(abi.encodePacked(parentNode, labelhash));
+    }
+
+    /// @notice Encodes a label and parent name into DNS wire format (length-prefixed label + parent name bytes)
+    function encodeName(
+        string memory label,
+        bytes memory name
+    ) internal pure returns (bytes memory ret) {
+        if (bytes(label).length < 1) {
+            L2RegistryMod_LabelTooShort.selector.revertWith();
+        }
+        if (bytes(label).length > 255) {
+            L2RegistryMod_LabelTooLong.selector.revertWith();
+        }
+        return abi.encodePacked(uint8(bytes(label).length), label, name);
+    }
+
+    /// @notice Reverts if caller is neither the node owner nor an approved registrar
+    function onlyOwnerOrRegistrar(Layout storage $, bytes32 node) internal view {
+        if ($.token.ownerOf(uint256(node)) != msg.sender && !$.registrars[msg.sender]) {
+            revert L2RegistryMod_NotOwnerOrRegistrar();
+        }
+    }
+
+    /// @notice Reverts if caller is not the owner of the base (root) node
+    function onlyOwner(Layout storage $) internal view {
+        if ($.token.ownerOf(uint256($.baseNode)) != msg.sender) {
+            revert L2RegistryMod_NotOwner();
+        }
+    }
+
+    /// @notice Reverts if caller is not an approved registrar
+    function onlyRegistrar(Layout storage $) internal view {
+        if (!$.registrars[msg.sender]) L2RegistryMod_NotRegistrar.selector.revertWith();
+    }
+
+    /// @notice Reverts if caller is not authorized to modify the given node
+    function onlyAuthorized(bytes32 node) internal view {
+        if (!isAuthorized(node)) L2RegistryMod_NotAuthorized.selector.revertWith();
+    }
+
+    /// @notice Checks if msg.sender is authorized to modify the given node (owner, approved, or registrar)
+    function isAuthorized(bytes32 node) internal view returns (bool) {
+        return isAuthorizedForAddress(getStorage(), msg.sender, node);
+    }
+
+    /// @notice Checks if an address is authorized to modify a node (registrar, owner, or approved operator)
+    function isAuthorizedForAddress(
+        Layout storage $,
+        address addr,
+        bytes32 node
+    ) internal view returns (bool) {
+        if ($.registrars[addr]) return true;
+
+        uint256 tokenId = uint256(node);
+        address owner = $.token.ownerOf(tokenId);
+
+        if ((owner != addr) && ($.token.getApproved(tokenId) != addr)) {
+            return false;
+        }
+
+        return true;
+    }
+}

package/src/domains/facets/l2/modules/TextResolverMod.sol

@@ -0,0 +1,62 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {ITextResolver} from "@ensdomains/ens-contracts/resolvers/profiles/ITextResolver.sol";
+
+/// @title TextResolverMod
+/// @notice Stores and retrieves arbitrary text records (key-value strings) for ENS nodes with versioning support
+/// @dev Implements ENS ITextResolver storage; records are keyed by (version, node, key) for atomic clearing
+library TextResolverMod {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          STORAGE                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    // keccak256(abi.encode(uint256(keccak256("ens.domains.text.resolver.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 constant STORAGE_SLOT =
+        0xccd57d47affdb87d4363b03aa46f3e8c1b9394057f472ce512f3a1ec1c667400;
+
+    /// @notice Storage layout with versioned text records: version => node => key => value
+    struct Layout {
+        mapping(uint64 => mapping(bytes32 => mapping(string => string))) versionable_texts;
+    }
+
+    /// @notice Returns the storage layout for this module
+    function getStorage() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_SLOT
+        }
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         FUNCTIONS                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Sets the text data associated with an ENS node and key
+    /// @param node The node to update
+    /// @param key The key to set
+    /// @param value The text data value to set
+    function setText(
+        Layout storage $,
+        uint64 version,
+        bytes32 node,
+        string calldata key,
+        string calldata value
+    ) internal {
+        $.versionable_texts[version][node][key] = value;
+        emit ITextResolver.TextChanged(node, key, key, value);
+    }
+
+    /// @notice Returns the text data associated with an ENS node and key
+    /// @param node The ENS node to query
+    /// @param key The text data key to query
+    /// @return The associated text data
+    function text(
+        Layout storage $,
+        uint64 version,
+        bytes32 node,
+        string calldata key
+    ) internal view returns (string memory) {
+        return $.versionable_texts[version][node][key];
+    }
+}

package/src/domains/facets/l2/modules/VersionRecordMod.sol

@@ -0,0 +1,42 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IVersionableResolver} from "@ensdomains/ens-contracts/resolvers/profiles/IVersionableResolver.sol";
+
+/// @title VersionRecordMod
+/// @notice Manages record versioning for ENS resolver records, enabling atomic invalidation of all records for a node
+/// @dev Incrementing a node's version effectively clears all its records since resolvers key records by (version, node)
+library VersionRecordMod {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          STORAGE                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    // keccak256(abi.encode(uint256(keccak256("ens.domains.version.record.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 constant STORAGE_SLOT =
+        0xf22205753714587a1da0c0ad29dc01aa3237bb3fbfb1b984b23c0773da3cb700;
+
+    /// @notice Storage layout mapping each node to its current record version number
+    struct Layout {
+        mapping(bytes32 => uint64) recordVersions;
+    }
+
+    /// @notice Returns the storage layout for this module
+    function getStorage() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_SLOT
+        }
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         FUNCTIONS                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Clears all records for a node by incrementing its version number
+    /// @dev Records are keyed by (version, node), so incrementing version makes old records inaccessible
+    function clearRecords(bytes32 node) internal {
+        Layout storage $ = getStorage();
+        uint64 version = $.recordVersions[node]++;
+        emit IVersionableResolver.VersionChanged(node, version);
+    }
+}

package/src/domains/facets/registrar/IL2Registrar.sol

@@ -0,0 +1,57 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+/// @title IL2Registrar
+/// @notice Interface for the L2 subdomain registrar
+/// @dev Handles subdomain registration with label validation for Towns domains.
+///      Only Towns smart accounts (IModularAccount) can register domains.
+///      First registration per account is free, subsequent registrations are charged via FeeManager.
+interface IL2Registrar {
+    /// @notice Registers a new subdomain
+    /// @dev Only callable by Towns smart accounts (IModularAccount).
+    ///      First registration is free, subsequent ones are charged via FeeManager.
+    /// @param label The subdomain label to register (e.g., "alice" for "alice.towns.eth")
+    /// @param owner The address that will own the subdomain NFT
+    function register(string calldata label, address owner) external;
+
+    /// @notice Sets the space factory address (owner only)
+    /// @param spaceFactory The new space factory address
+    function setSpaceFactory(address spaceFactory) external;
+
+    /// @notice Sets the registry address (owner only)
+    /// @param registry The new registry address
+    function setRegistry(address registry) external;
+
+    /// @notice Sets the currency (owner only)
+    /// @param currency The new currency
+    function setCurrency(address currency) external;
+
+    /// @notice Checks if a label is available for registration
+    /// @dev Returns false if label is invalid OR already registered
+    /// @param label The subdomain label to check (e.g., "alice")
+    /// @return True if the label can be registered, false otherwise
+    function isAvailable(string calldata label) external view returns (bool);
+
+    /// @notice Returns the registry address this registrar points to
+    /// @return The address of the L2Registry diamond contract
+    function getRegistry() external view returns (address);
+
+    /// @notice Returns the coinType used for address resolution
+    /// @dev Computed as 0x80000000 | chainId per ENSIP-11
+    /// @return The ENSIP-11 compliant coinType for this chain
+    function getCoinType() external view returns (uint256);
+
+    /// @notice Returns the space factory address
+    /// @return The address of the SpaceFactory diamond contract
+    function getSpaceFactory() external view returns (address);
+
+    /// @notice Returns the currency used for registration fees
+    /// @return The currency used for registration fees
+    function getCurrency() external view returns (address);
+
+    /// @notice Checks if a label format is valid (without checking availability)
+    /// @dev Validates: length (3-63), allowed chars (a-z, 0-9, hyphen), no leading/trailing hyphen
+    /// @param label The subdomain label to validate
+    /// @return True if the label format is valid
+    function isValidLabel(string calldata label) external pure returns (bool);
+}

package/src/domains/facets/registrar/L2RegistrarFacet.sol

@@ -0,0 +1,127 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IL2Registrar} from "./IL2Registrar.sol";
+
+// libraries
+import {L2RegistrarMod} from "./L2RegistrarMod.sol";
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {Validator} from "../../../utils/libraries/Validator.sol";
+
+// contracts
+import {Facet} from "@towns-protocol/diamond/src/facets/Facet.sol";
+import {OwnableBase} from "@towns-protocol/diamond/src/facets/ownable/OwnableBase.sol";
+import {ReentrancyGuardTransient} from "solady/utils/ReentrancyGuardTransient.sol";
+
+/// @title L2RegistrarFacet
+/// @notice Handles subdomain registration for Towns domains
+/// @dev Registrar that validates callers are Towns smart accounts, charges fees, and creates subdomains
+contract L2RegistrarFacet is IL2Registrar, OwnableBase, ReentrancyGuardTransient, Facet {
+    using CustomRevert for bytes4;
+    using L2RegistrarMod for L2RegistrarMod.Layout;
+
+    /// @notice Initializes the registrar with a registry contract and space factory
+    /// @param registry Address of the L2Registry diamond contract
+    /// @param spaceFactory Address of the SpaceFactory diamond (contains FeeManager facet)
+    /// @param currency Address of the ERC20 token used for fee payments
+    function __L2Registrar_init(
+        address registry,
+        address spaceFactory,
+        address currency
+    ) external onlyInitializing {
+        _addInterface(type(IL2Registrar).interfaceId);
+        __L2Registrar_init_unchained(registry, spaceFactory, currency);
+    }
+
+    /// @notice Internal initialization without interface registration
+    /// @dev Sets storage values for registry, factory, currency, and coinType
+    /// @param registry Address of the L2Registry diamond contract
+    /// @param spaceFactory Address of the SpaceFactory diamond (contains FeeManager facet)
+    /// @param currency Address of the ERC20 token used for fee payments
+    function __L2Registrar_init_unchained(
+        address registry,
+        address spaceFactory,
+        address currency
+    ) internal {
+        Validator.checkAddress(registry);
+        Validator.checkAddress(spaceFactory);
+        Validator.checkAddress(currency);
+        L2RegistrarMod.Layout storage $ = L2RegistrarMod.getStorage();
+        $.registry = registry;
+        $.spaceFactory = spaceFactory;
+        $.currency = currency;
+        // ENSIP-11: Maps EVM chainId to ENS coinType by setting MSB (bit 31).
+        // This avoids collisions with SLIP-44 native coin types and enables
+        // deterministic L2 address resolution. Formula: coinType = 0x80000000 | chainId
+        $.coinType = 0x80000000 | block.chainid;
+    }
+
+    /// @inheritdoc IL2Registrar
+    function register(string calldata label, address owner) external nonReentrant {
+        // 1. Verify caller is a Towns smart account
+        L2RegistrarMod.onlySmartAccount();
+
+        // 2. Validate label format
+        L2RegistrarMod.validateLabel(label);
+
+        L2RegistrarMod.Layout storage $ = L2RegistrarMod.getStorage();
+
+        // 3. Charge fee via FeeManager (hook handles first-free + tiers)
+        $.chargeFee(label);
+
+        // 4. Register domain (existing logic, minus duplicate label validation)
+        $.register(label, owner);
+    }
+
+    /// @inheritdoc IL2Registrar
+    function setSpaceFactory(address spaceFactory) external onlyOwner {
+        Validator.checkAddress(spaceFactory);
+        L2RegistrarMod.getStorage().spaceFactory = spaceFactory;
+        emit L2RegistrarMod.SpaceFactorySet(spaceFactory);
+    }
+
+    /// @inheritdoc IL2Registrar
+    function setRegistry(address registry) external onlyOwner {
+        Validator.checkAddress(registry);
+        L2RegistrarMod.getStorage().registry = registry;
+        emit L2RegistrarMod.RegistrySet(registry);
+    }
+
+    /// @inheritdoc IL2Registrar
+    function setCurrency(address currency) external onlyOwner {
+        Validator.checkAddress(currency);
+        L2RegistrarMod.getStorage().currency = currency;
+        emit L2RegistrarMod.CurrencySet(currency);
+    }
+
+    /// @inheritdoc IL2Registrar
+    function isAvailable(string calldata label) external view returns (bool) {
+        return L2RegistrarMod.getStorage().available(label);
+    }
+
+    /// @inheritdoc IL2Registrar
+    function getRegistry() external view returns (address) {
+        return L2RegistrarMod.getStorage().registry;
+    }
+
+    /// @inheritdoc IL2Registrar
+    function getCurrency() external view returns (address) {
+        return L2RegistrarMod.getStorage().currency;
+    }
+
+    /// @inheritdoc IL2Registrar
+    function getCoinType() external view returns (uint256) {
+        return L2RegistrarMod.getStorage().coinType;
+    }
+
+    /// @inheritdoc IL2Registrar
+    function getSpaceFactory() external view returns (address) {
+        return L2RegistrarMod.getStorage().spaceFactory;
+    }
+
+    /// @inheritdoc IL2Registrar
+    function isValidLabel(string calldata label) external pure returns (bool) {
+        return L2RegistrarMod.isValidLabel(label);
+    }
+}