Merge pull request #10 from init4tech/anna/one-per-rebase

feat: simple limiting 1 ru block per host block

Author: anna-carroll

src/Zenith.sol

@@ -28,6 +28,10 @@ contract Zenith is HostPassage, AccessControlDefaultAdminRules {
     /// rollupChainId => nextSequence number
     mapping(uint256 => uint256) public nextSequence;
 
+    /// @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
+    mapping(uint256 => uint256) public lastSubmittedAtBlock;
+
     /// @notice Thrown when a block submission is attempted with a sequence number that is not the next block for the rollup chainId.
     /// @dev Blocks must be submitted in strict monotonic increasing order.
     /// @param expected - the correct next sequence number for the given rollup chainId.
@@ -41,6 +45,9 @@ contract Zenith is HostPassage, AccessControlDefaultAdminRules {
     /// @param derivedSequencer - the derived signer of the block data that is not a permissioned sequencer.
     error BadSignature(address derivedSequencer);
 
+    /// @notice Thrown when attempting to submit more than one rollup block per host block
+    error OneRollupBlockPerHostBlock();
+
     /// @notice Emitted when a new rollup block is successfully submitted.
     /// @param sequencer - the address of the sequencer that signed the block.
     /// @param header - the block header information for the block.
@@ -100,6 +107,9 @@ contract Zenith is HostPassage, AccessControlDefaultAdminRules {
         // assert that signature is valid && sequencer is permissioned
         if (!hasRole(SEQUENCER_ROLE, sequencer)) revert BadSignature(sequencer);
 
+        // 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;
 
         // emit event
         emit BlockSubmitted(sequencer, header, blockDataHash);

test/Zenith.t.sol

@@ -97,5 +97,25 @@ contract ZenithTest is Test {
         vm.expectRevert(abi.encodeWithSelector(Zenith.BadSignature.selector, derivedSigner));
         target.submitBlock(header, blockDataHash, v, r, s, blockData);
     }
+
+    // cannot submit two rollup blocks within one host block
+    function test_onePerBlock() public {
+        // sign block commitmenet with correct sequencer key
+        (uint8 v, bytes32 r, bytes32 s) = vm.sign(sequencerKey, commit);
+
+        // should emit BlockSubmitted event
+        vm.expectEmit();
+        emit BlockSubmitted(vm.addr(sequencerKey), header, blockDataHash);
+        target.submitBlock(header, blockDataHash, v, r, s, blockData);
+
+        // incerement the header sequence
+        header.sequence += 1;
+        commit = target.blockCommitment(header, blockDataHash);
+        (v, r, s) = vm.sign(sequencerKey, commit);
+
+        // should revert with OneRollupBlockPerHostBlock
+        // (NOTE: this test works because forge does not increment block.number when it mines a transaction)
+        vm.expectRevert(abi.encodeWithSelector(Zenith.OneRollupBlockPerHostBlock.selector));
+        target.submitBlock(header, blockDataHash, v, r, s, blockData);
     }
 }