Add Launch Auction Price Oracle with reduced half life

src/L2/LaunchAuctionPriceOracle.sol

@@ -0,0 +1,91 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {FixedPointMathLib} from "solady/utils/FixedPointMathLib.sol";
+
+import {EDAPrice} from "src/lib/EDAPrice.sol";
+import {StablePriceOracle} from "src/L2/StablePriceOracle.sol";
+
+/// @title Launch Auction Price Oracle
+///
+/// @notice The mechanism by which names are auctioned upon Basenames public launch. The RegistrarController
+///     Passes the `launchTime` in place of expiry for all new names. The half life of this contract is hard-coded
+///     to 1.5 hours, accomplished by bitshifting the `endValue` and by passing this period into the exponential decay
+///     calculation.
+///
+///     Inspired by the `ExponentialPremiumPriceOracle` implemented by ENS:
+///     https://github.com/ensdomains/ens-contracts/blob/staging/contracts/ethregistrar/ExponentialPremiumPriceOracle.sol
+///
+/// @author Coinbase (https://github.com/base-org/usernames)
+contract LaunchAuctionPriceOracle is StablePriceOracle {
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          STORAGE                           */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+    /// @notice Starting premium for the dutch auction.
+    uint256 public immutable startPremium;
+
+    /// @notice Ending value of the auction, calculated on construction.
+    uint256 public immutable endValue;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          CONSTANTS                         */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice The half-life of the premium price decay in seconds.
+    uint256 constant PRICE_PREMIUM_HALF_LIFE = 1.5 hours;
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                          ERRORS                            */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Thrown when the auction duration is not cleanly divisible by the auction halflife.
+    error InvalidDuration();
+
+    /*´:°•.°+.*•´.*:˚.°*.˚•´.°:°•.°•.*•´.*:˚.°*.˚•´.°:°•.°+.*•´.*:*/
+    /*                        IMPLEMENTATION                      */
+    /*.•°:°.´+˚.*°.˚:*.´•*.+°.•°:´*.´•*.•°.•°:°.´:•˚°.*°.˚:*.´+°.•*/
+
+    /// @notice Construction of the premium pricing oracle.
+    ///
+    /// @param rentPrices The base prices passed to construction of the StablePriceOracle.
+    /// @param startPremium_ The starting price for the dutch auction, denominated in wei.
+    /// @param totalHours    The total duration (in hours) for the dutch auction.
+    constructor(uint256[] memory rentPrices, uint256 startPremium_, uint256 totalHours) StablePriceOracle(rentPrices) {
+        startPremium = startPremium_;
+        if ((totalHours * 1 hours) % PRICE_PREMIUM_HALF_LIFE != 0) revert InvalidDuration();
+        endValue = startPremium >> ((totalHours * 1 hours) / PRICE_PREMIUM_HALF_LIFE);
+    }
+
+    /// @notice The internal method for calculating pricing premium
+    ///
+    /// @dev This method handles three cases:
+    ///     1. The name is not yet expired, premium = 0.
+    ///     2. The name is expired and in the auction window, premium = calculated decayed premium.
+    ///     3. The name is expired and outside of the auction window, premium = 0.
+    ///
+    /// @param expires Timestamp of when the name will expire.
+    ///
+    /// @return Price premium denominated in wei.
+    function _premium(string memory, uint256 expires, uint256) internal view override returns (uint256) {
+        if (expires > block.timestamp) {
+            return 0;
+        }
+        uint256 elapsed = block.timestamp - expires;
+        uint256 premium_ = decayedPremium(elapsed);
+        if (premium_ > endValue) {
+            return premium_ - endValue;
+        }
+        return 0;
+    }
+
+    /// @notice The mechanism for calculating the decayed premium.
+    ///
+    /// @param elapsed Seconds elapsed since the auction started.
+    ///
+    /// @return Dacayed price premium denominated in wei.
+    function decayedPremium(uint256 elapsed) public view returns (uint256) {
+        /// @dev 50% decay per period in wad format
+        uint256 perPeriodDecayPercentWad = FixedPointMathLib.WAD / 2;
+        return EDAPrice.currentPrice(startPremium, elapsed, PRICE_PREMIUM_HALF_LIFE, perPeriodDecayPercentWad);
+    }
+}

src/L2/StablePriceOracle.sol

@@ -40,7 +40,7 @@ contract StablePriceOracle is IPriceOracle {
 
     /// @notice Price Oracle constructor which sets the immutably stored prices.
     ///
-    /// @param _rentPrices An array of prices orderd in increasing length.
+    /// @param _rentPrices An array of prices ordered in increasing length.
     constructor(uint256[] memory _rentPrices) {
         price1Letter = _rentPrices[0];
         price2Letter = _rentPrices[1];

test/IntegrationTest.t.sol → test/Integration/IntegrationTestBase.t.sol

@@ -14,6 +14,7 @@ import {IPriceOracle} from "src/L2/interface/IPriceOracle.sol";
 import {IReverseRegistrar} from "src/L2/interface/IReverseRegistrar.sol";
 import {L1Resolver} from "src/L1/L1Resolver.sol";
 import {L2Resolver} from "src/L2/L2Resolver.sol";
+import {LaunchAuctionPriceOracle} from "src/L2/LaunchAuctionPriceOracle.sol";
 import {RegistrarController} from "src/L2/RegistrarController.sol";
 import {Registry} from "src/L2/Registry.sol";
 import {ReverseRegistrar} from "src/L2/ReverseRegistrar.sol";
@@ -27,7 +28,7 @@ import {
     BASE_ETH_NAME
 } from "src/util/Constants.sol";
 
-contract IntegrationTest is Test {
+contract IntegrationTestBase is Test {
     address owner;
     address signer;
     address alice;
@@ -40,6 +41,7 @@ contract IntegrationTest is Test {
     RegistrarController registrarController;
     L2Resolver defaultL2Resolver;
     ReverseRegistrar reverseRegistrar;
+    LaunchAuctionPriceOracle launchAuctionPriceOracle;
     ExponentialPremiumPriceOracle exponentialPremiumPriceOracle;
 
     AttestationValidator attestationValidator;
@@ -52,7 +54,14 @@ contract IntegrationTest is Test {
     bytes32 constant REVERSE_LABEL = 0xdec08c9dbbdd0890e300eb5062089b2d4b1c40e3673bbccb5423f7b37dcf9a9c;
     bytes32 constant ADDR_LABEL = 0xe5e14487b78f85faa6e1808e89246cf57dd34831548ff2e6097380d98db2504a;
 
-    function setUp() public {
+    uint256 constant LAUNCH_AUCTION_START_PRICE = 100 ether;
+    uint256 constant LAUNCH_AUCTION_DURATION_HOURS = 36;
+    uint256 constant LAUNCH_TIME = 1723420800; // Monday, August 12, 2024 12:00:00 AM GMT
+
+    uint256 constant EXPIRY_AUCTION_START_PRICE = 1000 ether;
+    uint256 constant EXPIRY_AUCTION_DURATION_DAYS = 21;
+
+    function setUp() public virtual {
         owner = makeAddr("owner");
         signer = makeAddr("signer");
         alice = makeAddr("alice");
@@ -61,32 +70,23 @@ contract IntegrationTest is Test {
         registry = new Registry(owner);
         reverseRegistrar = new ReverseRegistrar(registry, owner, BASE_REVERSE_NODE);
 
-        uint256[] memory rentPrices = new uint256[](6);
-        rentPrices[0] = 317_097_919_837;
-        rentPrices[1] = 31_709_791_983;
-        rentPrices[2] = 3_170_979_198;
-        rentPrices[3] = 317_097_919;
-        rentPrices[4] = 31_709_791;
-        rentPrices[5] = 3_170_979; //3,170,979.1983764587 = 1e14 / (365 * 24 * 3600)
-
-        exponentialPremiumPriceOracle = new ExponentialPremiumPriceOracle(rentPrices, 1e18, 21);
+        launchAuctionPriceOracle =
+            new LaunchAuctionPriceOracle(_getBasePrices(), LAUNCH_AUCTION_START_PRICE, LAUNCH_AUCTION_DURATION_HOURS);
+
         baseRegistrar = new BaseRegistrar(registry, owner, BASE_ETH_NODE, "", "");
 
         _establishNamespaces();
 
         registrarController = new RegistrarController(
             baseRegistrar,
-            exponentialPremiumPriceOracle,
+            IPriceOracle(launchAuctionPriceOracle),
             IReverseRegistrar(address(reverseRegistrar)),
             owner,
             BASE_ETH_NODE,
             ".base.eth",
             payments
         );
 
-        vm.prank(owner);
-        baseRegistrar.addController(address(registrarController));
-
         vm.prank(owner);
         reverseRegistrar.setControllerApproval(address(registrarController), true);
 
@@ -98,7 +98,12 @@ contract IntegrationTest is Test {
         vm.prank(owner);
         reverseRegistrar.setName("rootOwner");
 
-        vm.warp(GRACE_PERIOD * 10);
+        vm.prank(owner);
+        baseRegistrar.addController(address(registrarController));
+
+        vm.prank(owner);
+        registrarController.setLaunchTime(LAUNCH_TIME);
+        vm.warp(LAUNCH_TIME);
     }
 
     function _establishNamespaces() internal {
@@ -134,4 +139,15 @@ contract IntegrationTest 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/LaunchAuctionRegistrations.t.sol

@@ -0,0 +1,74 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Test, console} from "forge-std/Test.sol";
+import {IntegrationTestBase} from "./IntegrationTestBase.t.sol";
+import {RegistrarController} from "src/L2/RegistrarController.sol";
+
+contract LaunchAuctionRegistrations is IntegrationTestBase {
+    string name = "alice";
+    uint256 duration = 365.25 days;
+    uint256 id = uint256(keccak256(bytes(name)));
+
+    function test_register_at_LaunchTime() public {
+        vm.warp(LAUNCH_TIME);
+        _register("launch time");
+    }
+
+    function test_register_oneHourAfter_LaunchTime() public {
+        vm.warp(LAUNCH_TIME + 1 hours);
+        _register("launch + 1 hour");
+    }
+
+    function test_register_threeHoursAfter_LaunchTime() public {
+        vm.warp(LAUNCH_TIME + 3 hours);
+        _register("launch + 3 hours");
+    }
+
+    function test_register_oneDayAfter_LaunchTime() public {
+        vm.warp(LAUNCH_TIME + 1 days);
+        _register("launch + 1 day");
+    }
+
+    function test_register_justBefore_launchAuctionEnds() public {
+        vm.warp(LAUNCH_TIME + (LAUNCH_AUCTION_DURATION_HOURS * 1 hours) - 1);
+        _register("1 second before auction ends");
+    }
+
+    function test_register_justAfter_launchAuctionEnds() public {
+        vm.warp(LAUNCH_TIME + (LAUNCH_AUCTION_DURATION_HOURS * 1 hours));
+        _register("auction end time");
+    }
+
+    function test_register_oneDayAfter_launchAuctionEnds() public {
+        vm.warp(LAUNCH_TIME + (LAUNCH_AUCTION_DURATION_HOURS * 1 hours) + 1 days);
+        _register("1 day after auction ends");
+    }
+
+    function _register(string memory logCase) internal {
+        uint256 price = registrarController.registerPrice(name, duration);
+        vm.deal(alice, price);
+
+        RegistrarController.RegisterRequest memory request = RegistrarController.RegisterRequest({
+            name: name,
+            owner: alice,
+            duration: duration,
+            resolver: address(defaultL2Resolver),
+            data: new bytes[](0),
+            reverseRecord: true
+        });
+
+        vm.expectEmit(address(registrarController));
+        emit RegistrarController.ETHPaymentProcessed(alice, price);
+
+        vm.prank(alice);
+        registrarController.register{value: price}(request);
+        assertEq(baseRegistrar.ownerOf(id), alice);
+
+        console.log("______________________________");
+        console.log("Registering at", logCase);
+        console.log("Timestamp: ", block.timestamp);
+        console.log("Price (WEI): ", price);
+        console.log("______________________________");
+    }
+}

test/Integration/PostLaunchAuctionConfig.t.sol

@@ -0,0 +1,101 @@
+//SPDX-License-Identifier: MIT
+pragma solidity ^0.8.23;
+
+import {Test, console} from "forge-std/Test.sol";
+import {IntegrationTestBase} from "./IntegrationTestBase.t.sol";
+import {RegistrarController} from "src/L2/RegistrarController.sol";
+import {ExponentialPremiumPriceOracle} from "src/L2/ExponentialPremiumPriceOracle.sol";
+import {IPriceOracle} from "src/L2/interface/IPriceOracle.sol";
+
+contract PostLaunchAuctionConfig is IntegrationTestBase {
+    string name = "alice";
+    uint256 duration = 365.25 days;
+    uint256 id = uint256(keccak256(bytes(name)));
+
+    function test_simulatePostAuctionConfig_register() public {
+        // Deploy original price oracle, we will do this ahead of launch
+        exponentialPremiumPriceOracle = new ExponentialPremiumPriceOracle(
+            _getBasePrices(), EXPIRY_AUCTION_START_PRICE, EXPIRY_AUCTION_DURATION_DAYS
+        );
+
+        // Jump forward 30 days
+        vm.warp(LAUNCH_TIME + 30 days);
+
+        // Set new price oracle on registrar controller (ownerOnly method)
+        vm.prank(owner);
+        registrarController.setPriceOracle(IPriceOracle(exponentialPremiumPriceOracle));
+
+        //// Register a name and check price + success
+        uint256 price = registrarController.registerPrice(name, duration);
+        vm.deal(alice, price);
+
+        RegistrarController.RegisterRequest memory request = RegistrarController.RegisterRequest({
+            name: name,
+            owner: alice,
+            duration: duration,
+            resolver: address(defaultL2Resolver),
+            data: new bytes[](0),
+            reverseRecord: true
+        });
+
+        vm.expectEmit(address(registrarController));
+        emit RegistrarController.ETHPaymentProcessed(alice, price);
+
+        vm.prank(alice);
+        registrarController.register{value: price}(request);
+        assertEq(baseRegistrar.ownerOf(id), alice);
+
+        uint256 expectedPrice = exponentialPremiumPriceOracle.price5Letter() * duration;
+        assertEq(price, expectedPrice);
+
+        console.log("______________________________");
+        console.log("Timestamp: ", block.timestamp);
+        console.log("Price (WEI): ", price);
+        console.log("______________________________");
+    }
+
+    function test_simulateContingency() public {
+        // Deploy original price oracle, we will do this ahead of launch
+        exponentialPremiumPriceOracle = new ExponentialPremiumPriceOracle(
+            _getBasePrices(), EXPIRY_AUCTION_START_PRICE, EXPIRY_AUCTION_DURATION_DAYS
+        );
+
+        // Jump forward 1 day
+        vm.warp(LAUNCH_TIME + 1 days);
+
+        // Set the launch time to 0 (no-op for launch pricing)
+        vm.prank(owner);
+        registrarController.setLaunchTime(0);
+        // Set new price oracle on registrar controller (ownerOnly method)
+        vm.prank(owner);
+        registrarController.setPriceOracle(IPriceOracle(exponentialPremiumPriceOracle));
+
+        //// Register a name and check price + success
+        uint256 price = registrarController.registerPrice(name, duration);
+        vm.deal(alice, price);
+
+        RegistrarController.RegisterRequest memory request = RegistrarController.RegisterRequest({
+            name: name,
+            owner: alice,
+            duration: duration,
+            resolver: address(defaultL2Resolver),
+            data: new bytes[](0),
+            reverseRecord: true
+        });
+
+        vm.expectEmit(address(registrarController));
+        emit RegistrarController.ETHPaymentProcessed(alice, price);
+
+        vm.prank(alice);
+        registrarController.register{value: price}(request);
+        assertEq(baseRegistrar.ownerOf(id), alice);
+
+        uint256 expectedPrice = exponentialPremiumPriceOracle.price5Letter() * duration;
+        assertEq(price, expectedPrice);
+
+        console.log("______________________________");
+        console.log("Timestamp: ", block.timestamp);
+        console.log("Price (WEI): ", price);
+        console.log("______________________________");
+    }
+}