@towns-protocol/contracts 0.0.455 → 1.0.1

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

@@ -0,0 +1,224 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IL2Registry} from "../l2/IL2Registry.sol";
+import {IModularAccount} from "@erc6900/reference-implementation/interfaces/IModularAccount.sol";
+import {IERC165} from "@openzeppelin/contracts/utils/introspection/IERC165.sol";
+import {IFeeManager} from "../../../factory/facets/fee/IFeeManager.sol";
+
+// libraries
+import {LibString} from "solady/utils/LibString.sol";
+import {CustomRevert} from "../../../utils/libraries/CustomRevert.sol";
+import {FeeTypesLib} from "../../../factory/facets/fee/FeeTypesLib.sol";
+import {ProtocolFeeLib} from "../../../spaces/facets/ProtocolFeeLib.sol";
+
+// contracts
+import {AddrResolverFacet} from "../l2/AddrResolverFacet.sol";
+
+library L2RegistrarMod {
+    using CustomRevert for bytes4;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          LAYOUT                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    struct Layout {
+        address registry;
+        uint256 coinType;
+        address spaceFactory;
+        address currency;
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         CONSTANTS                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Minimum length required for a subdomain label (3 characters)
+    uint256 internal constant MIN_LABEL_LENGTH = 3;
+
+    /// @notice Maximum length allowed for a subdomain label (63 characters per DNS spec)
+    uint256 internal constant MAX_LABEL_LENGTH = 63;
+
+    /// @notice Allowed characters: lowercase a-z, digits 0-9, and hyphen
+    /// @dev Computed as: LOWERCASE_7_BIT_ASCII | DIGITS_7_BIT_ASCII | (1 << 45)
+    /// where 45 is the ASCII code for hyphen '-'
+    uint128 internal constant ALLOWED_LABEL_CHARS =
+        LibString.LOWERCASE_7_BIT_ASCII | LibString.DIGITS_7_BIT_ASCII | 0x200000000000;
+
+    /// @notice ASCII code for hyphen character
+    bytes1 internal constant HYPHEN = 0x2d;
+
+    /// keccak256(abi.encode(uint256(keccak256("towns.domains.registrar.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0xd8d4140311c6e36bf92b2f6d963b373d4b20ef4c79fad106c706a4d652ed9b00;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           EVENTS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Emitted when a new subdomain is registered
+    /// @param label The subdomain label
+    /// @param owner The owner of the subdomain
+    event NameRegistered(string indexed label, address indexed owner);
+
+    /// @notice Emitted when the space factory address is updated
+    /// @param spaceFactory The new space factory address
+    event SpaceFactorySet(address spaceFactory);
+
+    /// @notice Emitted when the registry address is updated
+    /// @param registry The new registry address
+    event RegistrySet(address registry);
+
+    /// @notice Emitted when the currency is updated
+    /// @param currency The new currency
+    event CurrencySet(address currency);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                           ERRORS                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Thrown when a label is invalid (wrong length, chars, or format)
+    error L2Registrar__InvalidLabel();
+
+    /// @notice Thrown when caller is not a Towns smart account (IModularAccount)
+    error L2Registrar__NotSmartAccount();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                         FUNCTIONS                          */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Registers a subdomain in the L2 registry
+    /// @dev Reverts if the subdomain is not available or the label is invalid
+    /// @param $ The storage layout
+    /// @param subdomain The subdomain label to register (e.g., "alice")
+    /// @param owner The address of the owner of the subdomain
+    function register(Layout storage $, string calldata subdomain, address owner) internal {
+        // Get registry interface to interact with domain management functions
+        IL2Registry registry = IL2Registry($.registry);
+
+        // Retrieve the base domain hash (e.g., namehash("towns.eth"))
+        bytes32 domainHash = registry.baseDomainHash();
+
+        // Compute the subdomain namehash (e.g., namehash("alice.towns.eth"))
+        bytes32 subdomainHash = registry.encodeSubdomain(domainHash, subdomain);
+
+        // Register the name in the L2 registry
+        registry.createSubdomain(domainHash, subdomain, owner, new bytes[](0), "");
+
+        // Encode owner address as bytes for resolver record storage
+        bytes memory addr = abi.encodePacked(owner);
+
+        // Get address resolver facet to set address records for the subdomain
+        AddrResolverFacet addrResolver = AddrResolverFacet($.registry);
+
+        // Set the forward address for the current chain. This is needed for reverse resolution.
+        // E.g. if this contract is deployed to Base, set an address for chainId 8453 which is
+        // coinType 2147492101 according to ENSIP-11.
+        addrResolver.setAddr(subdomainHash, $.coinType, addr);
+
+        // Set the forward address for mainnet ETH (coinType 60) for easier debugging.
+        addrResolver.setAddr(subdomainHash, 60, addr);
+
+        // Emit event to notify about the successful registration
+        emit NameRegistered(subdomain, owner);
+    }
+
+    function chargeFee(Layout storage $, string calldata label) internal {
+        if ($.spaceFactory == address(0)) return;
+        if ($.currency == address(0)) return;
+
+        bytes memory extraData = abi.encode(bytes(label).length);
+
+        uint256 expectedFee = IFeeManager($.spaceFactory).calculateFee(
+            FeeTypesLib.DOMAIN_REGISTRATION,
+            msg.sender,
+            0,
+            extraData
+        );
+
+        ProtocolFeeLib.chargeAlways(
+            $.spaceFactory,
+            FeeTypesLib.DOMAIN_REGISTRATION,
+            msg.sender,
+            $.currency,
+            expectedFee,
+            expectedFee,
+            extraData
+        );
+    }
+
+    /// @notice Validates caller is a Towns smart account (IModularAccount)
+    /// @dev Uses ERC-165 supportsInterface check
+    function onlySmartAccount() internal view {
+        // Must be a contract
+        if (msg.sender.code.length == 0) {
+            L2Registrar__NotSmartAccount.selector.revertWith();
+        }
+
+        // Must support IModularAccount interface
+        try IERC165(msg.sender).supportsInterface(type(IModularAccount).interfaceId) returns (
+            bool supported
+        ) {
+            if (!supported) L2Registrar__NotSmartAccount.selector.revertWith();
+        } catch {
+            L2Registrar__NotSmartAccount.selector.revertWith();
+        }
+    }
+
+    /// @notice Checks if a subdomain is available for registration
+    /// @dev Returns true if the label is valid and the subdomain doesn't exist
+    /// @param $ The storage layout
+    /// @param subdomain The subdomain label to check (e.g., "alice")
+    /// @return True if the subdomain is available, false otherwise
+    function available(Layout storage $, string calldata subdomain) internal view returns (bool) {
+        // Check label validity first
+        if (!isValidLabel(subdomain)) return false;
+
+        // Check if subdomain already exists by querying its owner
+        // subdomainOwner returns address(0) if the subdomain doesn't exist
+        IL2Registry registry = IL2Registry($.registry);
+
+        // Compute the subdomain namehash
+        bytes32 subdomainHash = registry.encodeSubdomain(registry.baseDomainHash(), subdomain);
+
+        // Available if owner is zero address (subdomain doesn't exist)
+        return registry.subdomainOwner(subdomainHash) == address(0);
+    }
+
+    /// @notice Validates a subdomain label for registration
+    /// @dev Checks: length (3-63), allowed chars (a-z, 0-9, hyphen), no leading/trailing hyphen
+    /// @param label The subdomain label to validate (e.g., "alice")
+    function validateLabel(string calldata label) internal pure {
+        if (!isValidLabel(label)) L2Registrar__InvalidLabel.selector.revertWith();
+    }
+
+    /// @notice Checks if a label is valid without checking availability
+    /// @dev Use this for UI validation before attempting registration
+    /// @param label The subdomain label to validate
+    /// @return True if the label format is valid
+    function isValidLabel(string calldata label) internal pure returns (bool) {
+        uint256 len = bytes(label).length;
+
+        // Check length bounds
+        if (len < MIN_LABEL_LENGTH || len > MAX_LABEL_LENGTH) return false;
+
+        // Check all characters are allowed (a-z, 0-9, hyphen)
+        if (!LibString.is7BitASCII(label, ALLOWED_LABEL_CHARS)) return false;
+
+        // Check hyphen not at start or end
+        bytes calldata b = bytes(label);
+        if (b[0] == HYPHEN || b[len - 1] == HYPHEN) return false;
+
+        return true;
+    }
+
+    /// @notice Returns the storage layout for the L2Registrar facet
+    /// @dev Uses diamond storage pattern to avoid slot collisions between facets
+    /// @return $ The storage pointer to the facet's layout
+    function getStorage() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/domains/hooks/DomainFeeHook.sol

@@ -0,0 +1,212 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.29;
+
+// interfaces
+import {IFeeHook, FeeHookResult} from "../../factory/facets/fee/IFeeHook.sol";
+
+// libraries
+import {CustomRevert} from "../../utils/libraries/CustomRevert.sol";
+import {Validator} from "../../utils/libraries/Validator.sol";
+
+// contracts
+import {Ownable} from "solady/auth/Ownable.sol";
+
+/// @title DomainFeeHook
+/// @notice Fee hook for domain registration with tiered pricing and first-free logic
+/// @dev Implements IFeeHook to integrate with FeeManager system
+contract DomainFeeHook is IFeeHook, Ownable {
+    using CustomRevert for bytes4;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          STORAGE                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    struct Layout {
+        uint256 defaultPrice;
+        mapping(uint256 length => uint256 price) priceTiers;
+        mapping(address account => uint256 count) registrationCount;
+        address feeManager;
+    }
+
+    /// keccak256(abi.encode(uint256(keccak256("towns.domains.registrar.domain.feehook.storage")) - 1)) & ~bytes32(uint256(0xff))
+    bytes32 internal constant STORAGE_SLOT =
+        0x54805b38b00d627862a1394d5554c4c16c8fd44fa1e31b86f37dcbff65fe4e00;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          EVENTS                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Emitted when the default price is updated
+    event DefaultPriceSet(uint256 price);
+
+    /// @notice Emitted when a price tier is set
+    event PriceTierSet(uint256 indexed length, uint256 price);
+
+    /// @notice Emitted when the fee manager is updated
+    event FeeManagerSet(address indexed feeManager);
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          ERRORS                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Thrown when context data is invalid or missing
+    error DomainFeeHook__InvalidContext();
+
+    /// @notice Thrown when array lengths don't match in batch operations
+    error DomainFeeHook__LengthMismatch();
+
+    /// @notice Thrown when caller is not the authorized FeeManager
+    error DomainFeeHook__Unauthorized();
+
+    /// @notice Thrown when the number of lengths exceeds the maximum allowed
+    error DomainFeeHook__TooManyLengths();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        CONSTRUCTOR                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Initializes the fee hook with an owner and default price
+    /// @param owner The owner address
+    /// @param defaultPrice The default price for registrations
+    constructor(address owner, address feeManager, uint256 defaultPrice) {
+        _initializeOwner(owner);
+        Layout storage $ = getStorage();
+        Validator.checkAddress(feeManager);
+        ($.feeManager, $.defaultPrice) = (feeManager, defaultPrice);
+        emit FeeManagerSet(feeManager);
+        emit DefaultPriceSet(defaultPrice);
+    }
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                       FEE HOOK                             */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @inheritdoc IFeeHook
+    function onChargeFee(
+        bytes32,
+        address user,
+        uint256,
+        bytes calldata context
+    ) external returns (FeeHookResult memory result) {
+        Layout storage $ = getStorage();
+
+        // Restrict to authorized FeeManager only
+        if (msg.sender != $.feeManager) DomainFeeHook__Unauthorized.selector.revertWith();
+
+        result = _calculateFee(user, context);
+        // Increment registration count (state change)
+        ++$.registrationCount[user];
+    }
+
+    /// @notice Sets the fee manager address
+    /// @param feeManager The fee manager address authorized to call onChargeFee
+    function setFeeManager(address feeManager) external onlyOwner {
+        Validator.checkAddress(feeManager);
+        getStorage().feeManager = feeManager;
+        emit FeeManagerSet(feeManager);
+    }
+
+    /// @notice Sets the default price for registrations
+    /// @param price The new default price
+    function setDefaultPrice(uint256 price) external onlyOwner {
+        getStorage().defaultPrice = price;
+        emit DefaultPriceSet(price);
+    }
+
+    /// @notice Sets the price for a specific label length
+    /// @param length The label length
+    /// @param price The price for that length
+    function setPriceTier(uint256 length, uint256 price) external onlyOwner {
+        getStorage().priceTiers[length] = price;
+        emit PriceTierSet(length, price);
+    }
+
+    /// @notice Sets multiple price tiers at once
+    /// @param lengths Array of label lengths
+    /// @param prices Array of prices corresponding to each length
+    function setPriceTiers(
+        uint256[] calldata lengths,
+        uint256[] calldata prices
+    ) external onlyOwner {
+        if (lengths.length != prices.length) DomainFeeHook__LengthMismatch.selector.revertWith();
+        if (lengths.length > 10) DomainFeeHook__TooManyLengths.selector.revertWith();
+
+        Layout storage $ = getStorage();
+        for (uint256 i; i < lengths.length; ++i) {
+            $.priceTiers[lengths[i]] = prices[i];
+            emit PriceTierSet(lengths[i], prices[i]);
+        }
+    }
+
+    /// @inheritdoc IFeeHook
+    function calculateFee(
+        bytes32,
+        address user,
+        uint256,
+        bytes calldata context
+    ) external view returns (FeeHookResult memory) {
+        return _calculateFee(user, context);
+    }
+
+    /// @notice Returns the price for a specific label length
+    /// @param length The label length to query
+    /// @return The price for that length (or default if not set)
+    function getPrice(uint256 length) external view returns (uint256) {
+        Layout storage $ = getStorage();
+        uint256 price = $.priceTiers[length];
+        return price == 0 ? $.defaultPrice : price;
+    }
+
+    /// @notice Returns the default price for registrations
+    /// @return The default price
+    function getDefaultPrice() external view returns (uint256) {
+        return getStorage().defaultPrice;
+    }
+
+    /// @notice Returns the registration count for a user
+    /// @param user The user to query
+    /// @return The registration count
+    function getRegistrationCount(address user) external view returns (uint256) {
+        return getStorage().registrationCount[user];
+    }
+
+    /// @notice Returns the authorized fee manager address
+    /// @return The fee manager address
+    function getFeeManager() external view returns (address) {
+        return getStorage().feeManager;
+    }
+
+    /// @notice Internal fee calculation logic
+    /// @param user The user being charged
+    /// @param context ABI-encoded label length
+    /// @return result The fee calculation result
+    function _calculateFee(
+        address user,
+        bytes calldata context
+    ) internal view returns (FeeHookResult memory) {
+        Layout storage $ = getStorage();
+        // First registration is free
+        if ($.registrationCount[user] == 0) {
+            return FeeHookResult({finalFee: 0, metadata: ""});
+        }
+
+        // Decode label length from context
+        if (context.length < 32) DomainFeeHook__InvalidContext.selector.revertWith();
+        uint256 labelLength = abi.decode(context, (uint256));
+
+        // Get tiered price (fall back to default)
+        uint256 price = $.priceTiers[labelLength];
+        if (price == 0) price = $.defaultPrice;
+
+        return FeeHookResult({finalFee: price, metadata: ""});
+    }
+
+    /// @notice Returns the storage layout for the L2Registrar facet
+    /// @dev Uses diamond storage pattern to avoid slot collisions between facets
+    /// @return $ The storage pointer to the facet's layout
+    function getStorage() internal pure returns (Layout storage $) {
+        assembly {
+            $.slot := STORAGE_SLOT
+        }
+    }
+}

package/src/factory/facets/fee/FeeTypesLib.sol

@@ -26,6 +26,9 @@ library FeeTypesLib {
     /// @notice Fee for bot actions
     bytes32 internal constant BOT_ACTION = keccak256("FEE_TYPE.BOT_ACTION");
 
+    /// @notice Fee for domain registration
+    bytes32 internal constant DOMAIN_REGISTRATION = keccak256("FEE_TYPE.DOMAIN_REGISTRATION");
+
     /// @notice Generates fee type for membership based on currency
     /// @param currency The payment currency address
     /// @return The fee type identifier for the given currency

package/src/spaces/facets/ProtocolFeeLib.sol

@@ -23,6 +23,27 @@ library ProtocolFeeLib {
         address currency,
         uint256 amount,
         uint256 expectedFee
+    ) internal returns (uint256 protocolFee) {
+        return charge(spaceFactory, feeType, user, currency, amount, expectedFee, "");
+    }
+
+    /// @notice Charges protocol fee via FeeManager with ERC20 approval handling and extra data
+    /// @param spaceFactory The FeeManager address
+    /// @param feeType The type of fee being charged
+    /// @param user The user paying the fee
+    /// @param currency The payment currency (NATIVE_TOKEN or ERC20)
+    /// @param amount The base amount for fee calculation
+    /// @param expectedFee The pre-calculated expected fee
+    /// @param extraData Additional data for fee calculation (e.g., label length for domain registration)
+    /// @return protocolFee The actual fee charged
+    function charge(
+        address spaceFactory,
+        bytes32 feeType,
+        address user,
+        address currency,
+        uint256 amount,
+        uint256 expectedFee,
+        bytes memory extraData
     ) internal returns (uint256 protocolFee) {
         if (expectedFee == 0) return 0;
 
@@ -35,9 +56,43 @@ library ProtocolFeeLib {
             amount,
             currency,
             expectedFee,
-            ""
+            extraData
         );
 
         if (!isNative) currency.safeApprove(spaceFactory, 0);
     }
+
+    /// @notice Charges protocol fee via FeeManager, always calling chargeFee even when expectedFee is 0
+    /// @dev Use this when the fee hook needs to track calls regardless of fee amount (e.g., domain registration count)
+    /// @param spaceFactory The FeeManager address
+    /// @param feeType The type of fee being charged
+    /// @param user The user paying the fee
+    /// @param currency The payment currency (NATIVE_TOKEN or ERC20)
+    /// @param amount The base amount for fee calculation
+    /// @param expectedFee The pre-calculated expected fee
+    /// @param extraData Additional data for fee calculation
+    /// @return protocolFee The actual fee charged
+    function chargeAlways(
+        address spaceFactory,
+        bytes32 feeType,
+        address user,
+        address currency,
+        uint256 amount,
+        uint256 expectedFee,
+        bytes memory extraData
+    ) internal returns (uint256 protocolFee) {
+        bool isNative = currency == CurrencyTransfer.NATIVE_TOKEN;
+        if (!isNative && expectedFee > 0) currency.safeApproveWithRetry(spaceFactory, expectedFee);
+
+        protocolFee = IFeeManager(spaceFactory).chargeFee{value: isNative ? expectedFee : 0}(
+            feeType,
+            user,
+            amount,
+            currency,
+            expectedFee,
+            extraData
+        );
+
+        if (!isNative && expectedFee > 0) currency.safeApprove(spaceFactory, 0);
+    }
 }

package/LICENSE.txt

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2024 River Association
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.