refactor: ignore blockData entirely, just emit it; unify codepaths

Author: anna-carroll

src/Zenith.sol

@@ -7,20 +7,12 @@ import {AccessControlDefaultAdminRules} from
     "openzeppelin-contracts/contracts/access/extensions/AccessControlDefaultAdminRules.sol";
 
 contract Zenith is HostPassage, AccessControlDefaultAdminRules {
-    /// @notice The location where the block data was submitted.
-    /// @param Blobs - the block data was submitted as 4844 blobs. the `submitBlock` calldata contains `blobIndices` which can be used to pull the blobs / blob hashes.
-    /// @param Calldata - the block data was submitted directly via the `submitBlock` calldata.
-    enum DataLocation {
-        Blobs,
-        Calldata
-    }
     /// @notice Block header information for the rollup block, signed by the sequencer.
     /// @param rollupChainId - the chainId of the rollup chain. Any chainId is accepted by the contract.
     /// @param sequence - the sequence number of the rollup block. Must be monotonically increasing. Enforced by the contract.
     /// @param confirmBy - the timestamp by which the block must be submitted. Enforced by the contract.
     /// @param gasLimit - the gas limit for the rollup block. Ignored by the contract; enforced by the Node.
     /// @param rewardAddress - the address to receive the rollup block reward. Ignored by the contract; enforced by the Node.
-
     struct BlockHeader {
         uint256 rollupChainId;
         uint256 sequence;
@@ -50,17 +42,13 @@ contract Zenith is HostPassage, AccessControlDefaultAdminRules {
     error BadSignature(address derivedSequencer);
 
     /// @notice Emitted when a new rollup block is successfully submitted.
-    /// @param location - the location where the block data was submitted.
     /// @param sequencer - the address of the sequencer that signed the block.
     /// @param header - the block header information for the block.
-    event BlockSubmitted(DataLocation indexed location, address indexed sequencer, BlockHeader indexed header);
+    event BlockSubmitted(address indexed sequencer, BlockHeader indexed header);
 
     /// @notice Emit the entire block data for easy visibility
     event BlockData(bytes blockData);
 
-    /// @notice Emit the blob indices for easy visibility
-    event BlobIndices(uint32[] blobIndices);
-
     /// @notice Initializes the Admin role.
     /// @dev See `AccessControlDefaultAdminRules` for information on contract administration.
     ///      - Admin role can grant and revoke Sequencer roles.
@@ -69,132 +57,56 @@ contract Zenith is HostPassage, AccessControlDefaultAdminRules {
     constructor(address admin) AccessControlDefaultAdminRules(1 days, admin) {}
 
     /// @notice Submit a rollup block with block data submitted via calldata.
-    /// @param header - see _submitBlock.
-    /// @param blockData - full data for the block supplied directly.
-    /// @param v - see _submitBlock.
-    /// @param r - see _submitBlock.
-    /// @param s - see _submitBlock.
-    /// @custom:reverts see _submitBlock.
-    /// @custom:emits see _submitBlock.
-    function submitBlock(BlockHeader memory header, bytes calldata blockData, uint8 v, bytes32 r, bytes32 s) external {
-        bytes32 blockCommit = blockCommitment(header, blockData);
-
-        _submitBlock(DataLocation.Calldata, header, blockCommit, v, r, s);
-
-        emit BlockData(blockData);
-    }
-
-    /// @notice Submit a rollup block with block data stored in 4844 blobs.
-    /// @param header - see _submitBlock.
-    /// @param blobIndices - the indices of the 4844 blob hashes for the block data.
-    /// @param v - see _submitBlock.
-    /// @param r - see _submitBlock.
-    /// @param s - see _submitBlock.
-    /// @custom:reverts see _submitBlock.
-    /// @custom:emits see _submitBlock.
-    function submitBlock(BlockHeader memory header, uint32[] calldata blobIndices, uint8 v, bytes32 r, bytes32 s)
-        external
-    {
-        bytes32 blockCommit = blockCommitment(header, blobIndices);
-
-        _submitBlock(DataLocation.Blobs, header, blockCommit, v, r, s);
-
-        emit BlobIndices(blobIndices);
-    }
-
-    /// @notice Submit a rollup block.
     /// @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 blockCommit - the hashes `blockCommitment` signed by the Sequencer.
-    /// @param v - the v component of the Sequencer's ECSDA signature over the block commitment.
-    /// @param r - the r component of the Sequencer's ECSDA signature over the block commitment.
-    /// @param s - the s component of the Sequencer's ECSDA signature over the block commitment.
+    /// @param blockData - block data information. could be blob hashes / indices, or direct rlp-encoded transctions. blockData is ignored by the contract logic.
+    /// @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.
     /// @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 different block data.
+    ///                 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.
-    function _submitBlock(
-        DataLocation location,
-        BlockHeader memory header,
-        bytes32 blockCommit,
-        uint8 v,
-        bytes32 r,
-        bytes32 s
-    ) internal {
+    /// @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);
+        emit BlockData(blockData);
+    }
+
+    function _submitBlock(BlockHeader memory header, 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);
 
         // assert that confirmBy time has not passed
         if (block.timestamp > header.confirmBy) revert BlockExpired();
 
-        // derive sequencer from signature
+        // derive sequencer from signature over block header
+        bytes32 blockCommit = blockCommitment(header);
         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(location, sequencer, header);
-    }
-
-    /// @notice Encode an array of blob hashes, given their indices in the transaction.
-    /// @param blobIndices - the indices of the 4844 blob hashes for the block data.
-    /// @return encodedHashes - the encoded blob hashes.
-    function getHashes(uint32[] calldata blobIndices) internal view returns (bytes memory encodedHashes) {
-        for (uint32 i = 0; i < blobIndices.length; i++) {
-            encodedHashes = abi.encodePacked(encodedHashes, blobhash(blobIndices[i]));
-        }
-    }
 
-    /// @notice Construct hash of block details that the sequencer signs.
-    /// @dev NOTE: we have separate blockCommitment functions in order to keep `blockData` as `calldata`, which is not possible for `encodedHashes`
-    /// @param header - the header information for the rollup block.
-    /// @param blockData - full data for the block supplied directly.
-    /// @return commit - the hash of the encoded block details.
-    function blockCommitment(BlockHeader memory header, bytes calldata blockData)
-        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,
-            blockData.length,
-            blockData
-        );
-        commit = keccak256(encoded);
+        // emit event
+        emit BlockSubmitted(sequencer, header);
     }
 
     /// @notice Construct hash of block details that the sequencer signs.
     /// @param header - the header information for the rollup block.
-    /// @param blobIndices - the indices of the 4844 blob hashes for the block data.
     /// @return commit - the hash of the encoded block details.
-    function blockCommitment(BlockHeader memory header, uint32[] calldata blobIndices)
-        public
-        view
-        returns (bytes32 commit)
-    {
-        // query the blob hashes via the indices in order to
-        // ensure that the committed blob hashes are available in the transaction.
-        bytes memory encodedHashes = getHashes(blobIndices);
-
+    function blockCommitment(BlockHeader memory header) 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,
-            encodedHashes.length,
-            encodedHashes
+            header.rewardAddress
         );
         commit = keccak256(encoded);
     }

test/Zenith.t.sol

@@ -8,16 +8,14 @@ contract ZenithTest is Test {
     Zenith public target;
 
     Zenith.BlockHeader header;
-    bytes32[] blobHashes;
-    uint32[] blobIndices;
     bytes32 commit;
+    /// @dev blockData is ignored by the contract. it's included for the purpose of DA for the node.
+    bytes blockData = "0x1234567890abcdef";
 
     uint256 sequencerKey = 123;
     uint256 notSequencerKey = 300;
 
-    event BlockSubmitted(
-        Zenith.DataLocation indexed location, address indexed sequencer, Zenith.BlockHeader indexed header
-    );
+    event BlockSubmitted(address indexed sequencer, Zenith.BlockHeader indexed header);
 
     function setUp() public {
         target = new Zenith(address(this));
@@ -30,99 +28,70 @@ contract ZenithTest is Test {
         header.gasLimit = 30_000_000;
         header.rewardAddress = address(this);
 
-        // set default blob info
-        blobIndices.push(0);
-        blobHashes.push(bytes32("JUNK BLOBHASH"));
-        // TODO: vm.blobhashes(blobHashes);
-
-        // derive block commitment from sequence number and blobhashes
-        commit = target.blockCommitment(header, packHashes(blobHashes));
-    }
-
-    /// @notice Encode the array of blob hashes into a bytes string.
-    /// @param _blobHashes - the 4844 blob hashes for the block data.
-    /// @return encodedHashes - the encoded blob hashes.
-    function packHashes(bytes32[] memory _blobHashes) public pure returns (bytes memory encodedHashes) {
-        for (uint32 i = 0; i < _blobHashes.length; i++) {
-            encodedHashes = abi.encodePacked(encodedHashes, _blobHashes[i]);
-        }
+        // derive block commitment from the header
+        commit = target.blockCommitment(header);
     }
 
     // cannot submit block with incorrect sequence number
     function test_badSequence() public {
         // change to incorrect sequence number
         header.sequence = 1;
+        commit = target.blockCommitment(header);
 
         // 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, blobIndices, v, r, s);
+        target.submitBlock(header, 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);
 
         // 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, blobIndices, v, r, s);
+        target.submitBlock(header, v, r, s, blockData);
     }
 
-    // BLOCKED by PR supporting vm.blobhashes: https://github.com/foundry-rs/foundry/pull/7001
-    // can submit block successfully with acceptable data & correct signature provided
-    function BLOCKED_test_submitBlock() public {
+    // can submit block successfully with acceptable header & correct signature provided
+    function test_submitBlock() 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(Zenith.DataLocation.Blobs, vm.addr(sequencerKey), header);
-        target.submitBlock(header, blobIndices, v, r, s);
+        emit BlockSubmitted(vm.addr(sequencerKey), header);
+        target.submitBlock(header, v, r, s, blockData);
 
         // should increment sequence number
         assertEq(target.nextSequence(header.rollupChainId), header.sequence + 1);
     }
 
     // cannot submit block with invalid sequencer signer from non-permissioned key
-    function BLOCKED_test_notSequencer() public {
+    function test_notSequencer() public {
         // sign block commitmenet with NOT sequencer key
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(notSequencerKey, commit);
 
         vm.expectRevert(abi.encodeWithSelector(Zenith.BadSignature.selector, vm.addr(notSequencerKey)));
-        target.submitBlock(header, blobIndices, v, r, s);
+        target.submitBlock(header, v, r, s, blockData);
     }
 
     // cannot submit block with sequencer signature over different block header data
-    function BLOCKED_test_badSignature_header() public {
+    function test_badSignature() public {
         // sign original block commitmenet with sequencer key
         (uint8 v, bytes32 r, bytes32 s) = vm.sign(sequencerKey, commit);
 
         // change header data from what was signed by sequencer
         header.confirmBy = block.timestamp + 15 minutes;
-
-        bytes32 newCommit = target.blockCommitment(header, packHashes(blobHashes));
-        address derivedSigner = ecrecover(newCommit, v, r, s);
-
-        vm.expectRevert(abi.encodeWithSelector(Zenith.BadSignature.selector, derivedSigner));
-        target.submitBlock(header, blobIndices, v, r, s);
-    }
-
-    // cannot submit block with sequencer signature over different blob hashes
-    function BLOCKED_test_badSignature_blobs() public {
-        // sign original block commitmenet with sequencer key
-        (uint8 v, bytes32 r, bytes32 s) = vm.sign(sequencerKey, commit);
-
-        blobHashes[0] = bytes32("DIFFERENT BLOBHASH");
-        // TODO: vm.blobhashes(blobHashes);
-
-        bytes32 newCommit = target.blockCommitment(header, packHashes(blobHashes));
+        bytes32 newCommit = target.blockCommitment(header);
         address derivedSigner = ecrecover(newCommit, v, r, s);
 
         vm.expectRevert(abi.encodeWithSelector(Zenith.BadSignature.selector, derivedSigner));
-        target.submitBlock(header, blobIndices, v, r, s);
+        target.submitBlock(header, v, r, s, blockData);
     }
 }