Add UpgradeableRegistrarController

.gitmodules

@@ -34,3 +34,6 @@
 [submodule "lib/eas-contracts"]
 	path = lib/eas-contracts
 	url = https://github.com/ethereum-attestation-service/eas-contracts
+[submodule "lib/openzeppelin-contracts-upgradeable"]
+	path = lib/openzeppelin-contracts-upgradeable
+	url = https://github.com/openzeppelin/openzeppelin-contracts-upgradeable

foundry.toml

@@ -2,8 +2,19 @@
 src = "src"
 out = "out"
 libs = ["lib"]
-remappings = ["@ensdomains/buffer/=lib/buffer"]
+remappings = [
+    "@ensdomains/buffer/=lib/buffer", 
+    "solady/=lib/solady/src/",
+    "forge-std/=lib/forge-std/src/",
+    "ens-contracts/=lib/ens-contracts/contracts/",
+    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
+    "openzeppelin-contracts/=lib/openzeppelin-contracts",
+    "eas-contracts/=lib/eas-contracts/contracts/",
+    "verifications/=lib/verifications/src",
+    "openzeppelin-contracts-upgradeable/=lib/openzeppelin-contracts-upgradeable/contracts/"
+]
 fs_permissions = [{access = "read", path = "./script/premint/"}]
+auto_detect_remappings = false
 
 [rpc_endpoints]
 sepolia="${SEPOLIA_RPC_URL}"
@@ -12,4 +23,3 @@ base-sepolia="${BASE_SEPOLIA_RPC_URL}"
 [etherscan]
 sepolia={url = "https://api-sepolia.etherscan.io/api", key = "${ETHERSCAN_API_KEY}"}
 base-sepolia={url = "https://api-sepolia.basescan.org/api", key = "${BASE_ETHERSCAN_API_KEY}"}
-

src/L2/interface/IL2ReverseRegistrar.sol

@@ -0,0 +1,48 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.4;
+
+/// @notice Interface for the L2 Reverse Registrar.
+interface IL2ReverseRegistrar {
+    /// @notice Sets the `nameForAddr()` record for the calling account.
+    ///
+    /// @param name The name to set.
+    function setName(string memory name) external;
+
+    /// @notice Sets the `nameForAddr()` record for the addr provided account.
+    ///
+    /// @param addr The address to set the name for.
+    /// @param name The name to set.
+    function setNameForAddr(address addr, string memory name) external;
+
+    /// @notice Sets the `nameForAddr()` record for the addr provided account using a signature.
+    ///
+    /// @param addr The address to set the name for.
+    /// @param name The name to set.
+    /// @param coinTypes The coin types to set. Must be inclusive of the coin type for the contract.
+    /// @param signatureExpiry Date when the signature expires.
+    /// @param signature The signature from the addr.
+    function setNameForAddrWithSignature(
+        address addr,
+        uint256 signatureExpiry,
+        string memory name,
+        uint256[] memory coinTypes,
+        bytes memory signature
+    ) external;
+
+    /// @notice Sets the `nameForAddr()` record for the contract provided that is owned with `Ownable`.
+    ///
+    /// @param contractAddr The address of the contract to set the name for (implementing Ownable).
+    /// @param owner The owner of the contract (via Ownable).
+    /// @param signatureExpiry The expiry of the signature.
+    /// @param name The name to set.
+    /// @param coinTypes The coin types to set. Must be inclusive of the coin type for the contract.
+    /// @param signature The signature of an address that will return true on isValidSignature for the owner.
+    function setNameForOwnableWithSignature(
+        address contractAddr,
+        address owner,
+        uint256 signatureExpiry,
+        string memory name,
+        uint256[] memory coinTypes,
+        bytes memory signature
+    ) external;
+}

test/RegistrarController/RegisterPrice.t.sol

@@ -7,7 +7,7 @@ import {IPriceOracle} from "src/L2/interface/IPriceOracle.sol";
 contract RegisterPrice is RegistrarControllerBase {
     function test_returnsRegisterPrice_fromPricingOracle() public view {
         uint256 retPrice = controller.registerPrice(name, 0);
-        assertEq(retPrice, prices.DEFAULT_BASE_WEI() + prices.DEFAULT_PERMIUM_WEI());
+        assertEq(retPrice, prices.DEFAULT_BASE_WEI() + prices.DEFAULT_PREMIUM_WEI());
     }
 
     function test_fuzz_returnsRegisterPrice_fromPricingOracle(uint256 fuzzBase, uint256 fuzzPremium) public {

test/RegistrarController/RentPrice.t.sol

@@ -8,7 +8,7 @@ contract RentPrice is RegistrarControllerBase {
     function test_returnsPrice_fromPricingOracle() public view {
         IPriceOracle.Price memory retPrices = controller.rentPrice(name, 0);
         assertEq(retPrices.base, prices.DEFAULT_BASE_WEI());
-        assertEq(retPrices.premium, prices.DEFAULT_PERMIUM_WEI());
+        assertEq(retPrices.premium, prices.DEFAULT_PREMIUM_WEI());
     }
 
     function test_returnsPremium_ifTimeIsNearLaunchTime() public {

test/UpgradeableRegistrarController/Available.t.sol

@@ -0,0 +1,21 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {UpgradeableRegistrarControllerBase} from "./UpgradeableRegistrarControllerBase.t.sol";
+
+contract Available is UpgradeableRegistrarControllerBase {
+    function test_returnsFalse_whenNotAvailableOnBase() public {
+        base.setAvailable(uint256(nameLabel), false);
+        assertFalse(controller.available(name));
+    }
+
+    function test_returnsFalse_whenInvalidLength() public {
+        base.setAvailable(uint256(shortNameLabel), true);
+        assertFalse(controller.available(shortName));
+    }
+
+    function test_returnsTrue_whenValidAndAvailable() public {
+        base.setAvailable(uint256(nameLabel), true);
+        assertTrue(controller.available(name));
+    }
+}

test/UpgradeableRegistrarController/DiscountedRegister.t.sol

@@ -0,0 +1,148 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {UpgradeableRegistrarControllerBase} from "./UpgradeableRegistrarControllerBase.t.sol";
+import {UpgradeableRegistrarController} from "src/L2/UpgradeableRegistrarController.sol";
+import {IPriceOracle} from "src/L2/interface/IPriceOracle.sol";
+
+contract DiscountedRegister is UpgradeableRegistrarControllerBase {
+    function test_reverts_ifTheDiscountIsInactive() public {
+        UpgradeableRegistrarController.DiscountDetails memory inactiveDiscount = _getDefaultDiscount();
+        vm.deal(user, 1 ether);
+
+        inactiveDiscount.active = false;
+        vm.prank(owner);
+        controller.setDiscountDetails(inactiveDiscount);
+        uint256 price = controller.discountedRegisterPrice(name, duration, discountKey);
+
+        vm.expectRevert(abi.encodeWithSelector(UpgradeableRegistrarController.InactiveDiscount.selector, discountKey));
+        vm.prank(user);
+        controller.discountedRegister{value: price}(_getDefaultRegisterRequest(), discountKey, "");
+    }
+
+    function test_reverts_whenInvalidDiscountRegistration() public {
+        vm.deal(user, 1 ether);
+        vm.prank(owner);
+        controller.setDiscountDetails(_getDefaultDiscount());
+        validator.setReturnValue(false);
+        uint256 price = controller.discountedRegisterPrice(name, duration, discountKey);
+
+        vm.expectRevert(
+            abi.encodeWithSelector(UpgradeableRegistrarController.InvalidDiscount.selector, discountKey, "")
+        );
+        vm.prank(user);
+        controller.discountedRegister{value: price}(_getDefaultRegisterRequest(), discountKey, "");
+    }
+
+    function test_reverts_whenNameNotAvailble() public {
+        vm.deal(user, 1 ether);
+        vm.prank(owner);
+        controller.setDiscountDetails(_getDefaultDiscount());
+        uint256 price = controller.discountedRegisterPrice(name, duration, discountKey);
+        validator.setReturnValue(true);
+        base.setAvailable(uint256(nameLabel), false);
+
+        vm.expectRevert(abi.encodeWithSelector(UpgradeableRegistrarController.NameNotAvailable.selector, name));
+        vm.prank(user);
+        controller.discountedRegister{value: price}(_getDefaultRegisterRequest(), discountKey, "");
+    }
+
+    function test_reverts_whenDurationTooShort() public {
+        vm.deal(user, 1 ether);
+        vm.prank(owner);
+        controller.setDiscountDetails(_getDefaultDiscount());
+        uint256 price = controller.discountedRegisterPrice(name, duration, discountKey);
+        validator.setReturnValue(true);
+        base.setAvailable(uint256(nameLabel), true);
+
+        UpgradeableRegistrarController.RegisterRequest memory shortDurationRequest = _getDefaultRegisterRequest();
+        uint256 shortDuration = controller.MIN_REGISTRATION_DURATION() - 1;
+        shortDurationRequest.duration = shortDuration;
+        vm.expectRevert(abi.encodeWithSelector(UpgradeableRegistrarController.DurationTooShort.selector, shortDuration));
+        vm.prank(user);
+        controller.discountedRegister{value: price}(shortDurationRequest, discountKey, "");
+    }
+
+    function test_reverts_whenValueTooSmall() public {
+        vm.deal(user, 1 ether);
+        vm.prank(owner);
+        controller.setDiscountDetails(_getDefaultDiscount());
+        prices.setPrice(name, IPriceOracle.Price({base: 1 ether, premium: 0}));
+        uint256 price = controller.discountedRegisterPrice(name, duration, discountKey);
+        validator.setReturnValue(true);
+        base.setAvailable(uint256(nameLabel), true);
+
+        vm.expectRevert(UpgradeableRegistrarController.InsufficientValue.selector);
+        vm.prank(user);
+        controller.discountedRegister{value: price - 1}(_getDefaultRegisterRequest(), discountKey, "");
+    }
+
+    function test_registersWithDiscountSuccessfully() public {
+        vm.deal(user, 1 ether);
+        vm.prank(owner);
+        controller.setDiscountDetails(_getDefaultDiscount());
+        validator.setReturnValue(true);
+        base.setAvailable(uint256(nameLabel), true);
+        UpgradeableRegistrarController.RegisterRequest memory request = _getDefaultRegisterRequest();
+        uint256 expires = block.timestamp + request.duration;
+        base.setNameExpires(uint256(nameLabel), expires);
+        uint256 price = controller.discountedRegisterPrice(name, duration, discountKey);
+
+        vm.expectEmit(address(controller));
+        emit UpgradeableRegistrarController.ETHPaymentProcessed(user, price);
+        vm.expectEmit(address(controller));
+        emit UpgradeableRegistrarController.NameRegistered(request.name, nameLabel, user, expires);
+        vm.expectEmit(address(controller));
+        emit UpgradeableRegistrarController.DiscountApplied(user, discountKey);
+
+        vm.prank(user);
+        controller.discountedRegister{value: price}(request, discountKey, "");
+
+        bytes memory retByte = resolver.firstBytes();
+        assertEq(keccak256(retByte), keccak256(request.data[0]));
+        assertTrue(reverse.hasClaimed(user));
+        address[] memory addrs = new address[](1);
+        addrs[0] = user;
+        assertTrue(controller.hasRegisteredWithDiscount(addrs));
+    }
+
+    function test_sendsARefund_ifUserOverpayed() public {
+        vm.deal(user, 1 ether);
+        vm.prank(owner);
+        controller.setDiscountDetails(_getDefaultDiscount());
+        validator.setReturnValue(true);
+        base.setAvailable(uint256(nameLabel), true);
+        UpgradeableRegistrarController.RegisterRequest memory request = _getDefaultRegisterRequest();
+        uint256 expires = block.timestamp + request.duration;
+        base.setNameExpires(uint256(nameLabel), expires);
+        uint256 price = controller.discountedRegisterPrice(name, duration, discountKey);
+
+        vm.prank(user);
+        controller.discountedRegister{value: price + 1}(request, discountKey, "");
+
+        uint256 expectedBalance = 1 ether - price;
+        assertEq(user.balance, expectedBalance);
+    }
+
+    function test_reverts_ifTheRegistrantHasAlreadyRegisteredWithDiscount() public {
+        vm.deal(user, 1 ether);
+        vm.prank(owner);
+        controller.setDiscountDetails(_getDefaultDiscount());
+        validator.setReturnValue(true);
+        base.setAvailable(uint256(nameLabel), true);
+        UpgradeableRegistrarController.RegisterRequest memory request = _getDefaultRegisterRequest();
+        uint256 expires = block.timestamp + request.duration;
+        base.setNameExpires(uint256(nameLabel), expires);
+        uint256 price = controller.discountedRegisterPrice(name, duration, discountKey);
+
+        vm.prank(user);
+        controller.discountedRegister{value: price}(request, discountKey, "");
+
+        vm.expectRevert(
+            abi.encodeWithSelector(UpgradeableRegistrarController.AlreadyRegisteredWithDiscount.selector, user)
+        );
+        request.name = "newname";
+        vm.prank(user);
+        controller.discountedRegister{value: price}(request, discountKey, "");
+    }
+}

test/UpgradeableRegistrarController/DiscountedRegisterPrice.t.sol

@@ -0,0 +1,29 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {UpgradeableRegistrarControllerBase} from "./UpgradeableRegistrarControllerBase.t.sol";
+import {RegistrarController} from "src/L2/RegistrarController.sol";
+import {IPriceOracle} from "src/L2/interface/IPriceOracle.sol";
+
+contract DiscountedRegisterPrice is UpgradeableRegistrarControllerBase {
+    function test_returnsADiscountedPrice_whenThePriceIsGreaterThanTheDiscount(uint256 price) public {
+        vm.assume(price > discountAmount);
+        prices.setPrice(name, IPriceOracle.Price({base: price, premium: 0}));
+        vm.prank(owner);
+        controller.setDiscountDetails(_getDefaultDiscount());
+
+        uint256 expectedPrice = price - discountAmount;
+        uint256 retPrice = controller.discountedRegisterPrice(name, duration, discountKey);
+        assertEq(retPrice, expectedPrice);
+    }
+
+    function test_returnsZero_whenThePriceIsLessThanOrEqualToTheDiscount(uint256 price) public {
+        vm.assume(price > 0 && price <= discountAmount);
+        prices.setPrice(name, IPriceOracle.Price({base: price, premium: 0}));
+        vm.prank(owner);
+        controller.setDiscountDetails(_getDefaultDiscount());
+
+        uint256 retPrice = controller.discountedRegisterPrice(name, duration, discountKey);
+        assertEq(retPrice, 0);
+    }
+}

test/UpgradeableRegistrarController/Register.t.sol

@@ -0,0 +1,86 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {UpgradeableRegistrarControllerBase} from "./UpgradeableRegistrarControllerBase.t.sol";
+import {UpgradeableRegistrarController} from "src/L2/UpgradeableRegistrarController.sol";
+import {IPriceOracle} from "src/L2/interface/IPriceOracle.sol";
+
+contract Register is UpgradeableRegistrarControllerBase {
+    function test_reverts_whenResolverRequiredAndNotSupplied() public {
+        vm.deal(user, 1 ether);
+        uint256 price = controller.registerPrice(name, duration);
+        vm.expectRevert(UpgradeableRegistrarController.ResolverRequiredWhenDataSupplied.selector);
+        vm.prank(user);
+        UpgradeableRegistrarController.RegisterRequest memory noResolverRequest = _getDefaultRegisterRequest();
+        noResolverRequest.resolver = address(0);
+        controller.register{value: price}(noResolverRequest);
+    }
+
+    function test_reverts_whenNameNotAvailble() public {
+        vm.deal(user, 1 ether);
+        uint256 price = controller.registerPrice(name, duration);
+        base.setAvailable(uint256(nameLabel), false);
+        vm.expectRevert(abi.encodeWithSelector(UpgradeableRegistrarController.NameNotAvailable.selector, name));
+        vm.prank(user);
+        controller.register{value: price}(_getDefaultRegisterRequest());
+    }
+
+    function test_reverts_whenDurationTooShort() public {
+        vm.deal(user, 1 ether);
+        uint256 price = controller.registerPrice(name, duration);
+        base.setAvailable(uint256(nameLabel), true);
+        UpgradeableRegistrarController.RegisterRequest memory shortDurationRequest = _getDefaultRegisterRequest();
+        uint256 shortDuration = controller.MIN_REGISTRATION_DURATION() - 1;
+        shortDurationRequest.duration = shortDuration;
+        vm.expectRevert(abi.encodeWithSelector(UpgradeableRegistrarController.DurationTooShort.selector, shortDuration));
+        vm.prank(user);
+        controller.register{value: price}(shortDurationRequest);
+    }
+
+    function test_reverts_whenValueTooSmall() public {
+        vm.deal(user, 1 ether);
+        uint256 price = controller.registerPrice(name, duration);
+        base.setAvailable(uint256(nameLabel), true);
+        vm.expectRevert(UpgradeableRegistrarController.InsufficientValue.selector);
+        vm.prank(user);
+        controller.register{value: price - 1}(_getDefaultRegisterRequest());
+    }
+
+    function test_registersSuccessfully() public {
+        vm.deal(user, 1 ether);
+        UpgradeableRegistrarController.RegisterRequest memory request = _getDefaultRegisterRequest();
+
+        base.setAvailable(uint256(nameLabel), true);
+        uint256 expires = block.timestamp + request.duration;
+        base.setNameExpires(uint256(nameLabel), expires);
+        uint256 price = controller.registerPrice(request.name, request.duration);
+
+        vm.expectEmit(address(controller));
+        emit UpgradeableRegistrarController.ETHPaymentProcessed(user, price);
+        vm.expectEmit(address(controller));
+        emit UpgradeableRegistrarController.NameRegistered(request.name, nameLabel, user, expires);
+
+        vm.prank(user);
+        controller.register{value: price}(request);
+
+        bytes memory retByte = resolver.firstBytes();
+        assertEq(keccak256(retByte), keccak256(request.data[0]));
+        assertTrue(reverse.hasClaimed(user));
+    }
+
+    function test_sendsARefund_ifUserOverpayed() public {
+        vm.deal(user, 1 ether);
+        UpgradeableRegistrarController.RegisterRequest memory request = _getDefaultRegisterRequest();
+
+        base.setAvailable(uint256(nameLabel), true);
+        uint256 expires = block.timestamp + request.duration;
+        base.setNameExpires(uint256(nameLabel), expires);
+        uint256 price = controller.registerPrice(request.name, request.duration);
+
+        vm.prank(user);
+        controller.register{value: price + 1}(request);
+
+        uint256 expectedBalance = 1 ether - price;
+        assertEq(user.balance, expectedBalance);
+    }
+}