Feature/subdomain registrar

contracts/subdomainregistrar/SubdomainRegistrar.sol

@@ -0,0 +1,170 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import "../wrapper/INameWrapper.sol";
+import "@openzeppelin/contracts/utils/Address.sol";
+import {IERC20} from "@openzeppelin/contracts/token/ERC20/IERC20.sol";
+import {ERC1155Holder} from "@openzeppelin/contracts/token/ERC1155/utils/ERC1155Holder.sol";
+import "hardhat/console.sol";
+
+error Unavailable();
+error Unauthorised(bytes32 node);
+error InsufficientFunds();
+error NameNotRegistered();
+
+struct Name {
+    uint256 registrationFee; // per second
+    address token; // ERC20 token
+    address beneficiary;
+}
+
+contract SubdomainRegistrar is ERC1155Holder {
+    INameWrapper public immutable wrapper;
+    using Address for address;
+
+    mapping(bytes32 => Name) public names;
+    mapping(bytes32 => uint256) public expiries;
+
+    event NameRenewed(bytes32 node, uint256 duration);
+
+    constructor(INameWrapper _wrapper) {
+        wrapper = _wrapper;
+    }
+
+    modifier onlyOwner(bytes32 node) {
+        if (!wrapper.isTokenOwnerOrApproved(node, msg.sender)) {
+            revert Unauthorised(node);
+        }
+        _;
+    }
+
+    function setupDomain(
+        bytes32 node,
+        address token,
+        uint256 fee,
+        address beneficiary
+    ) public onlyOwner(node) {
+        setRegistrationFee(node, fee);
+        names[node].beneficiary = beneficiary;
+        names[node].token = token;
+    }
+
+    function setRegistrationFee(bytes32 node, uint256 fee)
+        public
+        onlyOwner(node)
+    {
+        names[node].registrationFee = fee;
+    }
+
+    function available(bytes32 node) public returns (bool) {
+        try wrapper.getFuses(node) returns (uint32, uint64 expiry) {
+            return expiry < block.timestamp;
+        } catch {
+            return true;
+        }
+    }
+
+    function register(
+        bytes32 parentNode,
+        string calldata label,
+        address newOwner,
+        address resolver,
+        uint32 fuses,
+        uint64 duration,
+        bytes[] calldata records
+    ) public payable {
+        bytes32 node = keccak256(
+            abi.encodePacked(parentNode, keccak256(bytes(label)))
+        );
+        uint256 fee = duration * names[parentNode].registrationFee;
+        // check max registration possible
+        // refund the rest
+
+        if (!available(node)) {
+            revert Unavailable();
+        }
+        if (msg.value < fee) {
+            revert InsufficientFunds();
+        }
+
+        if (records.length > 0) {
+            wrapper.setSubnodeOwner(
+                parentNode,
+                label,
+                address(this),
+                0,
+                uint64(block.timestamp + duration)
+            );
+            _setRecords(node, resolver, records);
+        }
+
+        wrapper.setSubnodeRecord(
+            parentNode,
+            label,
+            newOwner,
+            resolver,
+            0,
+            fuses | PARENT_CANNOT_CONTROL, // burn the ability for the parent to control
+            uint64(block.timestamp + duration)
+        );
+
+        IERC20(names[parentNode].token).transferFrom(
+            msg.sender,
+            address(names[parentNode].beneficiary),
+            fee
+        );
+    }
+
+    function renew(
+        bytes32 parentNode,
+        bytes32 labelhash,
+        uint64 duration
+    ) external payable returns (uint64 newExpiry) {
+        bytes32 node = _makeNode(parentNode, labelhash);
+        (, uint64 expiry) = wrapper.getFuses(node);
+        if (expiry < block.timestamp) {
+            revert NameNotRegistered();
+        }
+
+        uint256 fee = duration * names[parentNode].registrationFee;
+
+        newExpiry = expiry += duration;
+
+        wrapper.setChildFuses(parentNode, labelhash, 0, newExpiry);
+
+        IERC20(names[parentNode].token).transferFrom(
+            msg.sender,
+            address(names[parentNode].beneficiary),
+            fee
+        );
+
+        emit NameRenewed(node, newExpiry);
+    }
+
+    function _setRecords(
+        bytes32 node,
+        address resolver,
+        bytes[] calldata records
+    ) internal {
+        for (uint256 i = 0; i < records.length; i++) {
+            // check first few bytes are namehash
+            bytes32 txNamehash = bytes32(records[i][4:36]);
+            require(
+                txNamehash == node,
+                "SubdomainRegistrar: Namehash on record do not match the name being registered"
+            );
+            resolver.functionCall(
+                records[i],
+                "SubdomainRegistrar: Failed to set Record"
+            );
+        }
+    }
+
+    function _makeNode(bytes32 node, bytes32 labelhash)
+        private
+        pure
+        returns (bytes32)
+    {
+        return keccak256(abi.encodePacked(node, labelhash));
+    }
+}

contracts/subdomainregistrar/mocks/MockERC20.sol

@@ -0,0 +1,18 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.13;
+
+import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
+
+contract MockERC20 is ERC20 {
+    constructor(
+        string memory name,
+        string memory symbol,
+        address[] memory addresses
+    ) ERC20(name, symbol) {
+        _mint(msg.sender, 100 * 10**uint256(decimals()));
+
+        for (uint256 i = 0; i < addresses.length; i++) {
+            _mint(addresses[i], 100 * 10**uint256(decimals()));
+        }
+    }
+}

contracts/wrapper/INameWrapper.sol

@@ -36,6 +36,8 @@ interface INameWrapper is IERC1155 {
 
     function names(bytes32) external view returns (bytes memory);
 
+    function ownerOf(uint256) external view returns (address);
+
     function wrap(
         bytes calldata name,
         address wrappedOwner,
@@ -121,8 +123,6 @@ interface INameWrapper is IERC1155 {
 
     function setTTL(bytes32 node, uint64 ttl) external;
 
-    function ownerOf(uint256 id) external returns (address owner);
-
     function getFuses(bytes32 node)
         external
         returns (uint32 fuses, uint64 expiry);

contracts/wrapper/NameWrapper.sol

@@ -85,17 +85,6 @@ contract NameWrapper is
             super.supportsInterface(interfaceId);
     }
 
-    /* ERC1155 */
-
-    function ownerOf(uint256 id)
-        public
-        view
-        override(ERC1155Fuse, INameWrapper)
-        returns (address owner)
-    {
-        return super.ownerOf(id);
-    }
-
     /* Metadata service */
 
     /**
@@ -284,6 +273,21 @@ contract NameWrapper is
         _setData(node, owner, fuses, expiry);
     }
 
+    /**
+     * @dev Returns the owner of the ERC1155 token
+     *
+     * @param tokenId The hash of the label to register (eg, `keccak256('foo')`, for 'foo.eth').
+     * @return expires The expiry date of the name, in seconds since the Unix epoch.
+     */
+    function ownerOf(uint256 tokenId)
+        public
+        view
+        override(ERC1155Fuse, INameWrapper)
+        returns (address)
+    {
+        return super.ownerOf(tokenId);
+    }
+
     /**
      * @notice Wraps a non .eth domain, of any kind. Could be a DNSSEC name vitalik.xyz or a subdomain
      * @dev Can be called by the owner in the registry or an authorised caller in the registry