feat: ResourceConstraintManager (#389)

gzeoneth · yahgwai · web-flow · commit 426e3c813548 · 2025-11-18T16:15:45.000+08:00
* chore: checkout resource-constrait-precompiles

* wip: PricingManager

* chore: rename ResourceConstraintManager

* fix: use proper interface

* fix: nConstraints

* feat: ResourceConstraintManager.revoke

* feat: startingBacklogValue must be 0

* chore: better error

* chore: manager

* test: ResourceConstraintManagerTest

* feat: added pricing exponent check and tests

* style: formatting

* fix: remove unused error

* test: fixed failing test

* test: added better revert check

---------

Co-authored-by: Chris Buckland &lt;cpbuckland88@gmail.com&gt;
diff --git a/src/chain/ResourceConstraintManager.sol b/src/chain/ResourceConstraintManager.sol
@@ -0,0 +1,88 @@
+// Copyright 2022-2025, Offchain Labs, Inc.
+// For license information, see https://github.com/nitro/blob/master/LICENSE
+// SPDX-License-Identifier: BUSL-1.1
+
+pragma solidity ^0.8.0;
+
+import "../precompiles/ArbOwner.sol";
+import "../precompiles/ArbGasInfo.sol";
+import "@openzeppelin/contracts/access/AccessControlEnumerable.sol";
+
+contract ResourceConstraintManager is AccessControlEnumerable {
+    ArbOwner internal constant ARB_OWNER = ArbOwner(address(0x70));
+    ArbGasInfo internal constant ARB_GAS_INFO = ArbGasInfo(address(0x6c));
+
+    bytes32 public constant MANAGER_ROLE = keccak256("MANAGER_ROLE");
+    uint256 public expiryTimestamp;
+
+    error TooManyConstraints();
+    error InvalidPeriod(
+        uint64 gasTargetPerSec, uint64 adjustmentWindowSecs, uint64 startingBacklogValue
+    );
+    error InvalidTarget(
+        uint64 gasTargetPerSec, uint64 adjustmentWindowSecs, uint64 startingBacklogValue
+    );
+    error PricingExponentTooHigh(uint64 pricingExponent);
+    error NotExpired();
+
+    constructor(address admin, address manager, uint256 _expiryTimestamp) {
+        _setupRole(DEFAULT_ADMIN_ROLE, admin);
+        _setupRole(MANAGER_ROLE, manager);
+        expiryTimestamp = _expiryTimestamp;
+    }
+
+    /// @notice Removes the contract from the list of chain owners after the expiry timestamp
+    function revoke() external {
+        if (block.timestamp < expiryTimestamp) {
+            revert NotExpired();
+        }
+        ARB_OWNER.removeChainOwner(address(this));
+    }
+
+    /// @notice Sets the list of gas pricing constraints for the multi-constraint pricing model.
+    ///         See ArbOwner.setGasPricingConstraints interface for more information.
+    /// @param constraints Array of triples (gas_target_per_second, adjustment_window_seconds, starting_backlog_value)
+    ///        - gas_target_per_second: target gas usage per second for the constraint (uint64, gas/sec)
+    ///        - adjustment_window_seconds: time over which the price will rise by a factor of e if demand is 2x the target (uint64, seconds)
+    ///        - starting_backlog_value: initial backlog for this constraint (uint64, gas units)
+    function setGasPricingConstraints(
+        uint64[3][] calldata constraints
+    ) external onlyRole(MANAGER_ROLE) {
+        // If zero constraints are provided, the chain uses the single-constraint pricing model
+        uint256 nConstraints = constraints.length;
+        if (nConstraints > 10) {
+            revert TooManyConstraints();
+        }
+        uint64 pricingExponent = 0;
+        for (uint256 i = 0; i < nConstraints; ++i) {
+            uint64 gasTargetPerSec = constraints[i][0];
+            uint64 adjustmentWindowSecs = constraints[i][1];
+            uint64 startingBacklogValue = constraints[i][2];
+            if (gasTargetPerSec < 7_000_000 || gasTargetPerSec > 100_000_000) {
+                revert InvalidTarget(gasTargetPerSec, adjustmentWindowSecs, startingBacklogValue);
+            }
+            if (adjustmentWindowSecs < 5 || adjustmentWindowSecs > 86400) {
+                revert InvalidPeriod(gasTargetPerSec, adjustmentWindowSecs, startingBacklogValue);
+            }
+            // we scale by 1000 to improve precision in calculating the exponent
+            // since this division will round down, it's always possible for the real exponent to be up to
+            // the number of constraints greater than the value we measure
+            // for instance
+            // if n = 10, and we check with precision 1 against threshold 8, then the real exponent might actually be up to 18
+            // if n = 10, and we check with precision 1000 against threshold 8000, then the real exponent might actually be up to 8010 / 1000
+            pricingExponent +=
+                (startingBacklogValue * 1000) / (gasTargetPerSec * adjustmentWindowSecs);
+        }
+
+        // this calculated pricing exponent will by used by nitro to calculate the gas price
+        // we check that the pricing exponent is below some reasonable number to avoid setting the gas price astronomically high
+        // as long as the gas price is not so high that no-one at all can send a transaction the chain will be able to function
+        // eg. these constraints can be changed again, or the sec council can send admin transactions
+        // with min base fee of 0.02, exponent of 8 (scaled by 1000) corresponds to a gas price of ~60 Gwei
+        if (pricingExponent > 8000) {
+            revert PricingExponentTooHigh(pricingExponent);
+        }
+
+        ARB_OWNER.setGasPricingConstraints(constraints);
+    }
+}
diff --git a/test/foundry/ResourceConstraintManager.t.sol b/test/foundry/ResourceConstraintManager.t.sol
@@ -0,0 +1,258 @@
+// SPDX-License-Identifier: UNLICENSED
+pragma solidity ^0.8.4;
+
+import "forge-std/Test.sol";
+import "../../src/chain/ResourceConstraintManager.sol";
+
+contract ResourceConstraintManagerTest is Test {
+    ResourceConstraintManager public resourceConstraintManager;
+    ArbOwnerMock internal constant ARB_OWNER = ArbOwnerMock(address(0x70));
+
+    address constant admin = address(1337);
+    address constant manager = address(7331);
+    uint256 constant expiryTimestamp = 12345678;
+
+    constructor() {
+        resourceConstraintManager = new ResourceConstraintManager(admin, manager, expiryTimestamp);
+        vm.etch(address(ARB_OWNER), type(ArbOwnerMock).runtimeCode);
+    }
+
+    function test_revoke() external {
+        // Test before expiry
+        vm.warp(expiryTimestamp - 1);
+        vm.expectRevert(ResourceConstraintManager.NotExpired.selector);
+        resourceConstraintManager.revoke();
+
+        // Test after expiry
+        vm.warp(expiryTimestamp);
+        assertFalse(ARB_OWNER.removeChainOwnerCalled());
+        resourceConstraintManager.revoke();
+        assertTrue(ARB_OWNER.removeChainOwnerCalled());
+    }
+
+    function test_setGasPricingConstraints_success() external {
+        // Test with valid single constraint
+        uint64[3][] memory constraints = new uint64[3][](1);
+        constraints[0] = [uint64(10_000_000), uint64(100), uint64(0)];
+
+        vm.prank(manager);
+        resourceConstraintManager.setGasPricingConstraints(constraints);
+
+        // Test with multiple valid constraints
+        uint64[3][] memory multipleConstraints = new uint64[3][](3);
+        multipleConstraints[0] = [uint64(7_000_000), uint64(5), uint64(0)];
+        multipleConstraints[1] = [uint64(50_000_000), uint64(1000), uint64(1)];
+        multipleConstraints[2] = [uint64(100_000_000), uint64(86400), uint64(10000)];
+
+        vm.prank(manager);
+        resourceConstraintManager.setGasPricingConstraints(multipleConstraints);
+
+        // Test with empty constraints array (switch to single-constraint model)
+        uint64[3][] memory emptyConstraints = new uint64[3][](0);
+        vm.prank(manager);
+        resourceConstraintManager.setGasPricingConstraints(emptyConstraints);
+    }
+
+    function test_setGasPricingConstraints_pricingExponentTooHigh() external {
+        // create constraints on the limit of the pricing exponent
+        uint64[3][] memory multipleConstraints = new uint64[3][](3);
+        multipleConstraints[0] = [uint64(7_000_000), uint64(5), uint64(35_000_000)]; // 1
+        multipleConstraints[1] = [uint64(50_000_000), uint64(1000), uint64(300_000_000_000)]; // 6
+        multipleConstraints[2] = [uint64(100_000_000), uint64(86400), uint64(8_640_000_000_000)]; // 1
+
+        vm.prank(manager);
+        resourceConstraintManager.setGasPricingConstraints(multipleConstraints);
+
+        // up to the limit
+        multipleConstraints[1][2] = uint64(300_049_999_999);
+        vm.prank(manager);
+        resourceConstraintManager.setGasPricingConstraints(multipleConstraints);
+
+        // over the limit
+        multipleConstraints[1][2] = uint64(300_050_000_000);
+        vm.prank(manager);
+        vm.expectRevert(
+            abi.encodeWithSelector(ResourceConstraintManager.PricingExponentTooHigh.selector, 8001)
+        );
+        resourceConstraintManager.setGasPricingConstraints(multipleConstraints);
+    }
+
+    function test_setGasPricingConstraints_accessControl() external {
+        uint64[3][] memory constraints = new uint64[3][](1);
+        constraints[0] = [uint64(10_000_000), uint64(100), uint64(0)];
+
+        // Test non-manager cannot call
+        vm.expectRevert();
+        resourceConstraintManager.setGasPricingConstraints(constraints);
+
+        // Test admin without manager role cannot call
+        vm.prank(admin);
+        vm.expectRevert();
+        resourceConstraintManager.setGasPricingConstraints(constraints);
+
+        // Test manager can call
+        vm.prank(manager);
+        resourceConstraintManager.setGasPricingConstraints(constraints);
+    }
+
+    function test_setGasPricingConstraints_tooManyConstraints() external {
+        // Test exactly 10 constraints (should succeed)
+        uint64[3][] memory tenConstraints = new uint64[3][](10);
+        for (uint256 i = 0; i < 10; i++) {
+            tenConstraints[i] = [uint64(10_000_000), uint64(100), uint64(0)];
+        }
+        vm.prank(manager);
+        resourceConstraintManager.setGasPricingConstraints(tenConstraints);
+
+        // Test 11 constraints (should revert)
+        uint64[3][] memory elevenConstraints = new uint64[3][](11);
+        for (uint256 i = 0; i < 11; i++) {
+            elevenConstraints[i] = [uint64(10_000_000), uint64(100), uint64(0)];
+        }
+        vm.prank(manager);
+        vm.expectRevert(ResourceConstraintManager.TooManyConstraints.selector);
+        resourceConstraintManager.setGasPricingConstraints(elevenConstraints);
+    }
+
+    function test_setGasPricingConstraints_invalidTarget() external {
+        // Test gas target below minimum (6,999,999)
+        uint64[3][] memory constraintsLowTarget = new uint64[3][](1);
+        constraintsLowTarget[0] = [uint64(6_999_999), uint64(100), uint64(0)];
+
+        vm.prank(manager);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                ResourceConstraintManager.InvalidTarget.selector,
+                uint64(6_999_999),
+                uint64(100),
+                uint64(0)
+            )
+        );
+        resourceConstraintManager.setGasPricingConstraints(constraintsLowTarget);
+
+        // Test gas target above maximum (100,000,001)
+        uint64[3][] memory constraintsHighTarget = new uint64[3][](1);
+        constraintsHighTarget[0] = [uint64(100_000_001), uint64(100), uint64(0)];
+
+        vm.prank(manager);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                ResourceConstraintManager.InvalidTarget.selector,
+                uint64(100_000_001),
+                uint64(100),
+                uint64(0)
+            )
+        );
+        resourceConstraintManager.setGasPricingConstraints(constraintsHighTarget);
+
+        // Test edge cases (exactly at boundaries should succeed)
+        uint64[3][] memory constraintsMinTarget = new uint64[3][](1);
+        constraintsMinTarget[0] = [uint64(7_000_000), uint64(100), uint64(0)];
+        vm.prank(manager);
+        resourceConstraintManager.setGasPricingConstraints(constraintsMinTarget);
+
+        uint64[3][] memory constraintsMaxTarget = new uint64[3][](1);
+        constraintsMaxTarget[0] = [uint64(100_000_000), uint64(100), uint64(0)];
+        vm.prank(manager);
+        resourceConstraintManager.setGasPricingConstraints(constraintsMaxTarget);
+    }
+
+    function test_setGasPricingConstraints_invalidPeriod() external {
+        // Test adjustment window below minimum (4 seconds)
+        uint64[3][] memory constraintsLowPeriod = new uint64[3][](1);
+        constraintsLowPeriod[0] = [uint64(10_000_000), uint64(4), uint64(0)];
+
+        vm.prank(manager);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                ResourceConstraintManager.InvalidPeriod.selector,
+                uint64(10_000_000),
+                uint64(4),
+                uint64(0)
+            )
+        );
+        resourceConstraintManager.setGasPricingConstraints(constraintsLowPeriod);
+
+        // Test adjustment window above maximum (86401 seconds)
+        uint64[3][] memory constraintsHighPeriod = new uint64[3][](1);
+        constraintsHighPeriod[0] = [uint64(10_000_000), uint64(86401), uint64(0)];
+
+        vm.prank(manager);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                ResourceConstraintManager.InvalidPeriod.selector,
+                uint64(10_000_000),
+                uint64(86401),
+                uint64(0)
+            )
+        );
+        resourceConstraintManager.setGasPricingConstraints(constraintsHighPeriod);
+
+        // Test edge cases (exactly at boundaries should succeed)
+        uint64[3][] memory constraintsMinPeriod = new uint64[3][](1);
+        constraintsMinPeriod[0] = [uint64(10_000_000), uint64(5), uint64(0)];
+        vm.prank(manager);
+        resourceConstraintManager.setGasPricingConstraints(constraintsMinPeriod);
+
+        uint64[3][] memory constraintsMaxPeriod = new uint64[3][](1);
+        constraintsMaxPeriod[0] = [uint64(10_000_000), uint64(86400), uint64(0)];
+        vm.prank(manager);
+        resourceConstraintManager.setGasPricingConstraints(constraintsMaxPeriod);
+    }
+
+    function test_setGasPricingConstraints_multipleConstraintValidation() external {
+        // Test that all constraints are validated (not just the first one)
+        uint64[3][] memory constraints = new uint64[3][](3);
+        constraints[0] = [uint64(10_000_000), uint64(100), uint64(0)]; // Valid
+        constraints[1] = [uint64(20_000_000), uint64(200), uint64(0)]; // Valid
+        constraints[2] = [uint64(5_000_000), uint64(100), uint64(0)]; // Invalid target
+
+        vm.prank(manager);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                ResourceConstraintManager.InvalidTarget.selector,
+                uint64(5_000_000),
+                uint64(100),
+                uint64(0)
+            )
+        );
+        resourceConstraintManager.setGasPricingConstraints(constraints);
+
+        // Test with invalid period in middle
+        constraints[0] = [uint64(10_000_000), uint64(100), uint64(0)]; // Valid
+        constraints[1] = [uint64(20_000_000), uint64(3), uint64(0)]; // Invalid period
+        constraints[2] = [uint64(30_000_000), uint64(100), uint64(0)]; // Valid
+
+        vm.prank(manager);
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                ResourceConstraintManager.InvalidPeriod.selector,
+                uint64(20_000_000),
+                uint64(3),
+                uint64(0)
+            )
+        );
+        resourceConstraintManager.setGasPricingConstraints(constraints);
+    }
+}
+
+contract ArbOwnerMock {
+    bool public removeChainOwnerCalled;
+    uint64[3][] public lastConstraints;
+
+    function removeChainOwner(
+        address ownerToRemove
+    ) external {
+        removeChainOwnerCalled = true;
+    }
+
+    function setGasPricingConstraints(
+        uint64[3][] calldata constraints
+    ) external {
+        lastConstraints = constraints;
+    }
+
+    function getLastConstraints() external view returns (uint64[3][] memory) {
+        return lastConstraints;
+    }
+}
