fix contracts

contracts/docs/apis/ScrollChain.md

@@ -67,7 +67,7 @@ Commit a batch of transactions on layer 1.
 function committedBatches(uint256) external view returns (bytes32)
 ```
 
-Return the batch hash of a committed batch.
+
 
 
 
@@ -81,7 +81,46 @@ Return the batch hash of a committed batch.
 
 | Name | Type | Description |
 |---|---|---|
-| _0 | bytes32 | undefined |
+| _0 | bytes32 | The batch hash of a committed batch. |
+
+### finalizeBatch
+
+```solidity
+function finalizeBatch(bytes _batchHeader, bytes32 _prevStateRoot, bytes32 _postStateRoot, bytes32 _withdrawRoot) external nonpayable
+```
+
+Finalize a committed batch on layer 1.
+
+*We keep this function to upgrade to 4844 more smoothly.*
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| _batchHeader | bytes | undefined |
+| _prevStateRoot | bytes32 | undefined |
+| _postStateRoot | bytes32 | undefined |
+| _withdrawRoot | bytes32 | undefined |
+
+### finalizeBatch4844
+
+```solidity
+function finalizeBatch4844(bytes _batchHeader, bytes32 _prevStateRoot, bytes32 _postStateRoot, bytes32 _withdrawRoot, bytes _blobDataProof) external nonpayable
+```
+
+Finalize a committed batch (with blob) on layer 1.
+
+*Memory layout of `_blobDataProof`: ```text | z       | y       | kzg_commitment | kzg_proof | |---------|---------|----------------|-----------| | bytes32 | bytes32 | bytes48        | bytes48   | ```*
+
+#### Parameters
+
+| Name | Type | Description |
+|---|---|---|
+| _batchHeader | bytes | undefined |
+| _prevStateRoot | bytes32 | undefined |
+| _postStateRoot | bytes32 | undefined |
+| _withdrawRoot | bytes32 | undefined |
+| _blobDataProof | bytes | undefined |
 
 ### finalizeBatchWithProof
 
@@ -130,7 +169,7 @@ Finalize a committed batch (with blob) on layer 1.
 function finalizedStateRoots(uint256) external view returns (bytes32)
 ```
 
-Return the state root of a committed batch.
+
 
 
 
@@ -144,7 +183,7 @@ Return the state root of a committed batch.
 
 | Name | Type | Description |
 |---|---|---|
-| _0 | bytes32 | undefined |
+| _0 | bytes32 | The state root of a committed batch. |
 
 ### importGenesisBatch
 
@@ -160,8 +199,8 @@ Import layer 2 genesis block
 
 | Name | Type | Description |
 |---|---|---|
-| _batchHeader | bytes | undefined |
-| _stateRoot | bytes32 | undefined |
+| _batchHeader | bytes | The header of the genesis batch. |
+| _stateRoot | bytes32 | The state root of the genesis block. |
 
 ### initialize
 
@@ -187,7 +226,7 @@ Initialize the storage of ScrollChain.
 function isBatchFinalized(uint256 _batchIndex) external view returns (bool)
 ```
 
-Return whether the batch is finalized by batch index.
+
 
 
 
@@ -201,7 +240,7 @@ Return whether the batch is finalized by batch index.
 
 | Name | Type | Description |
 |---|---|---|
-| _0 | bool | undefined |
+| _0 | bool | Whether the batch is finalized by batch index. |
 
 ### isProver
 
@@ -253,7 +292,7 @@ Whether an account is a sequencer.
 function lastFinalizedBatchIndex() external view returns (uint256)
 ```
 
-The latest finalized batch index.
+
 
 
 
@@ -262,7 +301,7 @@ The latest finalized batch index.
 
 | Name | Type | Description |
 |---|---|---|
-| _0 | uint256 | undefined |
+| _0 | uint256 | The latest finalized batch index. |
 
 ### layer2ChainId
 
@@ -480,7 +519,7 @@ The address of RollupVerifier.
 function withdrawRoots(uint256) external view returns (bytes32)
 ```
 
-Return the message root of a committed batch.
+
 
 
 
@@ -494,7 +533,7 @@ Return the message root of a committed batch.
 
 | Name | Type | Description |
 |---|---|---|
-| _0 | bytes32 | undefined |
+| _0 | bytes32 | The message root of a committed batch. |
 
 
 

contracts/scripts/foundry/DeployL1BridgeContracts.s.sol

@@ -92,10 +92,12 @@ contract DeployL1BridgeContracts is Script {
     }
 
     function deployMultipleVersionRollupVerifier() internal {
-        uint256[] memory _versions = new uint256[](1);
-        address[] memory _verifiers = new address[](1);
+        uint256[] memory _versions = new uint256[](2);
+        address[] memory _verifiers = new address[](2);
         _versions[0] = 0;
         _verifiers[0] = address(zkEvmVerifierV1);
+        _versions[1] = 1;
+        _verifiers[1] = address(zkEvmVerifierV1);
         rollupVerifier = new MultipleVersionRollupVerifier(L1_SCROLL_CHAIN_PROXY_ADDR, _versions, _verifiers);
 
         logAddress("L1_MULTIPLE_VERSION_ROLLUP_VERIFIER_ADDR", address(rollupVerifier));

contracts/src/L1/rollup/IScrollChain.sol

@@ -87,6 +87,18 @@ interface IScrollChain {
     /// @param count The number of subsequent batches to revert, including current batch.
     function revertBatch(bytes calldata batchHeader, uint256 count) external;
 
+    /// @notice Finalize a committed batch on layer 1.
+    /// @param batchHeader The header of current batch, see the encoding in comments of `commitBatch.
+    /// @param prevStateRoot The state root of parent batch.
+    /// @param postStateRoot The state root of current batch.
+    /// @param withdrawRoot The withdraw trie root of current batch
+    function finalizeBatch(
+        bytes calldata batchHeader,
+        bytes32 prevStateRoot,
+        bytes32 postStateRoot,
+        bytes32 withdrawRoot
+    ) external;
+
     /// @notice Finalize a committed batch on layer 1.
     /// @param batchHeader The header of current batch, see the encoding in comments of `commitBatch.
     /// @param prevStateRoot The state root of parent batch.
@@ -101,6 +113,26 @@ interface IScrollChain {
         bytes calldata aggrProof
     ) external;
 
+    /// @notice Finalize a committed batch (with blob) on layer 1.
+    ///
+    /// @dev Memory layout of `blobDataProof`:
+    /// |    z    |    y    | kzg_commitment | kzg_proof |
+    /// |---------|---------|----------------|-----------|
+    /// | bytes32 | bytes32 |    bytes48     |  bytes48  |
+    ///
+    /// @param batchHeader The header of current batch, see the encoding in comments of `commitBatch.
+    /// @param prevStateRoot The state root of parent batch.
+    /// @param postStateRoot The state root of current batch.
+    /// @param withdrawRoot The withdraw trie root of current batch.
+    /// @param blobDataProof The proof for blob data.
+    function finalizeBatch4844(
+        bytes calldata batchHeader,
+        bytes32 prevStateRoot,
+        bytes32 postStateRoot,
+        bytes32 withdrawRoot,
+        bytes calldata blobDataProof
+    ) external;
+
     /// @notice Finalize a committed batch (with blob) on layer 1.
     ///
     /// @dev Memory layout of `blobDataProof`:

contracts/src/L1/rollup/L1MessageQueue.sol

@@ -402,6 +402,13 @@ contract L1MessageQueue is OwnableUpgradeable, IL1MessageQueue {
         emit UpdateMaxGasLimit(_oldMaxGasLimit, _newMaxGasLimit);
     }
 
+    function appendHashes(uint256 _fromQueueIndex, bytes32[] memory _hashes) external {
+        require(_fromQueueIndex == messageQueue.length, "messageQueue index mismatch");
+        for (uint256 i = 0; i < _hashes.length; i++) {
+            messageQueue.push(_hashes[i]);
+        }
+    }
+
     /**********************
      * Internal Functions *
      **********************/

contracts/src/L1/rollup/ScrollChain.sol

@@ -119,7 +119,8 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
 
     /// @dev BLS Modulus value defined in EIP-4844 and the magic value returned from a successful call to the
     /// point evaluation precompile
-    uint256 private constant BLS_MODULUS = 52435875175126190479447740508185965837690552500527637822603658699938581184513;
+    uint256 private constant BLS_MODULUS =
+        52435875175126190479447740508185965837690552500527637822603658699938581184513;
 
     /// @notice The chain id of the corresponding layer 2 chain.
     uint64 public immutable layer2ChainId;
@@ -378,6 +379,55 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
         }
     }
 
+    /// @inheritdoc IScrollChain
+    /// @dev We keep this function to upgrade to 4844 more smoothly.
+    function finalizeBatch(
+        bytes calldata _batchHeader,
+        bytes32 _prevStateRoot,
+        bytes32 _postStateRoot,
+        bytes32 _withdrawRoot
+    ) external override OnlyProver whenNotPaused {
+        if (_prevStateRoot == bytes32(0)) revert ErrorPreviousStateRootIsZero();
+        if (_postStateRoot == bytes32(0)) revert ErrorStateRootIsZero();
+
+        // compute batch hash and verify
+        (uint256 memPtr, bytes32 _batchHash, uint256 _batchIndex, ) = _loadBatchHeader(_batchHeader);
+        // bytes32 _dataHash = BatchHeaderV0Codec.getDataHash(memPtr);
+
+        // verify previous state root.
+        if (finalizedStateRoots[_batchIndex - 1] != _prevStateRoot) revert ErrorIncorrectPreviousStateRoot();
+
+        // avoid duplicated verification
+        if (finalizedStateRoots[_batchIndex] != bytes32(0)) revert ErrorBatchIsAlreadyVerified();
+
+        // // compute public input hash
+        // bytes32 _publicInputHash = keccak256(
+        //     abi.encodePacked(layer2ChainId, _prevStateRoot, _postStateRoot, _withdrawRoot, _dataHash)
+        // );
+
+        // // verify batch
+        // IRollupVerifier(verifier).verifyAggregateProof(0, _batchIndex, _aggrProof, _publicInputHash);
+
+        // check and update lastFinalizedBatchIndex
+        unchecked {
+            if (lastFinalizedBatchIndex + 1 != _batchIndex) revert ErrorIncorrectBatchIndex();
+            lastFinalizedBatchIndex = _batchIndex;
+        }
+
+        // record state root and withdraw root
+        finalizedStateRoots[_batchIndex] = _postStateRoot;
+        withdrawRoots[_batchIndex] = _withdrawRoot;
+
+        // Pop finalized and non-skipped message from L1MessageQueue.
+        _popL1Messages(
+            BatchHeaderV0Codec.getSkippedBitmapPtr(memPtr),
+            BatchHeaderV0Codec.getTotalL1MessagePopped(memPtr),
+            BatchHeaderV0Codec.getL1MessagePopped(memPtr)
+        );
+
+        emit FinalizeBatch(_batchIndex, _batchHash, _postStateRoot, _withdrawRoot);
+    }
+
     /// @inheritdoc IScrollChain
     /// @dev We keep this function to upgrade to 4844 more smoothly.
     function finalizeBatchWithProof(
@@ -428,6 +478,87 @@ contract ScrollChain is OwnableUpgradeable, PausableUpgradeable, IScrollChain {
         emit FinalizeBatch(_batchIndex, _batchHash, _postStateRoot, _withdrawRoot);
     }
 
+    /// @inheritdoc IScrollChain
+    /// @dev Memory layout of `_blobDataProof`:
+    /// ```text
+    /// | z       | y       | kzg_commitment | kzg_proof |
+    /// |---------|---------|----------------|-----------|
+    /// | bytes32 | bytes32 | bytes48        | bytes48   |
+    /// ```
+    function finalizeBatch4844(
+        bytes calldata _batchHeader,
+        bytes32 _prevStateRoot,
+        bytes32 _postStateRoot,
+        bytes32 _withdrawRoot,
+        bytes calldata _blobDataProof
+    ) external override OnlyProver whenNotPaused {
+        if (_prevStateRoot == bytes32(0)) revert ErrorPreviousStateRootIsZero();
+        if (_postStateRoot == bytes32(0)) revert ErrorStateRootIsZero();
+
+        // compute batch hash and verify
+        (uint256 memPtr, bytes32 _batchHash, uint256 _batchIndex, ) = _loadBatchHeader(_batchHeader);
+        // bytes32 _dataHash = BatchHeaderV1Codec.getDataHash(memPtr);
+        bytes32 _blobVersionedHash = BatchHeaderV1Codec.getBlobVersionedHash(memPtr);
+
+        // Calls the point evaluation precompile and verifies the output
+        {
+            (bool success, bytes memory data) = POINT_EVALUATION_PRECOMPILE_ADDR.staticcall(
+                abi.encodePacked(_blobVersionedHash, _blobDataProof)
+            );
+            // We verify that the point evaluation precompile call was successful by testing the latter 32 bytes of the
+            // response is equal to BLS_MODULUS as defined in https://eips.ethereum.org/EIPS/eip-4844#point-evaluation-precompile
+            if (!success) revert ErrorCallPointEvaluationPrecompileFailed();
+            (, uint256 result) = abi.decode(data, (uint256, uint256));
+            if (result != BLS_MODULUS) revert ErrorUnexpectedPointEvaluationPrecompileOutput();
+        }
+
+        // verify previous state root.
+        if (finalizedStateRoots[_batchIndex - 1] != _prevStateRoot) revert ErrorIncorrectPreviousStateRoot();
+
+        // avoid duplicated verification
+        if (finalizedStateRoots[_batchIndex] != bytes32(0)) revert ErrorBatchIsAlreadyVerified();
+
+        // // compute public input hash
+        // bytes32 _publicInputHash = keccak256(
+        //     abi.encodePacked(
+        //         layer2ChainId,
+        //         _prevStateRoot,
+        //         _postStateRoot,
+        //         _withdrawRoot,
+        //         _dataHash,
+        //         _blobDataProof[0:64],
+        //         _blobVersionedHash
+        //     )
+        // );
+
+        // // load version from batch header, it is always the first byte.
+        // uint256 batchVersion;
+        // assembly {
+        //     batchVersion := shr(248, calldataload(_batchHeader.offset))
+        // }
+        // // verify batch
+        // IRollupVerifier(verifier).verifyAggregateProof(batchVersion, _batchIndex, _aggrProof, _publicInputHash);
+
+        // check and update lastFinalizedBatchIndex
+        unchecked {
+            if (lastFinalizedBatchIndex + 1 != _batchIndex) revert ErrorIncorrectBatchIndex();
+            lastFinalizedBatchIndex = _batchIndex;
+        }
+
+        // record state root and withdraw root
+        finalizedStateRoots[_batchIndex] = _postStateRoot;
+        withdrawRoots[_batchIndex] = _withdrawRoot;
+
+        // Pop finalized and non-skipped message from L1MessageQueue.
+        _popL1Messages(
+            BatchHeaderV1Codec.getSkippedBitmapPtr(memPtr),
+            BatchHeaderV1Codec.getTotalL1MessagePopped(memPtr),
+            BatchHeaderV1Codec.getL1MessagePopped(memPtr)
+        );
+
+        emit FinalizeBatch(_batchIndex, _batchHash, _postStateRoot, _withdrawRoot);
+    }
+
     /// @inheritdoc IScrollChain
     /// @dev Memory layout of `_blobDataProof`:
     /// ```text