feat(protocol): support backward-compatible batch-proof verification

packages/protocol/contracts/L1/ITaikoL1.sol

@@ -48,11 +48,18 @@ interface ITaikoL1 {
     /// TaikoData.TierProof) tuple.
     function proveBlock(uint64 _blockId, bytes calldata _input) external;
 
-    /// @notice Proves or contests multiple block transitions.
+    /// @notice Proves or contests multiple block transitions (version 2)
     /// @param _blockIds The indices of the blocks to prove.
-    /// @param _inputArr An list of abi-encoded (TaikoData.BlockMetadata, TaikoData.Transition,
+    /// @param _inputs An list of abi-encoded (TaikoData.BlockMetadata, TaikoData.Transition,
     /// TaikoData.TierProof) tuples.
-    function proveBlocks(uint64[] calldata _blockIds, bytes[] calldata _inputArr) external;
+    /// @param _batchProof An abi-encoded TaikoData.TierProof that contains the batch/aggregated
+    /// proof for the given blocks.
+    function proveBlocks(
+        uint64[] calldata _blockIds,
+        bytes[] calldata _inputs,
+        bytes calldata _batchProof
+    )
+        external;
 
     /// @notice Verifies up to a certain number of blocks.
     /// @param _maxBlocksToVerify Max number of blocks to verify.

packages/protocol/contracts/L1/TaikoL1.sol

@@ -78,13 +78,9 @@ contract TaikoL1 is EssentialContract, ITaikoL1, TaikoEvents {
         returns (TaikoData.BlockMetadata memory meta_, TaikoData.EthDeposit[] memory deposits_)
     {
         TaikoData.Config memory config = getConfig();
-
-        (meta_,, deposits_) = LibProposing.proposeBlock(state, config, this, _params, _txList);
+        (meta_,) = LibProposing.proposeBlock(state, config, this, _params, _txList);
         if (meta_.id >= config.ontakeForkHeight) revert L1_FORK_ERROR();
-
-        if (LibUtils.shouldVerifyBlocks(config, meta_.id, true) && !state.slotB.provingPaused) {
-            LibVerifying.verifyBlocks(state, config, this, config.maxBlocksToVerify);
-        }
+        deposits_ = new TaikoData.EthDeposit[](0);
     }
 
     function proposeBlockV2(
@@ -96,9 +92,11 @@ contract TaikoL1 is EssentialContract, ITaikoL1, TaikoEvents {
         whenNotPaused
         nonReentrant
         emitEventForClient
-        returns (TaikoData.BlockMetadataV2 memory)
+        returns (TaikoData.BlockMetadataV2 memory meta_)
     {
-        return _proposeBlock(_params, _txList, getConfig());
+        TaikoData.Config memory config = getConfig();
+        (, meta_) = LibProposing.proposeBlock(state, config, this, _params, _txList);
+        if (meta_.id < config.ontakeForkHeight) revert L1_FORK_ERROR();
     }
 
     /// @inheritdoc ITaikoL1
@@ -113,15 +111,10 @@ contract TaikoL1 is EssentialContract, ITaikoL1, TaikoEvents {
         emitEventForClient
         returns (TaikoData.BlockMetadataV2[] memory metaArr_)
     {
-        if (_paramsArr.length == 0 || _paramsArr.length != _txListArr.length) {
-            revert L1_INVALID_PARAMS();
-        }
-
-        metaArr_ = new TaikoData.BlockMetadataV2[](_paramsArr.length);
         TaikoData.Config memory config = getConfig();
-
-        for (uint256 i; i < _paramsArr.length; ++i) {
-            metaArr_[i] = _proposeBlock(_paramsArr[i], _txListArr[i], config);
+        (, metaArr_) = LibProposing.proposeBlocks(state, config, this, _paramsArr, _txListArr);
+        for (uint256 i; i < metaArr_.length; ++i) {
+            if (metaArr_[i].id < config.ontakeForkHeight) revert L1_FORK_ERROR();
         }
     }
 
@@ -136,30 +129,22 @@ contract TaikoL1 is EssentialContract, ITaikoL1, TaikoEvents {
         nonReentrant
         emitEventForClient
     {
-        TaikoData.Config memory config = getConfig();
-        _proveBlock(_blockId, _input, config);
+        LibProving.proveBlock(state, getConfig(), this, _blockId, _input);
     }
 
     /// @inheritdoc ITaikoL1
     function proveBlocks(
         uint64[] calldata _blockIds,
-        bytes[] calldata _inputArr
+        bytes[] calldata _inputs,
+        bytes calldata _batchProof
     )
         external
         whenNotPaused
         whenProvingNotPaused
         nonReentrant
         emitEventForClient
     {
-        if (_blockIds.length == 0 || _blockIds.length != _inputArr.length) {
-            revert L1_INVALID_PARAMS();
-        }
-
-        TaikoData.Config memory config = getConfig();
-
-        for (uint256 i; i < _blockIds.length; ++i) {
-            _proveBlock(_blockIds[i], _inputArr[i], config);
-        }
+        LibProving.proveBlocks(state, getConfig(), this, _blockIds, _inputs, _batchProof);
     }
 
     /// @inheritdoc ITaikoL1
@@ -315,36 +300,6 @@ contract TaikoL1 is EssentialContract, ITaikoL1, TaikoEvents {
          });
     }
 
-    function _proposeBlock(
-        bytes calldata _params,
-        bytes calldata _txList,
-        TaikoData.Config memory _config
-    )
-        internal
-        returns (TaikoData.BlockMetadataV2 memory meta_)
-    {
-        (, meta_,) = LibProposing.proposeBlock(state, _config, this, _params, _txList);
-        if (meta_.id < _config.ontakeForkHeight) revert L1_FORK_ERROR();
-
-        if (LibUtils.shouldVerifyBlocks(_config, meta_.id, true) && !state.slotB.provingPaused) {
-            LibVerifying.verifyBlocks(state, _config, this, _config.maxBlocksToVerify);
-        }
-    }
-
-    function _proveBlock(
-        uint64 _blockId,
-        bytes calldata _input,
-        TaikoData.Config memory _config
-    )
-        internal
-    {
-        LibProving.proveBlock(state, _config, this, _blockId, _input);
-
-        if (LibUtils.shouldVerifyBlocks(_config, _blockId, false)) {
-            LibVerifying.verifyBlocks(state, _config, this, _config.maxBlocksToVerify);
-        }
-    }
-
     /// @dev chain_pauser is supposed to be a cold wallet.
     function _authorizePause(
         address,

packages/protocol/contracts/L1/libs/LibData.sol

@@ -2,6 +2,7 @@
 pragma solidity 0.8.24;
 
 import "../TaikoData.sol";
+import "../../verifiers/IVerifier.sol";
 
 /// @title LibData
 /// @notice A library that offers helper functions.
@@ -103,4 +104,22 @@ library LibData {
             verifiedTransitionId: _v2.verifiedTransitionId
         });
     }
+
+    function verifierContextV2toV1(
+        IVerifier.ContextV2 memory _v2
+    )
+        internal
+        pure
+        returns (IVerifier.Context memory)
+    {
+        return IVerifier.Context({
+            metaHash: _v2.metaHash,
+            blobHash: _v2.blobHash,
+            prover: _v2.prover,
+            blockId: _v2.blockId,
+            isContesting: _v2.isContesting,
+            blobUsed: _v2.blobUsed,
+            msgSender: _v2.msgSender
+        });
+    }
 }

packages/protocol/contracts/L1/libs/LibProposing.sol

@@ -6,6 +6,7 @@ import "../../libs/LibNetwork.sol";
 import "./LibBonds.sol";
 import "./LibData.sol";
 import "./LibUtils.sol";
+import "./LibVerifying.sol";
 
 /// @title LibProposing
 /// @notice A library for handling block proposals in the Taiko protocol.
@@ -50,34 +51,91 @@ library LibProposing {
     error L1_BLOB_NOT_AVAILABLE();
     error L1_BLOB_NOT_FOUND();
     error L1_INVALID_ANCHOR_BLOCK();
+    error L1_INVALID_PARAMS();
     error L1_INVALID_PROPOSER();
     error L1_INVALID_TIMESTAMP();
     error L1_LIVENESS_BOND_NOT_RECEIVED();
     error L1_TOO_MANY_BLOCKS();
     error L1_UNEXPECTED_PARENT();
 
-    /// @dev Proposes a Taiko L2 block.
-    /// @param _state Current TaikoData.State.
-    /// @param _config Actual TaikoData.Config.
-    /// @param _resolver Address resolver interface.
-    /// @param _data Encoded data bytes containing the block params.
+    /// @notice Proposes multiple Taiko L2 blocks.
+    /// @param _state The current state of the Taiko protocol.
+    /// @param _config The configuration parameters for the Taiko protocol.
+    /// @param _resolver The address resolver interface.
+    /// @param _paramsArr An array of encoded data bytes containing the block parameters.
+    /// @param _txListArr An array of transaction list bytes (if not blob).
+    /// @return metaV1s_ An array of metadata objects for the proposed L2 blocks (version 1).
+    /// @return metas_ An array of metadata objects for the proposed L2 blocks (version 2).
+    function proposeBlocks(
+        TaikoData.State storage _state,
+        TaikoData.Config memory _config,
+        IAddressResolver _resolver,
+        bytes[] calldata _paramsArr,
+        bytes[] calldata _txListArr
+    )
+        public
+        returns (
+            TaikoData.BlockMetadata[] memory metaV1s_,
+            TaikoData.BlockMetadataV2[] memory metas_
+        )
+    {
+        if (_paramsArr.length == 0 || _paramsArr.length != _txListArr.length) {
+            revert L1_INVALID_PARAMS();
+        }
+
+        metaV1s_ = new TaikoData.BlockMetadata[](_paramsArr.length);
+        metas_ = new TaikoData.BlockMetadataV2[](_paramsArr.length);
+
+        for (uint256 i; i < _paramsArr.length; ++i) {
+            (metaV1s_[i], metas_[i]) =
+                _proposeBlock(_state, _config, _resolver, _paramsArr[i], _txListArr[i]);
+        }
+
+        if (!_state.slotB.provingPaused) {
+            for (uint256 i; i < _paramsArr.length; ++i) {
+                if (LibUtils.shouldVerifyBlocks(_config, metas_[i].id, false)) {
+                    LibVerifying.verifyBlocks(_state, _config, _resolver, _config.maxBlocksToVerify);
+                }
+            }
+        }
+    }
+
+    /// @notice Proposes a single Taiko L2 block.
+    /// @param _state The current state of the Taiko protocol.
+    /// @param _config The configuration parameters for the Taiko protocol.
+    /// @param _resolver The address resolver interface.
+    /// @param _params Encoded data bytes containing the block parameters.
     /// @param _txList Transaction list bytes (if not blob).
-    /// @return metaV1_ The constructed block's metadata v1.
-    /// @return meta_ The constructed block's metadata v2.
-    /// @return deposits_ An empty ETH deposit array.
+    /// @return metaV1_ The metadata of the proposed block (version 1).
+    /// @return meta_ The metadata of the proposed block (version 2).
     function proposeBlock(
         TaikoData.State storage _state,
         TaikoData.Config memory _config,
         IAddressResolver _resolver,
-        bytes calldata _data,
+        bytes calldata _params,
         bytes calldata _txList
     )
         public
-        returns (
-            TaikoData.BlockMetadata memory metaV1_,
-            TaikoData.BlockMetadataV2 memory meta_,
-            TaikoData.EthDeposit[] memory deposits_
-        )
+        returns (TaikoData.BlockMetadata memory metaV1_, TaikoData.BlockMetadataV2 memory meta_)
+    {
+        (metaV1_, meta_) = _proposeBlock(_state, _config, _resolver, _params, _txList);
+
+        if (!_state.slotB.provingPaused) {
+            if (LibUtils.shouldVerifyBlocks(_config, meta_.id, false)) {
+                LibVerifying.verifyBlocks(_state, _config, _resolver, _config.maxBlocksToVerify);
+            }
+        }
+    }
+
+    function _proposeBlock(
+        TaikoData.State storage _state,
+        TaikoData.Config memory _config,
+        IAddressResolver _resolver,
+        bytes calldata _params,
+        bytes calldata _txList
+    )
+        private
+        returns (TaikoData.BlockMetadata memory metaV1_, TaikoData.BlockMetadataV2 memory meta_)
     {
         // Checks proposer access.
         Local memory local;
@@ -91,12 +149,12 @@ library LibProposing {
         }
 
         if (local.postFork) {
-            if (_data.length != 0) {
-                local.params = abi.decode(_data, (TaikoData.BlockParamsV2));
+            if (_params.length != 0) {
+                local.params = abi.decode(_params, (TaikoData.BlockParamsV2));
                 // otherwise use a default BlockParamsV2 with 0 values
             }
         } else {
-            TaikoData.BlockParams memory paramsV1 = abi.decode(_data, (TaikoData.BlockParams));
+            TaikoData.BlockParams memory paramsV1 = abi.decode(_params, (TaikoData.BlockParams));
             local.params = LibData.blockParamsV1ToV2(paramsV1);
             local.extraData = paramsV1.extraData;
         }
@@ -244,8 +302,6 @@ library LibProposing {
             address(block.coinbase).sendEtherAndVerify(msg.value);
         }
 
-        deposits_ = new TaikoData.EthDeposit[](0);
-
         if (local.postFork) {
             emit BlockProposedV2(meta_.id, meta_);
         } else {
@@ -254,7 +310,7 @@ library LibProposing {
                 assignedProver: msg.sender,
                 livenessBond: _config.livenessBond,
                 meta: metaV1_,
-                depositsProcessed: deposits_
+                depositsProcessed: new TaikoData.EthDeposit[](0)
             });
         }
     }