feat: implement transact gas limits

Author: anna-carroll

.gas-snapshot

@@ -24,14 +24,16 @@ PassageTest:test_onlyTokenAdmin() (gas: 16881)
 PassageTest:test_receive() (gas: 21339)
 PassageTest:test_setUp() (gas: 16901)
 PassageTest:test_withdraw() (gas: 59055)
-ZenithTest:test_addSequencer() (gas: 88222)
-ZenithTest:test_badSignature() (gas: 37320)
-ZenithTest:test_incorrectHostBlock() (gas: 35165)
-ZenithTest:test_notSequencer() (gas: 34155)
-ZenithTest:test_notSequencerAdmin() (gas: 10137)
-ZenithTest:test_onePerBlock() (gas: 68351)
-ZenithTest:test_removeSequencer() (gas: 39744)
-ZenithTest:test_setUp() (gas: 8410)
-ZenithTest:test_submitBlock() (gas: 63456)
-ZenithTest:test_transact() (gas: 32536)
-ZenithTest:test_transact_defaultChain() (gas: 31022)
+ZenithTest:test_addSequencer() (gas: 110340)
+ZenithTest:test_badSignature() (gas: 37389)
+ZenithTest:test_incorrectHostBlock() (gas: 35233)
+ZenithTest:test_notSequencer() (gas: 34157)
+ZenithTest:test_notSequencerAdmin() (gas: 10149)
+ZenithTest:test_onePerBlock() (gas: 90513)
+ZenithTest:test_removeSequencer() (gas: 39747)
+ZenithTest:test_setUp() (gas: 8478)
+ZenithTest:test_submitBlock() (gas: 85551)
+ZenithTest:test_transact() (gas: 135881)
+ZenithTest:test_transact_defaultChain() (gas: 126171)
+ZenithTest:test_transact_globalGasLimit() (gas: 152687)
+ZenithTest:test_transact_perTransactGasLimit() (gas: 106413)

src/Zenith.sol

@@ -4,6 +4,9 @@ pragma solidity ^0.8.24;
 import {Passage} from "./Passage.sol";
 
 contract Zenith {
+    /// @notice Each `transact` call cannot use more than 1/5 of the global `transact` gasLimit for the block.
+    uint256 public constant PER_TRANSACT_GAS_LIMIT = 5;
+
     /// @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;
 
@@ -30,9 +33,18 @@ contract Zenith {
     }
 
     /// @notice The host block number that a block was last submitted at for a given rollup chainId.
-    /// rollupChainId => host blockNumber that block was last submitted at
+    /// rollupChainId => host blockNumber the last block was submitted at.
     mapping(uint256 => uint256) public lastSubmittedAtBlock;
 
+    /// @notice The gasLimit of the last submitted block for a given rollup chainId.
+    /// @dev NOTE that this can change mid-block, causing some `transact` to have a different limit than others.
+    /// rollupChainId => gasLimit of the previous block.
+    mapping(uint256 => uint256) public currentGasLimit;
+
+    /// @notice The total gasLimit used by `transact` so far in this block.
+    /// rollupChainId => block number => `transasct` gasLimit used so far.
+    mapping(uint256 => mapping(uint256 => uint256)) public transactGasUsed;
+
     /// @notice Registry of permissioned sequencers.
     /// address => TRUE if it's a permissioned sequencer
     mapping(address => bool) public isSequencer;
@@ -48,6 +60,12 @@ contract Zenith {
     /// @notice Thrown when attempting to submit more than one rollup block per host block
     error OneRollupBlockPerHostBlock();
 
+    /// @notice Thrown when attempting to use more then the current global `transact` gasLimit for the block.
+    error GlobalTransactGasLimitReached(uint256 globalTransactLimit);
+
+    /// @notice Thrown when attempting to use too much gas per single `transact` call.
+    error PerTransactGasLimitReached(uint256 perTransactLimit);
+
     /// @notice Thrown when attempting to modify sequencer roles if not sequencerAdmin.
     error OnlySequencerAdmin();
 
@@ -133,13 +151,19 @@ contract Zenith {
         // assert this is the first rollup block submitted for this host block
         if (lastSubmittedAtBlock[header.rollupChainId] == block.number) revert OneRollupBlockPerHostBlock();
         lastSubmittedAtBlock[header.rollupChainId] = block.number;
+        currentGasLimit[header.rollupChainId] = header.gasLimit;
 
         // emit event
         emit BlockSubmitted(
             sequencer, header.rollupChainId, header.gasLimit, header.rewardAddress, header.blockDataHash
         );
     }
 
+    /// @dev See `transact` for docs.
+    function transact(address to, bytes calldata data, uint256 value, uint256 gas, uint256 maxFeePerGas) external {
+        transact(defaultRollupChainId, to, data, value, gas, maxFeePerGas);
+    }
+
     /// @notice Send a special transaction to be sent to the rollup with sender == L1 msg.sender.
     /// @dev Transact is processed after normal rollup block execution.
     /// @param rollupChainId - The rollup chain to send the transaction to.
@@ -157,15 +181,20 @@ contract Zenith {
         uint256 gas,
         uint256 maxFeePerGas
     ) public {
+        // ensure per-transact gas limit is respected
+        uint256 globalLimit = currentGasLimit[rollupChainId];
+        uint256 perTransactLimit = globalLimit / PER_TRANSACT_GAS_LIMIT;
+        if (gas > perTransactLimit) revert PerTransactGasLimitReached(perTransactLimit);
+
+        // ensure global transact gas limit is respected
+        uint256 gasUsed = transactGasUsed[rollupChainId][block.number];
+        if (gasUsed + gas > globalLimit) revert GlobalTransactGasLimitReached(globalLimit);
+        transactGasUsed[rollupChainId][block.number] = gasUsed + gas;
+
         // emit Transact event
         emit Transact(rollupChainId, msg.sender, to, data, value, gas, maxFeePerGas);
     }
 
-    /// @dev See `transact` for docs.
-    function transact(address to, bytes calldata data, uint256 value, uint256 gas, uint256 maxFeePerGas) external {
-        transact(defaultRollupChainId, to, data, value, gas, maxFeePerGas);
-    }
-
     /// @notice Construct hash of block details that the sequencer signs.
     /// @param header - the header information for the rollup block.
     /// @return commit - the hash of the encoded block details.

test/Zenith.t.sol

@@ -19,7 +19,7 @@ contract ZenithTest is Test {
     address to = address(0x01);
     bytes data = abi.encode(0xbeef);
     uint256 value = 100;
-    uint256 gas = 10_000_000;
+    uint256 gas = 6_000_000;
     uint256 maxFeePerGas = 50;
 
     event BlockSubmitted(
@@ -43,7 +43,7 @@ contract ZenithTest is Test {
     );
 
     function setUp() public {
-        target = new Zenith(block.number + 1, address(this));
+        target = new Zenith(block.chainid + 1, address(this));
         target.addSequencer(vm.addr(sequencerKey));
 
         // set default block values
@@ -178,14 +178,55 @@ contract ZenithTest is Test {
     }
 
     function test_transact() public {
+        // submit a block to set the prevGasLimit to 30M
+        header.rollupChainId = chainId;
+        commit = target.blockCommitment(header);
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(sequencerKey, commit);
+        target.submitBlock(header, v, r, s, blockData);
+
         vm.expectEmit();
         emit Transact(chainId, address(this), to, data, value, gas, maxFeePerGas);
         target.transact(chainId, to, data, value, gas, maxFeePerGas);
     }
 
     function test_transact_defaultChain() public {
+        // submit a block to set the prevGasLimit to 30M
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(sequencerKey, commit);
+        target.submitBlock(header, v, r, s, blockData);
+
         vm.expectEmit();
         emit Transact(target.defaultRollupChainId(), address(this), to, data, value, gas, maxFeePerGas);
         target.transact(to, data, value, gas, maxFeePerGas);
     }
+
+    function test_transact_perTransactGasLimit() public {
+        // submit a block to set the prevGasLimit to 30M
+        header.rollupChainId = chainId;
+        commit = target.blockCommitment(header);
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(sequencerKey, commit);
+        target.submitBlock(header, v, r, s, blockData);
+
+        // attempt transact with 6M + 1 gas.
+        vm.expectRevert(
+            abi.encodeWithSelector(
+                Zenith.PerTransactGasLimitReached.selector, (header.gasLimit / target.PER_TRANSACT_GAS_LIMIT())
+            )
+        );
+        target.transact(chainId, to, data, value, gas + 1, maxFeePerGas);
+    }
+
+    function test_transact_globalGasLimit() public {
+        // submit a block to set the prevGasLimit to 30M
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(sequencerKey, commit);
+        target.submitBlock(header, v, r, s, blockData);
+
+        // submit 5x transacts with 6M gas, consuming the total 30M global limit
+        for (uint256 i; i < 5; i++) {
+            target.transact(to, data, value, gas, maxFeePerGas);
+        }
+
+        // attempt to submit another transact with 1 gas - should revert.
+        vm.expectRevert(abi.encodeWithSelector(Zenith.GlobalTransactGasLimitReached.selector, header.gasLimit));
+        target.transact(to, data, value, 1, maxFeePerGas);
+    }
 }