feat(protocol): add preconfirmation support [helder]

packages/protocol/contracts/L1/ISequencerRegistry.sol

@@ -0,0 +1,10 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+/// @title ISequencerRegistry
+/// @custom:security-contact [email protected]
+interface ISequencerRegistry {
+    /// @notice Return true if the specified address can propose blocks, false otherwise
+    /// @param _proposer The address proposing a block
+    function isEligibleSigner(address _proposer) external returns (bool);
+}

packages/protocol/contracts/L1/ITaikoL1.sol

@@ -8,12 +8,12 @@ import "./TaikoData.sol";
 interface ITaikoL1 {
     /// @notice Proposes a Taiko L2 block.
     /// @param _params Block parameters, currently an encoded BlockParams object.
-    /// @param _txList txList data if calldata is used for DA.
+    /// @param _txLists txList data if calldata is used for DA.
     /// @return meta_ The metadata of the proposed L2 block.
     /// @return deposits_ The Ether deposits processed.
     function proposeBlock(
-        bytes calldata _params,
-        bytes calldata _txList
+        bytes[] calldata _params,
+        bytes[] calldata _txLists
     )
         external
         payable

packages/protocol/contracts/L1/SequencerRegistry.sol

@@ -0,0 +1,50 @@
+// SPDX-License-Identifier: MIT
+pragma solidity 0.8.24;
+
+import "../common/EssentialContract.sol";
+import "./ISequencerRegistry.sol";
+
+/// @title SequencerRegistry
+/// A dummy implementation that only whitelist some trusted addresses. A real
+/// implementation would only allow a single proposer address to propose a block
+/// using some selection mechanism.
+/// @custom:security-contact [email protected]
+contract SequencerRegistry is EssentialContract, ISequencerRegistry {
+    /// @dev Emitted when the status of a sequencer is updated.
+    /// @param sequencer The address of the sequencer whose state has updated.
+    /// @param enabled If the sequencer is now enabled or not.
+    event SequencerUpdated(address indexed sequencer, bool enabled);
+
+    /// @notice Whitelisted sequencers
+    mapping(address sequencer => bool enabled) public sequencers;
+
+    uint256[49] private __gap;
+
+    /// @notice Initializes the contract with the provided address manager.
+    /// @param _owner The address of the owner.
+    function init(address _owner) external initializer {
+        __Essential_init(_owner);
+    }
+
+    /// @notice Sets/unsets an the imageId as trusted entity
+    /// @param _sequencers The list of sequencers
+    /// @param _enabled The corresponding list of the new status of the sequencers
+    function setSequencers(
+        address[] memory _sequencers,
+        bool[] memory _enabled
+    )
+        external
+        onlyOwner
+    {
+        require(_sequencers.length == _enabled.length, "invalid input data");
+        for (uint256 i = 0; i < _sequencers.length; i++) {
+            sequencers[_sequencers[i]] = _enabled[i];
+            emit SequencerUpdated(_sequencers[i], _enabled[i]);
+        }
+    }
+
+    /// @inheritdoc ISequencerRegistry
+    function isEligibleSigner(address _proposer) external view returns (bool) {
+        return sequencers[_proposer];
+    }
+}

packages/protocol/contracts/L1/TaikoData.sol

@@ -64,6 +64,11 @@ library TaikoData {
         bytes32 parentMetaHash;
         HookCall[] hookCalls; // DEPRECATED, value ignored.
         bytes signature;
+        uint32 l1StateBlockNumber;
+        uint64 timestamp;
+        uint64 blobTxListOffset;
+        uint64 blobTxListLength;
+        uint8 blobIndex;
     }
 
     /// @dev Struct containing data only required for proving a block
@@ -85,6 +90,9 @@ library TaikoData {
         bool blobUsed;
         bytes32 parentMetaHash;
         address sender; // a.k.a proposer
+        uint64 blobTxListOffset;
+        uint64 blobTxListLength;
+        uint8 index; // index of the block in the tx, ie: first block proposed is 0, next is 1, etc
     }
 
     /// @dev Struct representing transition to be proven.
@@ -124,6 +132,11 @@ library TaikoData {
         // this block is not verified as the last block in a batch, verifiedTransitionId
         // will remain zero.
         uint32 verifiedTransitionId;
+        // The block's timestamp
+        uint64 timestamp; // slot 4
+        // This block number is the value for _l1BlockId (and related values) in TaikoL2's anchor()
+        // function.
+        uint32 l1StateBlockNumber;
     }
 
     /// @dev Struct representing an Ethereum deposit.

packages/protocol/contracts/L1/TaikoErrors.sol

@@ -21,6 +21,7 @@ abstract contract TaikoErrors {
     error L1_INVALID_GENESIS_HASH();
     error L1_INVALID_PARAM();
     error L1_INVALID_PAUSE_STATUS();
+    error L1_INVALID_PROPOSER();
     error L1_INVALID_SIG();
     error L1_INVALID_TIER();
     error L1_INVALID_TRANSITION();

packages/protocol/contracts/L1/TaikoL1.sol

@@ -8,6 +8,7 @@ import "./libs/LibVerifying.sol";
 import "./ITaikoL1.sol";
 import "./TaikoErrors.sol";
 import "./TaikoEvents.sol";
+import "./ISequencerRegistry.sol";
 
 /// @title TaikoL1
 /// @notice This contract serves as the "base layer contract" of the Taiko protocol, providing
@@ -68,8 +69,8 @@ contract TaikoL1 is EssentialContract, ITaikoL1, TaikoEvents, TaikoErrors {
 
     /// @inheritdoc ITaikoL1
     function proposeBlock(
-        bytes calldata _params,
-        bytes calldata _txList
+        bytes[] calldata _params,
+        bytes[] calldata _txLists
     )
         external
         payable
@@ -78,13 +79,30 @@ contract TaikoL1 is EssentialContract, ITaikoL1, TaikoEvents, TaikoErrors {
         emitEventForClient
         returns (TaikoData.BlockMetadata memory meta_, TaikoData.EthDeposit[] memory deposits_)
     {
+        // If there's a sequencer registry, check if the block can be proposed by the current
+        // proposer
+        ISequencerRegistry sequencerRegistry =
+            ISequencerRegistry(resolve(LibStrings.B_SEQUENCER_REGISTRY, true));
+        if (sequencerRegistry != ISequencerRegistry(address(0))) {
+            if (!sequencerRegistry.isEligibleSigner(msg.sender)) {
+                revert L1_INVALID_PROPOSER();
+            }
+        }
+
+        require(_params.length == _txLists.length, "mismatched params length");
+
         TaikoData.Config memory config = getConfig();
         TaikoToken tko = TaikoToken(resolve(LibStrings.B_TAIKO_TOKEN, false));
 
-        (meta_, deposits_) = LibProposing.proposeBlock(state, tko, config, this, _params, _txList);
+        for (uint8 i = 0; i < _params.length; i++) {
+            (meta_, deposits_) =
+                LibProposing.proposeBlock(state, tko, config, this, _params[i], _txLists[i], i);
+        }
 
         if (LibUtils.shouldVerifyBlocks(config, meta_.id, true) && !state.slotB.provingPaused) {
-            LibVerifying.verifyBlocks(state, tko, config, this, config.maxBlocksToVerify);
+            LibVerifying.verifyBlocks(
+                state, tko, config, this, config.maxBlocksToVerify * uint64(_params.length)
+            );
         }
     }
 

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

@@ -35,7 +35,10 @@ library LibProposing {
         address indexed assignedProver,
         uint96 livenessBond,
         TaikoData.BlockMetadata meta,
-        TaikoData.EthDeposit[] depositsProcessed
+        TaikoData.EthDeposit[] depositsProcessed,
+        uint64 blobTxListOffset,
+        uint64 blobTxListLength,
+        uint8 blobIndex
     );
 
     /// @notice Emitted when a block's txList is in the calldata.
@@ -46,7 +49,9 @@ library LibProposing {
     // Warning: Any errors defined here must also be defined in TaikoErrors.sol.
     error L1_BLOB_NOT_AVAILABLE();
     error L1_BLOB_NOT_FOUND();
+    error L1_INVALID_L1_STATE_BLOCK();
     error L1_INVALID_SIG();
+    error L1_INVALID_TIMESTAMP();
     error L1_LIVENESS_BOND_NOT_RECEIVED();
     error L1_TOO_MANY_BLOCKS();
     error L1_UNEXPECTED_PARENT();
@@ -55,17 +60,17 @@ library LibProposing {
     /// @param _state Current TaikoData.State.
     /// @param _tko The taiko token.
     /// @param _config Actual TaikoData.Config.
-    /// @param _resolver Address resolver interface.
     /// @param _data Encoded data bytes containing the block params.
     /// @param _txList Transaction list bytes (if not blob).
     /// @return meta_ The constructed block's metadata.
     function proposeBlock(
         TaikoData.State storage _state,
         TaikoToken _tko,
         TaikoData.Config memory _config,
-        IAddressResolver _resolver,
+        IAddressResolver, /*_resolver*/
         bytes calldata _data,
-        bytes calldata _txList
+        bytes calldata _txList,
+        uint8 index
     )
         internal
         returns (TaikoData.BlockMetadata memory meta_, TaikoData.EthDeposit[] memory deposits_)
@@ -77,6 +82,18 @@ library LibProposing {
             local.params.coinbase = msg.sender;
         }
 
+        // If no L1 state block is specified, fall back to the previous L1 block
+        // (the most recent block that has its block hash available in the EVM through the blockhash
+        // opcode).
+        if (local.params.l1StateBlockNumber == 0) {
+            local.params.l1StateBlockNumber = uint32(block.number) - 1;
+        }
+
+        // If no timestamp specified, use the current timestamp
+        if (local.params.timestamp == 0) {
+            local.params.timestamp = uint64(block.timestamp);
+        }
+
         // Taiko, as a Based Rollup, enables permissionless block proposals.
         local.b = _state.slotB;
 
@@ -86,9 +103,9 @@ library LibProposing {
             revert L1_TOO_MANY_BLOCKS();
         }
 
-        local.parentMetaHash =
-            _state.blocks[(local.b.numBlocks - 1) % _config.blockRingBufferSize].metaHash;
-        // assert(parentMetaHash != 0);
+        TaikoData.Block storage parentBlock =
+            _state.blocks[(local.b.numBlocks - 1) % _config.blockRingBufferSize];
+        local.parentMetaHash = parentBlock.metaHash;
 
         // Check if parent block has the right meta hash. This is to allow the proposer to make sure
         // the block builds on the expected latest chain state.
@@ -97,38 +114,62 @@ library LibProposing {
             revert L1_UNEXPECTED_PARENT();
         }
 
+        // Verify the passed in L1 state block number.
+        // We only allow the L1 block to be 4 epochs old.
+        // The other constraint is that the L1 block number needs to be larger than or equal the one
+        // in the previous L2 block.
+        if (
+            local.params.l1StateBlockNumber + 128 < block.number
+                || local.params.l1StateBlockNumber >= block.number
+                || local.params.l1StateBlockNumber < parentBlock.l1StateBlockNumber
+        ) {
+            revert L1_INVALID_L1_STATE_BLOCK();
+        }
+
+        // Verify the passed in timestamp.
+        // We only allow the timestamp to be 4 epochs old.
+        // The other constraint is that the timestamp needs to be larger than or equal the one
+        // in the previous L2 block.
+        if (
+            local.params.timestamp + 128 * 12 < block.timestamp
+                || local.params.timestamp > block.timestamp
+                || local.params.timestamp < parentBlock.timestamp
+        ) {
+            revert L1_INVALID_TIMESTAMP();
+        }
+
         // Initialize metadata to compute a metaHash, which forms a part of
         // the block data to be stored on-chain for future integrity checks.
         // If we choose to persist all data fields in the metadata, it will
         // require additional storage slots.
         unchecked {
             meta_ = TaikoData.BlockMetadata({
-                l1Hash: blockhash(block.number - 1),
+                l1Hash: blockhash(local.params.l1StateBlockNumber),
                 difficulty: 0, // to be initialized below
                 blobHash: 0, // to be initialized below
                 extraData: local.params.extraData,
                 depositsHash: _EMPTY_ETH_DEPOSIT_HASH,
                 coinbase: local.params.coinbase,
                 id: local.b.numBlocks,
                 gasLimit: _config.blockMaxGasLimit,
-                timestamp: uint64(block.timestamp),
-                l1Height: uint64(block.number - 1),
+                // Use the timestamp one block after the chosen L1 state block
+                timestamp: local.params.timestamp,
+                l1Height: local.params.l1StateBlockNumber,
                 minTier: 0, // to be initialized below
                 blobUsed: _txList.length == 0,
                 parentMetaHash: local.parentMetaHash,
-                sender: msg.sender
+                sender: msg.sender,
+                blobTxListOffset: local.params.blobTxListOffset,
+                blobTxListLength: local.params.blobTxListLength,
+                index: index
             });
         }
 
         // Update certain meta fields
         if (meta_.blobUsed) {
-            if (!LibNetwork.isDencunSupported(block.chainid)) revert L1_BLOB_NOT_AVAILABLE();
+            //if (!LibNetwork.isDencunSupported(block.chainid)) revert L1_BLOB_NOT_AVAILABLE();
 
-            // Always use the first blob in this transaction. If the
-            // proposeBlock functions are called more than once in the same
-            // L1 transaction, these multiple L2 blocks will share the same
-            // blob.
-            meta_.blobHash = blobhash(0);
+            meta_.blobHash = blobhash(local.params.blobIndex);
             if (meta_.blobHash == 0) revert L1_BLOB_NOT_FOUND();
         } else {
             meta_.blobHash = keccak256(_txList);
@@ -137,30 +178,30 @@ library LibProposing {
             // the node to extract the calldata easily.
             // We cannot rely on `msg.sender != tx.origin` for EOA check, as it will break after EIP
             // 7645: Alias ORIGIN to SENDER
-            if (
-                _config.checkEOAForCalldataDA
-                    && ECDSA.recover(meta_.blobHash, local.params.signature) != msg.sender
-            ) {
-                revert L1_INVALID_SIG();
-            }
+            // if (
+            //     _config.checkEOAForCalldataDA
+            //         && ECDSA.recover(meta_.blobHash, local.params.signature) != msg.sender
+            // ) {
+            //     revert L1_INVALID_SIG();
+            // }
 
             emit CalldataTxList(meta_.id, _txList);
         }
 
-        // Following the Merge, the L1 mixHash incorporates the
-        // prevrandao value from the beacon chain. Given the possibility
-        // of multiple Taiko blocks being proposed within a single
-        // Ethereum block, we choose to introduce a salt to this random
-        // number as the L2 mixHash.
-        meta_.difficulty =
-            keccak256(abi.encodePacked(block.prevrandao, local.b.numBlocks, block.number));
+        // Generate a random value from the L1 state block hash and the L2 block ID
+        meta_.difficulty = keccak256(
+            abi.encodePacked(blockhash(local.params.l1StateBlockNumber), local.b.numBlocks)
+        );
 
         {
-            ITierRouter tierRouter = ITierRouter(_resolver.resolve(LibStrings.B_TIER_ROUTER, false));
-            ITierProvider tierProvider = ITierProvider(tierRouter.getProvider(local.b.numBlocks));
+            // ITierRouter tierRouter = ITierRouter(_resolver.resolve(LibStrings.B_TIER_ROUTER,
+            // false));
+            // ITierProvider tierProvider =
+            // ITierProvider(tierRouter.getProvider(local.b.numBlocks));
 
             // Use the difficulty as a random number
-            meta_.minTier = tierProvider.getMinTier(uint256(meta_.difficulty));
+            // meta_.minTier = tierProvider.getMinTier(uint256(meta_.difficulty));
+            meta_.minTier = 100;
         }
 
         // Create the block that will be stored onchain
@@ -177,7 +218,9 @@ library LibProposing {
             // For a new block, the next transition ID is always 1, not 0.
             nextTransitionId: 1,
             // For unverified block, its verifiedTransitionId is always 0.
-            verifiedTransitionId: 0
+            verifiedTransitionId: 0,
+            l1StateBlockNumber: local.params.l1StateBlockNumber,
+            timestamp: local.params.timestamp
         });
 
         // Store the block in the ring buffer
@@ -202,7 +245,10 @@ library LibProposing {
             assignedProver: msg.sender,
             livenessBond: _config.livenessBond,
             meta: meta_,
-            depositsProcessed: deposits_
+            depositsProcessed: deposits_,
+            blobTxListOffset: local.params.blobTxListOffset,
+            blobTxListLength: local.params.blobTxListLength,
+            blobIndex: local.params.blobIndex
         });
     }
 }