feat(bulk-renew): implement add-bulk-renew

.github/workflows/test.yml

@@ -5,14 +5,14 @@ on:
     branches:
       - mainnet
       - testnet
-      - 'feature/*'
-      - 'features/*'
+      - "feature/*"
+      - "features/*"
   pull_request:
     branches:
       - mainnet
       - testnet
-      - 'feature/*'
-      - 'features/*'
+      - "feature/*"
+      - "features/*"
 
 env:
   FOUNDRY_PROFILE: ci
@@ -37,11 +37,6 @@ jobs:
       - name: Update package with soldeer
         run: forge soldeer update
 
-      - name: Recursively update dependencies
-        run: |
-          chmod +x ./update-deps.sh
-          ./update-deps.sh
-
       - name: Run Forge build
         run: |
           forge --version

foundry.toml

@@ -7,7 +7,7 @@ ffi = true
 
 solc = '0.8.21'
 extra_output = ["devdoc", "userdoc", "storagelayout"]
-evm_version = 'istanbul'
+evm_version = 'london'
 use_literal_content = true
 fs_permissions = [{ access = "read-write", path = "./" }]
 
@@ -30,6 +30,26 @@ runs = 256
 runs = 256
 
 [dependencies]
-"@fdk" = { version = "0.3.0-beta", url = "https://github.com/axieinfinity/foundry-deployment-kit/archive/refs/tags/v0.3.0-beta.zip" }
+"@fdk" = { version = "0.3.4-beta", url = "https://github.com/axieinfinity/foundry-deployment-kit/archive/refs/tags/v0.3.4-beta.zip" }
 "@pythnetwork-pyth-sdk-solidity" = { version = "2.2.0" }
 "@openzeppelin-contracts" = { version = "4.9.3" }
+
+[soldeer]
+# whether soldeer manages remappings
+remappings_generate = false
+
+# whether soldeer re-generates all remappings when installing, updating or uninstalling deps
+remappings_regenerate = false
+
+# whether to suffix the remapping with the version: `name-a.b.c`
+remappings_version = true
+
+# a prefix to add to the remappings ("@" would give `@name`)
+remappings_prefix = "@"
+
+# where to store the remappings ("txt" for `remappings.txt` or "config" for `foundry.toml`)
+# ignored when `soldeer.toml` is used as config (uses `remappings.txt`)
+remappings_location = "txt"
+
+# whether to install sub-dependencies or not. If true this wil install the dependencies of dependencies 1 level down.
+recursive_deps = true

soldeer.lock

@@ -1,17 +1,20 @@
 [[dependencies]]
 name = "@fdk"
 version = "0.3.0-beta"
-source = "https://github.com/axieinfinity/foundry-deployment-kit/archive/refs/tags/v0.3.0-beta.zip"
+url = "https://github.com/axieinfinity/foundry-deployment-kit/archive/refs/tags/v0.3.0-beta.zip"
 checksum = "aabeda6cc1fe02227d26f3edd86d4af6c91e2167e8b9f1971cc1ea7ce33d34f9"
-
-[[dependencies]]
-name = "@pythnetwork-pyth-sdk-solidity"
-version = "2.2.0"
-source = "https://soldeer-revisions.s3.amazonaws.com/@pythnetwork-pyth-sdk-solidity/2_2_0_15-04-2024_18:50:54_pyth-sdk-solidity.zip"
-checksum = "54e3bda3b27467f84c1605722f58e1d2b5a19d6ca3c24840550f1d6cf3bc2231"
+integrity = "436f06791b10ed0ce2363d3dde8e520e79376df1b81b00f0787670ad03941661"
 
 [[dependencies]]
 name = "@openzeppelin-contracts"
 version = "4.9.3"
-source = "https://soldeer-revisions.s3.amazonaws.com/@openzeppelin-contracts/4_9_3_22-01-2024_13:13:53_contracts.zip"
+url = "https://soldeer-revisions.s3.amazonaws.com/@openzeppelin-contracts/4_9_3_22-01-2024_13:13:53_contracts.zip"
 checksum = "95886307069cf73310b41396c49df51801a73f31f18f62e7d05adfc2031e7725"
+integrity = "6daa959732c1bceabda7f2823d1baa097b96509b48db78cb2e3ddd38bd4fd030"
+
+[[dependencies]]
+name = "@pythnetwork-pyth-sdk-solidity"
+version = "2.2.0"
+url = "https://soldeer-revisions.s3.amazonaws.com/@pythnetwork-pyth-sdk-solidity/2_2_0_15-04-2024_18:50:54_pyth-sdk-solidity.zip"
+checksum = "54e3bda3b27467f84c1605722f58e1d2b5a19d6ca3c24840550f1d6cf3bc2231"
+integrity = "4a13c0cb110ee72e9f453835fcd63af6f13d5bbf4b102340ed454971d84c40fd"

src/RONRegistrarController.sol

@@ -228,6 +228,34 @@ contract RONRegistrarController is
     _transferRONToTreasury();
   }
 
+  /**
+   * @inheritdoc IRONRegistrarController
+   */
+  function bulkRenew(string[] calldata names, uint64[] calldata durations) external payable whenNotPaused nonReentrant {
+    uint256 length = names.length;
+    if (length == 0 || length != durations.length) revert InvalidArrayLength();
+
+    uint256 id;
+    uint256 totalPrice;
+    uint64 expiryTime;
+
+    for (uint256 i; i < length; ++i) {
+      (, uint256 ronPrice) = rentPrice(names[i], durations[i]);
+
+      totalPrice += ronPrice;
+      id = computeId(names[i]);
+      expiryTime = _rnsUnified.renew(id, durations[i]);
+
+      emit NameRenewed(names[i], id, ronPrice, expiryTime);
+    }
+
+    if (msg.value < totalPrice) revert InsufficientValue();
+    uint256 remainAmount = msg.value - totalPrice;
+
+    if (remainAmount != 0) RONTransferHelper.safeTransfer(payable(_msgSender()), remainAmount);
+    _transferRONToTreasury();
+  }
+
   /**
    * @inheritdoc IRONRegistrarController
    */

src/interfaces/IRONRegistrarController.sol

@@ -40,6 +40,8 @@ interface IRONRegistrarController {
   error InvalidArrayLength();
   /// @dev Thrown when treasury address is set to null
   error NullAddress();
+  /// @dev Thrown when the names is not sorted in ascending order
+  error InvalidOrderOfNames();
 
   /**
    * @dev Emitted when the min registration duration is updated.
@@ -176,6 +178,17 @@ interface IRONRegistrarController {
    */
   function renew(string calldata name, uint64 duration) external payable;
 
+  /**
+   * @dev Renew multiple names in a single transaction.
+   * Requirements:
+   * - `names` and `durations` arrays must have the same length.
+   * - The caller must provide enough value to cover the total renewal cost.
+   * WARNING: The function does not check for duplicate names.
+   * @param names The array of names to be renewed.
+   * @param durations The array of durations for the renewal.
+   */
+  function bulkRenew(string[] calldata names, uint64[] calldata durations) external payable;
+
   /**
    * @dev Registers a protected name.
    *

test/RONRegistrarController/RONRegistrarController.bulkRenew.t.sol

@@ -0,0 +1,216 @@
+// SPDX-License-Identifier: MIT
+pragma solidity ^0.8.19;
+
+import { TransparentUpgradeableProxy } from "@openzeppelin/contracts/proxy/transparent/TransparentUpgradeableProxy.sol";
+import { Strings } from "@openzeppelin/contracts/utils/Strings.sol";
+import { console2, Test } from "forge-std/Test.sol";
+import { RNSUnified } from "@rns-contracts/RNSUnified.sol";
+import {
+  RONRegistrarController,
+  IRONRegistrarController,
+  INSUnified,
+  INameChecker,
+  INSDomainPrice,
+  INSReverseRegistrar
+} from "@rns-contracts/RONRegistrarController.sol";
+import { RONTransferHelper } from "@rns-contracts/libraries/transfers/RONTransferHelper.sol";
+import { LibString } from "@rns-contracts/libraries/LibString.sol";
+import { LibRNSDomain } from "@rns-contracts/libraries/LibRNSDomain.sol";
+import { RONRegistrarControllerTest } from "./RONRegistrarController.t.sol";
+
+contract RONRegistrarControllerBulkRenewTest is RONRegistrarControllerTest {
+  event NameRenewed(string name, uint256 indexed id, uint256 cost, uint64 expires);
+
+  function testConcreate_Renew_2names_Check_CorrectFeeCharged() external {
+    string[] memory names = new string[](2);
+    names[0] = "tori.ron";
+    names[1] = "test.ron";
+
+    (uint256[] memory ids, string[] memory sortedNames) = _sortNames(names);
+    uint64[] memory expires = new uint64[](ids.length);
+    uint64 duration = 30 days;
+    for (uint256 i; i < ids.length; ++i) {
+      console2.log("id", ids[i]);
+      console2.log("name", sortedNames[i]);
+      expires[i] = _rnsUnified.getRecord(ids[i]).mut.expiry + duration;
+    }
+
+    uint256[] memory fees = new uint256[](2);
+    fees[0] = _calFee(names[0], duration);
+    fees[1] = _calFee(names[1], duration);
+
+    uint256 totalFee = fees[0] + fees[1];
+
+    uint256 sendValue = 10 ether;
+    uint256 balanceBefore = address(_caller).balance;
+
+    uint64[] memory durations = new uint64[](2);
+    durations[0] = duration;
+    durations[1] = duration;
+    _expectEmit(sortedNames, ids, fees, expires);
+    vm.prank(_caller);
+    _controller.bulkRenew{ value: sendValue }(sortedNames, durations);
+    assertEq(address(_caller).balance, balanceBefore - totalFee);
+
+    durations[0] = duration;
+    durations[1] = duration;
+    vm.prank(_caller);
+    _controller.bulkRenew{ value: sendValue }(sortedNames, durations);
+  }
+
+  function testConcreate_bulkRenew_TheSameName_CorrectFeeCharged() external {
+    string[] memory names = new string[](2);
+    names[0] = "tori.vip.ron";
+    names[1] = "tori.vip.ron";
+
+    uint64 duration = 30 days;
+    uint64[] memory durations = new uint64[](2);
+    durations[0] = duration;
+    durations[1] = duration;
+    uint256 balanceBefore = address(_caller).balance;
+
+    uint256 fee = _calFee(names[0], duration) * 2;
+
+    vm.prank(_caller);
+    _controller.bulkRenew{ value: 10 ether }(names, durations);
+
+    assertEq(address(_caller).balance, balanceBefore - fee);
+    assertEq(_treasury.balance, fee);
+  }
+
+  function testRevert_bulkRenew_InsufficientValue() external {
+    string[] memory names = new string[](2);
+    names[0] = "test.ron";
+    names[1] = "tori.ron";
+
+    uint64 duration = 30 days;
+    uint64[] memory durations = new uint64[](2);
+    durations[0] = duration;
+    durations[1] = duration;
+
+    uint256 name0Fee = _calFee(names[0], duration);
+    uint256 name1Fee = _calFee(names[1], duration);
+
+    vm.prank(_caller);
+    vm.expectRevert(IRONRegistrarController.InsufficientValue.selector);
+    _controller.bulkRenew{ value: name0Fee + name1Fee - 1 }(names, durations);
+
+    // Call success
+    _controller.bulkRenew{ value: name0Fee + name1Fee }(names, durations);
+  }
+
+  function testRevert_bulkRenew_ExpiryNotLargerThanOldOne() external {
+    string[] memory names = new string[](1);
+    names[0] = "test.ron";
+
+    uint64[] memory durations = new uint64[](1);
+    durations[0] = 0;
+
+    vm.prank(_caller);
+    vm.expectRevert(INSUnified.ExpiryTimeMustBeLargerThanTheOldOne.selector);
+    _controller.bulkRenew{ value: 10 ether }(names, durations);
+  }
+
+  function testBenchMark_bulkRenew(uint8 times) external {
+    vm.pauseGasMetering();
+    vm.assume(times > 0);
+    string[] memory names = new string[](times);
+    uint64[] memory durations = new uint64[](times);
+    uint256 totalFee;
+    for (uint256 i; i < times; ++i) {
+      names[i] = string.concat("test", vm.toString(i), ".ron");
+      durations[i] = 30 days;
+      totalFee += _calFee(names[i], durations[i]);
+    }
+    vm.deal(_caller, totalFee + 10 ether);
+    (, string[] memory sortedNames) = _sortNames(names);
+    vm.resumeGasMetering();
+    vm.prank(_caller);
+    _controller.bulkRenew{ value: totalFee + 10 ether }(sortedNames, durations);
+
+    assertEq(address(_caller).balance, 10 ether);
+    assertEq(_treasury.balance, totalFee);
+  }
+
+  function testRevert_bulkRenew_InvalidArrayLength() external {
+    string[] memory names = new string[](2);
+    names[0] = "test.ron";
+    names[1] = "tori.ron";
+
+    uint64[] memory durations = new uint64[](1);
+    durations[0] = 30 days;
+
+    vm.prank(_caller);
+    vm.expectRevert(IRONRegistrarController.InvalidArrayLength.selector);
+    _controller.bulkRenew{ value: 10 ether }(names, durations);
+
+    names = new string[](0);
+    durations = new uint64[](0);
+    vm.expectRevert(IRONRegistrarController.InvalidArrayLength.selector);
+    _controller.bulkRenew{ value: 10 ether }(names, durations);
+  }
+
+  function testConcreate_DuplicateNames_With_TheSameDuration() external {
+    string[] memory names = new string[](2);
+    names[0] = "test.ron";
+    names[1] = "test.ron";
+
+    uint64[] memory durations = new uint64[](2);
+    durations[0] = 30 days;
+    durations[1] = 30 days;
+
+    vm.prank(_caller);
+    // vm.expectRevert(IRONRegistrarController.InvalidArrayLength.selector);
+    _controller.bulkRenew{ value: 10 ether }(names, durations);
+  }
+
+  function testConcreate_DuplicateNames_With_DifferentDuration() external {
+    string[] memory names = new string[](2);
+    names[0] = "test.ron";
+    names[1] = "test.ron";
+
+    uint64[] memory durations = new uint64[](2);
+    durations[0] = 30 days;
+    durations[1] = 10 days;
+
+    vm.prank(_caller);
+    // vm.expectRevert(IRONRegistrarController.InvalidArrayLength.selector);
+    _controller.bulkRenew{ value: 10 ether }(names, durations);
+  }
+
+  function _calFee(string memory name, uint64 duration) internal returns (uint256) {
+    (, uint256 ronPrice) = _controller.rentPrice(name, duration);
+    return ronPrice;
+  }
+
+  function _sortNames(string[] memory names) internal returns (uint256[] memory, string[] memory) {
+    uint256[] memory ids = new uint256[](names.length);
+    for (uint256 i = 0; i < names.length; i++) {
+      ids[i] = _controller.computeId(names[i]);
+    }
+
+    for (uint256 i = 0; i < names.length; i++) {
+      for (uint256 j = i + 1; j < names.length; j++) {
+        if (ids[i] > ids[j]) {
+          uint256 tempId = ids[i];
+          ids[i] = ids[j];
+          ids[j] = tempId;
+
+          string memory tempName = names[i];
+          names[i] = names[j];
+          names[j] = tempName;
+        }
+      }
+    }
+    return (ids, names);
+  }
+
+  function _expectEmit(string[] memory names, uint256[] memory ids, uint256[] memory fees, uint64[] memory expires)
+    internal
+  {
+    for (uint256 i; i < names.length; ++i) {
+      vm.expectEmit(false, true, false, true);
+      emit NameRenewed(names[i], ids[i], fees[i], expires[i]);
+    }
+  }
+}