feat: configurable gas limits

Author: anna-carroll

.gas-snapshot

@@ -28,12 +28,14 @@ RollupPassageTest:test_exit() (gas: 22347)
 RollupPassageTest:test_exitToken() (gas: 50183)
 RollupPassageTest:test_fallback() (gas: 19883)
 RollupPassageTest:test_receive() (gas: 19844)
-TransactTest:test_enterTransact() (gas: 99486)
-TransactTest:test_setUp() (gas: 8481)
-TransactTest:test_transact() (gas: 97089)
-TransactTest:test_transact_defaultChain() (gas: 95892)
-TransactTest:test_transact_globalGasLimit() (gas: 99262)
-TransactTest:test_transact_perTransactGasLimit() (gas: 30687)
+TransactTest:test_configureGas() (gas: 22828)
+TransactTest:test_enterTransact() (gas: 103961)
+TransactTest:test_onlyGasAdmin() (gas: 8810)
+TransactTest:test_setUp() (gas: 17494)
+TransactTest:test_transact() (gas: 101431)
+TransactTest:test_transact_defaultChain() (gas: 100544)
+TransactTest:test_transact_globalGasLimit() (gas: 105063)
+TransactTest:test_transact_perTransactGasLimit() (gas: 32774)
 ZenithTest:test_addSequencer() (gas: 88121)
 ZenithTest:test_badSignature() (gas: 37241)
 ZenithTest:test_incorrectHostBlock() (gas: 35086)

script/Zenith.s.sol

@@ -9,17 +9,17 @@ import {HostOrders, RollupOrders} from "../src/Orders.sol";
 
 contract ZenithScript is Script {
     // deploy:
-    // forge script ZenithScript --sig "deploy(uint256,address,address)" --rpc-url $RPC_URL --etherscan-api-key $ETHERSCAN_API_KEY --private-key $PRIVATE_KEY --broadcast --verify $ROLLUP_CHAIN_ID $WITHDRAWAL_ADMIN_ADDRESS $INITIAL_ENTER_TOKENS_ARRAY $SEQUENCER_ADMIN_ADDRESS
+    // forge script ZenithScript --sig "deploy(uint256,address,address)" --rpc-url $RPC_URL --etherscan-api-key $ETHERSCAN_API_KEY --private-key $PRIVATE_KEY --broadcast --verify $ROLLUP_CHAIN_ID $WITHDRAWAL_ADMIN_ADDRESS $INITIAL_ENTER_TOKENS_ARRAY $SEQUENCER_AND_GAS_ADMIN_ADDRESS
     function deploy(
         uint256 defaultRollupChainId,
         address withdrawalAdmin,
         address[] memory initialEnterTokens,
-        address sequencerAdmin
+        address sequencerAndGasAdmin
     ) public returns (Zenith z, Passage p, Transactor t, HostOrders m) {
         vm.startBroadcast();
-        z = new Zenith(sequencerAdmin);
+        z = new Zenith(sequencerAndGasAdmin);
         p = new Passage(defaultRollupChainId, withdrawalAdmin, initialEnterTokens);
-        t = new Transactor(defaultRollupChainId, p);
+        t = new Transactor(defaultRollupChainId, sequencerAndGasAdmin, p, 30_000_000, 5_000_000);
         m = new HostOrders();
     }
 

src/Transact.sol

@@ -5,18 +5,21 @@ import {Passage} from "./Passage.sol";
 
 /// @notice A contract deployed to Host chain that enables transactions from L1 to be sent on an L2.
 contract Transactor {
-    /// @notice The sum of `transact` calls in a block cannot use more than 30M gas.
-    uint256 public constant PER_BLOCK_TRANSACT_GAS_LIMIT = 30_000_000;
-
-    /// @notice Each `transact` call cannot use more than 5M gas.
-    uint256 public constant PER_TRANSACT_GAS_LIMIT = 5_000_000;
-
     /// @notice The chainId of rollup that Ether will be sent to by default when entering the rollup via fallback() or receive().
     uint256 public immutable defaultRollupChainId;
 
+    /// @notice The address that is allowed to configure `transact` gas limits.
+    address public immutable gasAdmin;
+
     /// @notice The address of the Passage contract, to enable transact + enter.
     Passage public immutable passage;
 
+    /// @notice The sum of `transact` calls in a block cannot use more than this limit.
+    uint256 public perBlockGasLimit;
+
+    /// @notice Each `transact` call cannot use more than this limit.
+    uint256 public perTransactGasLimit;
+
     /// @notice The total gas used by `transact` so far in this block.
     /// rollupChainId => block number => `transasct` gasLimit used so far.
     mapping(uint256 => mapping(uint256 => uint256)) public transactGasUsed;
@@ -32,17 +35,37 @@ contract Transactor {
         uint256 maxFeePerGas
     );
 
+    /// @notice Emitted when the admin configures gas limits.
+    event GasConfigured(uint256 perBlock, uint256 perTransact);
+
     /// @notice Thrown when attempting to use more then the current global `transact` gasLimit for the block.
     error PerBlockTransactGasLimit();
 
     /// @notice Thrown when attempting to use too much gas per single `transact` call.
     error PerTransactGasLimit();
 
+    /// @notice Thrown when attempting to configure gas if not the admin.
+    error OnlyGasAdmin();
+
     /// @param _defaultRollupChainId - the chainId of the rollup that Ether will be sent to by default
     ///                                when entering the rollup via fallback() or receive() fns.
-    constructor(uint256 _defaultRollupChainId, Passage _passage) {
+    constructor(
+        uint256 _defaultRollupChainId,
+        address _gasAdmin,
+        Passage _passage,
+        uint256 _perBlockGasLimit,
+        uint256 _perTransactGasLimit
+    ) {
         defaultRollupChainId = _defaultRollupChainId;
+        gasAdmin = _gasAdmin;
         passage = _passage;
+        _configureGas(_perBlockGasLimit, _perTransactGasLimit);
+    }
+
+    /// @notice Configure the `transact` gas limits.
+    function configureGas(uint256 perBlock, uint256 perTransact) external {
+        if (msg.sender != gasAdmin) revert OnlyGasAdmin();
+        _configureGas(perBlock, perTransact);
     }
 
     /// @notice Allows a special transaction to be sent to the rollup with sender == L1 msg.sender.
@@ -93,14 +116,21 @@ contract Transactor {
         }
 
         // ensure per-transact gas limit is respected
-        if (gas > PER_TRANSACT_GAS_LIMIT) revert PerTransactGasLimit();
+        if (gas > perTransactGasLimit) revert PerTransactGasLimit();
 
         // ensure global transact gas limit is respected
         uint256 gasUsed = transactGasUsed[rollupChainId][block.number];
-        if (gasUsed + gas > PER_BLOCK_TRANSACT_GAS_LIMIT) revert PerBlockTransactGasLimit();
+        if (gasUsed + gas > perBlockGasLimit) revert PerBlockTransactGasLimit();
         transactGasUsed[rollupChainId][block.number] = gasUsed + gas;
 
         // emit Transact event
         emit Transact(rollupChainId, msg.sender, to, data, value, gas, maxFeePerGas);
     }
+
+    /// @notice Helper to configure gas limits on deploy & via admin function
+    function _configureGas(uint256 perBlock, uint256 perTransact) internal {
+        perBlockGasLimit = perBlock;
+        perTransactGasLimit = perTransact;
+        emit GasConfigured(perBlock, perTransact);
+    }
 }

test/Transact.t.sol

@@ -28,18 +28,23 @@ contract TransactTest is Test {
         uint256 maxFeePerGas
     );
 
+    event GasConfigured(uint256 perBlock, uint256 perTransact);
+
     // Passage event
     event Enter(uint256 indexed rollupChainId, address indexed rollupRecipient, uint256 amount);
 
     function setUp() public {
         // deploy target
         passage = new Passage(block.chainid + 1, address(this), new address[](0));
-        target = new Transactor(block.chainid + 1, passage);
+        target = new Transactor(block.chainid + 1, address(this), passage, gas * 6, gas);
     }
 
     function test_setUp() public {
         assertEq(target.defaultRollupChainId(), block.chainid + 1);
+        assertEq(target.gasAdmin(), address(this));
         assertEq(address(target.passage()), address(passage));
+        assertEq(target.perBlockGasLimit(), gas * 6);
+        assertEq(target.perTransactGasLimit(), gas);
     }
 
     function test_transact() public {
@@ -88,4 +93,23 @@ contract TransactTest is Test {
         vm.expectRevert(abi.encodeWithSelector(Transactor.PerBlockTransactGasLimit.selector));
         target.transact(to, data, value, 1, maxFeePerGas);
     }
+
+    function test_onlyGasAdmin() public {
+        vm.startPrank(address(0x01));
+        vm.expectRevert(Transactor.OnlyGasAdmin.selector);
+        target.configureGas(0, 0);
+    }
+
+    function test_configureGas() public {
+        uint256 newPerBlock = 40_000_000;
+        uint256 newPerTransact = 2_000_000;
+
+        // configure gas
+        vm.expectEmit();
+        emit GasConfigured(newPerBlock, newPerTransact);
+        target.configureGas(newPerBlock, newPerTransact);
+
+        assertEq(target.perBlockGasLimit(), newPerBlock);
+        assertEq(target.perTransactGasLimit(), newPerTransact);
+    }
 }