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

@@ -1,8 +1,8 @@
 // SPDX-License-Identifier: MIT
-pragma solidity ^0.8.4;
+pragma solidity ^0.8.23;
 
 /// @notice Interface for the L2 Reverse Registrar.
-///     https://github.com/ensdomains/ens-contracts/pull/265
+///     https://github.com/ensdomains/ens-contracts/tree/feature/simplify-reverse-resolver
 interface IL2ReverseRegistrar {
     /// @notice Sets the `nameForAddr()` record for the calling account.
     ///

src/L2/interface/IReverseRegistrarV2.sol

@@ -0,0 +1,27 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+/// @title Interface for ReverseRegistrarV2
+interface IReverseRegistrarV2 {
+    /// @notice Transfers ownership of the base-specific reverse ENS record for `msg.sender` to the provided `owner`.
+    ///
+    /// @param owner The address to set as the owner of the reverse record in ENS.
+    ///
+    /// @return The ENS node hash of the Base network-specific reverse record.
+    function claim(address owner) external returns (bytes32);
+
+    /// @notice Sets the reverse record `name` for `addr`.
+    ///
+    /// @param addr The name records will be set for this address.
+    /// @param signatureExpiry The timestamp expiration of the signature.
+    /// @param name The name that will be stored for `addr`.
+    /// @param cointypes The array of networks-as-cointypes used in replayable reverse sets.
+    /// @param signature The signature bytes.
+    function setNameForAddrWithSignature(
+        address addr,
+        uint256 signatureExpiry,
+        string calldata name,
+        uint256[] memory cointypes,
+        bytes memory signature
+    ) external returns (bytes32);
+}

test/Integration/IntegrationTestBase.t.sol

@@ -118,10 +118,18 @@ contract IntegrationTestBase is Test {
         vm.stopPrank();
     }
 
-    function test_integration_register() public {
-        vm.stopPrank();
-        vm.startPrank(alice);
+    function _getBasePrices() internal pure returns (uint256[] memory) {
+        uint256[] memory rentPrices = new uint256[](6);
+        rentPrices[0] = 316_808_781_402;
+        rentPrices[1] = 31_680_878_140;
+        rentPrices[2] = 3_168_087_814;
+        rentPrices[3] = 316_808_781;
+        rentPrices[4] = 31_680_878;
+        rentPrices[5] = 3_168_087; // 3,168,808.781402895 = 1e14 / (365.25 * 24 * 3600)
+        return rentPrices;
+    }
 
+    function _registerAlice() internal {
         string memory name = "alice";
         uint256 duration = 365.25 days;
 
@@ -139,15 +147,4 @@ contract IntegrationTestBase is Test {
 
         registrarController.register{value: registerPrice}(request);
     }
-
-    function _getBasePrices() internal pure returns (uint256[] memory) {
-        uint256[] memory rentPrices = new uint256[](6);
-        rentPrices[0] = 316_808_781_402;
-        rentPrices[1] = 31_680_878_140;
-        rentPrices[2] = 3_168_087_814;
-        rentPrices[3] = 316_808_781;
-        rentPrices[4] = 31_680_878;
-        rentPrices[5] = 3_168_087; // 3,168,808.781402895 = 1e14 / (365.25 * 24 * 3600)
-        return rentPrices;
-    }
 }

test/Integration/SwitchToUpgradeableRegistrarController.t.sol

@@ -0,0 +1,119 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Test} from "forge-std/Test.sol";
+import {console} from "forge-std/console.sol";
+
+import {IntegrationTestBase} from "./IntegrationTestBase.t.sol";
+import {MockL2ReverseRegistrar} from "test/mocks/MockL2ReverseRegistrar.sol";
+import {MockReverseRegistrarV2} from "test/mocks/MockReverseRegistrarV2.sol";
+
+import {ExponentialPremiumPriceOracle} from "src/L2/ExponentialPremiumPriceOracle.sol";
+import {IPriceOracle} from "src/L2/interface/IPriceOracle.sol";
+import {UpgradeableRegistrarController} from "src/L2/UpgradeableRegistrarController.sol";
+import {TransparentUpgradeableProxy} from
+    "openzeppelin-contracts/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+
+import {BASE_ETH_NODE, GRACE_PERIOD} from "src/util/Constants.sol";
+
+contract SwitchToUpgradeableRegistrarController is IntegrationTestBase {
+    UpgradeableRegistrarController public controllerImpl;
+    UpgradeableRegistrarController public controller;
+    TransparentUpgradeableProxy public proxy;
+    MockL2ReverseRegistrar public l2ReverseRegistrar;
+    MockReverseRegistrarV2 public reverseRegistrarv2;
+
+    address admin;
+    uint256 duration = 365.25 days;
+
+    uint256 constant UPGRADE_TIMESTAMP = 1746057600; // May 1 2025
+
+    function setUp() public override {
+        super.setUp();
+        _registerAlice();
+
+        vm.warp(UPGRADE_TIMESTAMP);
+
+        admin = makeAddr("admin");
+
+        l2ReverseRegistrar = new MockL2ReverseRegistrar();
+        reverseRegistrarv2 = new MockReverseRegistrarV2();
+
+        exponentialPremiumPriceOracle = new ExponentialPremiumPriceOracle(
+            _getBasePrices(), EXPIRY_AUCTION_START_PRICE, EXPIRY_AUCTION_DURATION_DAYS
+        );
+
+        bytes memory controllerInitData = abi.encodeWithSelector(
+            UpgradeableRegistrarController.initialize.selector,
+            baseRegistrar,
+            exponentialPremiumPriceOracle,
+            reverseRegistrarv2,
+            owner,
+            BASE_ETH_NODE,
+            ".base.eth",
+            payments,
+            address(registrarController),
+            address(l2ReverseRegistrar)
+        );
+
+        controllerImpl = new UpgradeableRegistrarController();
+        proxy = new TransparentUpgradeableProxy(address(controllerImpl), admin, controllerInitData);
+        controller = UpgradeableRegistrarController(address(proxy));
+
+        _postDeployConfig();
+    }
+
+    function _postDeployConfig() internal {
+        vm.startPrank(owner);
+        baseRegistrar.addController(address(proxy));
+        reverseRegistrar.setControllerApproval(address(proxy), true);
+        defaultL2Resolver.setRegistrarController(address(proxy));
+        vm.stopPrank();
+    }
+
+    function test_canRegisterANewName() public {
+        string memory name = "new-name";
+        uint256[] memory coinTypes = new uint256[](1);
+        coinTypes[0] = 0x80000000 | 0x00002105;
+
+        uint256 registerPrice = controller.registerPrice(name, duration);
+        uint256 expectedPrice = _getBasePrices()[4] * duration;
+        vm.assertEq(registerPrice, expectedPrice);
+
+        UpgradeableRegistrarController.RegisterRequest memory request = UpgradeableRegistrarController.RegisterRequest({
+            name: name,
+            owner: alice,
+            duration: duration,
+            resolver: address(defaultL2Resolver),
+            data: new bytes[](0),
+            reverseRecord: true,
+            coinTypes: coinTypes,
+            signatureExpiry: block.timestamp,
+            signature: ""
+        });
+
+        vm.deal(alice, 1 ether);
+        vm.prank(alice);
+        controller.register{value: registerPrice}(request);
+    }
+
+    function test_canRenewExistingName() public {
+        string memory name = "alice";
+
+        IPriceOracle.Price memory prices = controller.rentPrice(name, duration);
+
+        vm.deal(alice, 1 ether);
+        vm.prank(alice);
+        controller.renew{value: prices.base}(name, duration);
+    }
+
+    function test_canRenewNameInGracePeriod() public {
+        string memory name = "alice";
+
+        IPriceOracle.Price memory prices = controller.rentPrice(name, duration);
+
+        vm.deal(alice, 1 ether);
+        vm.warp(LAUNCH_TIME + duration + GRACE_PERIOD - 1);
+        controller.renew{value: prices.base}(name, duration);
+    }
+}

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/ReverseRegistrarV2/SetBaseForwardAddr.t.sol

@@ -96,7 +96,7 @@ contract SetBaseForwardAddr is ReverseRegistrarV2Base {
         fwdNode = keccak256(abi.encodePacked(BASE_ETH_NODE, nameLabel));
     }
 
-    function _getNodes() internal returns (bytes32[] memory nodes) {
+    function _getNodes() internal view returns (bytes32[] memory nodes) {
         nodes = new bytes32[](1);
         nodes[0] = fwdNode;
     }

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));
+    }
+}