add blockDataHash

Author: anna-carroll

src/Zenith.sol

@@ -44,7 +44,8 @@ contract Zenith is HostPassage, AccessControlDefaultAdminRules {
     /// @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.
-    event BlockSubmitted(address indexed sequencer, BlockHeader indexed header);
+    /// @param blockDataHash - keccak256(blockData). the Node will discard the block if the hash doens't match.
+    event BlockSubmitted(address indexed sequencer, BlockHeader indexed header, bytes32 blockDataHash);
 
     /// @notice Emit the entire block data for easy visibility
     event BlockData(bytes blockData);
@@ -59,23 +60,32 @@ contract Zenith is HostPassage, AccessControlDefaultAdminRules {
     /// @notice Submit a rollup block with block data submitted via calldata.
     /// @dev Blocks are submitted by Builders, with an attestation to the block data signed by a Sequencer.
     /// @param header - the header information for the rollup block.
-    /// @param blockData - block data information. could be blob hashes / indices, or direct rlp-encoded transctions. blockData is ignored by the contract logic.
+    /// @param blockDataHash - keccak256(blockData). the Node will discard the block if the hash doens't match.
+    /// @dev including blockDataHash allows the sequencer to sign over finalized block data, without needing to calldatacopy the `blockData` param.
     /// @param v - the v component of the Sequencer's ECSDA signature over the block header.
     /// @param r - the r component of the Sequencer's ECSDA signature over the block header.
     /// @param s - the s component of the Sequencer's ECSDA signature over the block header.
+    /// @param blockData - block data information. could be packed blob hashes, or direct rlp-encoded transctions. blockData is ignored by the contract logic.
     /// @custom:reverts BadSequence if the sequence number is not the next block for the given rollup chainId.
     /// @custom:reverts BlockExpired if the confirmBy time has passed.
     /// @custom:reverts BadSignature if the signer is not a permissioned sequencer,
     ///                 OR if the signature provided commits to a different header.
     /// @custom:reverts OneRollupBlockPerHostBlock if attempting to submit a second rollup block within one host block.
     /// @custom:emits BlockSubmitted if the block is successfully submitted.
     /// @custom:emits BlockData to expose the block calldata; as a convenience until calldata tracing is implemented in the Node.
-    function submitBlock(BlockHeader memory header, uint8 v, bytes32 r, bytes32 s, bytes calldata blockData) external {
-        _submitBlock(header, v, r, s);
+    function submitBlock(
+        BlockHeader memory header,
+        bytes32 blockDataHash,
+        uint8 v,
+        bytes32 r,
+        bytes32 s,
+        bytes calldata blockData
+    ) external {
+        _submitBlock(header, blockDataHash, v, r, s);
         emit BlockData(blockData);
     }
 
-    function _submitBlock(BlockHeader memory header, uint8 v, bytes32 r, bytes32 s) internal {
+    function _submitBlock(BlockHeader memory header, bytes32 blockDataHash, uint8 v, bytes32 r, bytes32 s) internal {
         // assert that the sequence number is valid and increment it
         uint256 _nextSequence = nextSequence[header.rollupChainId]++;
         if (_nextSequence != header.sequence) revert BadSequence(_nextSequence);
@@ -84,29 +94,30 @@ contract Zenith is HostPassage, AccessControlDefaultAdminRules {
         if (block.timestamp > header.confirmBy) revert BlockExpired();
 
         // derive sequencer from signature over block header
-        bytes32 blockCommit = blockCommitment(header);
+        bytes32 blockCommit = blockCommitment(header, blockDataHash);
         address sequencer = ecrecover(blockCommit, v, r, s);
 
         // assert that signature is valid && sequencer is permissioned
         if (!hasRole(SEQUENCER_ROLE, sequencer)) revert BadSignature(sequencer);
 
 
         // emit event
-        emit BlockSubmitted(sequencer, header);
+        emit BlockSubmitted(sequencer, header, blockDataHash);
     }
 
     /// @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.
-    function blockCommitment(BlockHeader memory header) public view returns (bytes32 commit) {
+    function blockCommitment(BlockHeader memory header, bytes32 blockDataHash) public view returns (bytes32 commit) {
         bytes memory encoded = abi.encodePacked(
             "init4.sequencer.v0",
             block.chainid,
             header.rollupChainId,
             header.sequence,
             header.gasLimit,
             header.confirmBy,
-            header.rewardAddress
+            header.rewardAddress,
+            blockDataHash
         );
         commit = keccak256(encoded);
     }

test/Zenith.t.sol

@@ -11,11 +11,12 @@ contract ZenithTest is Test {
     bytes32 commit;
     /// @dev blockData is ignored by the contract. it's included for the purpose of DA for the node.
     bytes blockData = "0x1234567890abcdef";
+    bytes32 blockDataHash;
 
     uint256 sequencerKey = 123;
     uint256 notSequencerKey = 300;
 
-    event BlockSubmitted(address indexed sequencer, Zenith.BlockHeader indexed header);
+    event BlockSubmitted(address indexed sequencer, Zenith.BlockHeader indexed header, bytes32 blockDataHash);
 
     function setUp() public {
         target = new Zenith(address(this));
@@ -28,34 +29,36 @@ contract ZenithTest is Test {
         header.gasLimit = 30_000_000;
         header.rewardAddress = address(this);
 
+        blockDataHash = keccak256(blockData);
+
         // derive block commitment from the header
-        commit = target.blockCommitment(header);
+        commit = target.blockCommitment(header, blockDataHash);
     }
 
     // cannot submit block with incorrect sequence number
     function test_badSequence() public {
         // change to incorrect sequence number
         header.sequence = 1;
-        commit = target.blockCommitment(header);
+        commit = target.blockCommitment(header, blockDataHash);
 
         // sign block commitmenet with sequencer key
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(sequencerKey, commit);
 
         vm.expectRevert(abi.encodeWithSelector(Zenith.BadSequence.selector, 0));
-        target.submitBlock(header, v, r, s, blockData);
+        target.submitBlock(header, blockDataHash, v, r, s, blockData);
     }
 
     // cannot submit block with expired confirmBy time
     function test_blockExpired() public {
         // change to expired confirmBy time
         header.confirmBy = block.timestamp - 1;
-        commit = target.blockCommitment(header);
+        commit = target.blockCommitment(header, blockDataHash);
 
         // sign block commitmenet with sequencer key
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(sequencerKey, commit);
 
         vm.expectRevert(abi.encodeWithSelector(Zenith.BlockExpired.selector));
-        target.submitBlock(header, v, r, s, blockData);
+        target.submitBlock(header, blockDataHash, v, r, s, blockData);
     }
 
     // can submit block successfully with acceptable header & correct signature provided
@@ -65,8 +68,8 @@ contract ZenithTest is Test {
 
         // should emit BlockSubmitted event
         vm.expectEmit();
-        emit BlockSubmitted(vm.addr(sequencerKey), header);
-        target.submitBlock(header, v, r, s, blockData);
+        emit BlockSubmitted(vm.addr(sequencerKey), header, blockDataHash);
+        target.submitBlock(header, blockDataHash, v, r, s, blockData);
 
         // should increment sequence number
         assertEq(target.nextSequence(header.rollupChainId), header.sequence + 1);
@@ -78,7 +81,7 @@ contract ZenithTest is Test {
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(notSequencerKey, commit);
 
         vm.expectRevert(abi.encodeWithSelector(Zenith.BadSignature.selector, vm.addr(notSequencerKey)));
-        target.submitBlock(header, v, r, s, blockData);
+        target.submitBlock(header, blockDataHash, v, r, s, blockData);
     }
 
     // cannot submit block with sequencer signature over different block header data
@@ -88,10 +91,11 @@ contract ZenithTest is Test {
 
         // change header data from what was signed by sequencer
         header.confirmBy = block.timestamp + 15 minutes;
-        bytes32 newCommit = target.blockCommitment(header);
+        bytes32 newCommit = target.blockCommitment(header, blockDataHash);
         address derivedSigner = ecrecover(newCommit, v, r, s);
 
         vm.expectRevert(abi.encodeWithSelector(Zenith.BadSignature.selector, derivedSigner));
-        target.submitBlock(header, v, r, s, blockData);
+        target.submitBlock(header, blockDataHash, v, r, s, blockData);
+    }
     }
 }