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/SequencerRegistry.sol

@@ -0,0 +1,44 @@
+// 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 {
+    /// @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 corresponing 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];
+        }
+    }
+
+    /// @inheritdoc ISequencerRegistry
+    function isEligibleSigner(address _proposer) external view returns (bool) {
+        return sequencers[_proposer];
+    }
+}

packages/protocol/contracts/L1/TaikoData.sol

@@ -64,6 +64,7 @@ library TaikoData {
         bytes32 parentMetaHash;
         HookCall[] hookCalls; // DEPRECATED, value ignored.
         bytes signature;
+        uint32 l1StateBlockNumber;
     }
 
     /// @dev Struct containing data only required for proving a block
@@ -124,6 +125,7 @@ library TaikoData {
         // this block is not verified as the last block in a batch, verifiedTransitionId
         // will remain zero.
         uint32 verifiedTransitionId;
+        uint64 l1StateBlockNumber;
     }
 
     /// @dev Struct representing an Ethereum deposit.
@@ -167,7 +169,7 @@ library TaikoData {
         mapping(
             uint64 blockId_mod_blockRingBufferSize
                 => mapping(uint32 transitionId => TransitionState ts)
-        ) transitions;
+            ) transitions;
         // Ring buffer for Ether deposits
         bytes32 __reserve1;
         SlotA slotA; // slot 5

packages/protocol/contracts/L1/TaikoErrors.sol

@@ -35,4 +35,5 @@ abstract contract TaikoErrors {
     error L1_TRANSITION_NOT_FOUND();
     error L1_UNEXPECTED_PARENT();
     error L1_UNEXPECTED_TRANSITION_ID();
+    error L1_INVALID_PROPOSER();
 }

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
@@ -78,6 +79,16 @@ 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();
+            }
+        }
+
         TaikoData.Config memory config = getConfig();
         TaikoToken tko = TaikoToken(resolve(LibStrings.B_TAIKO_TOKEN, false));
 

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

@@ -39,6 +39,7 @@ library LibProposing {
     error L1_LIVENESS_BOND_NOT_RECEIVED();
     error L1_TOO_MANY_BLOCKS();
     error L1_UNEXPECTED_PARENT();
+    error L1_INVALID_L1_STATE_BLOCK();
 
     /// @dev Proposes a Taiko L2 block.
     /// @param _state Current TaikoData.State.
@@ -74,35 +75,47 @@ library LibProposing {
             revert L1_TOO_MANY_BLOCKS();
         }
 
-        bytes32 parentMetaHash =
-            _state.blocks[(b.numBlocks - 1) % _config.blockRingBufferSize].metaHash;
-        // assert(parentMetaHash != 0);
+        TaikoData.Block storage parentBlock =
+            _state.blocks[(b.numBlocks - 1) % _config.blockRingBufferSize];
 
         // 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.
-        if (params.parentMetaHash != 0 && parentMetaHash != params.parentMetaHash) {
+        if (params.parentMetaHash != 0 && parentBlock.metaHash != params.parentMetaHash) {
             revert L1_UNEXPECTED_PARENT();
         }
 
+        // Verify the passed in L1 state block number.
+        // We only allow the L1 block to be 2 epochs old.
+        // The other constraint is that the L1 block number needs to be larger than or equal the one
+        // in the previous block.
+        if (
+            params.l1StateBlockNumber < block.number - 64
+                || params.l1StateBlockNumber >= block.number
+                || params.l1StateBlockNumber < parentBlock.l1StateBlockNumber
+        ) {
+            revert L1_INVALID_L1_STATE_BLOCK();
+        }
+
         // 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(params.l1StateBlockNumber),
                 difficulty: 0, // to be initialized below
                 blobHash: 0, // to be initialized below
                 extraData: params.extraData,
                 depositsHash: _EMPTY_ETH_DEPOSIT_HASH,
                 coinbase: params.coinbase,
                 id: b.numBlocks,
                 gasLimit: _config.blockMaxGasLimit,
-                timestamp: uint64(block.timestamp),
-                l1Height: uint64(block.number - 1),
+                // Use the timestamp of the L1 state block
+                timestamp: uint64(block.timestamp - 12 * (block.number - params.l1StateBlockNumber)),
+                l1Height: uint64(params.l1StateBlockNumber),
                 minTier: 0, // to be initialized below
                 blobUsed: _txList.length == 0,
-                parentMetaHash: parentMetaHash,
+                parentMetaHash: parentBlock.metaHash,
                 sender: msg.sender
             });
         }
@@ -137,7 +150,9 @@ library LibProposing {
         // 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, b.numBlocks, block.number));
+        meta_.difficulty = keccak256(
+            abi.encodePacked(blockhash(params.l1StateBlockNumber), b.numBlocks, block.number)
+        );
 
         {
             ITierRouter tierRouter = ITierRouter(_resolver.resolve(LibStrings.B_TIER_ROUTER, false));
@@ -161,7 +176,8 @@ 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: params.l1StateBlockNumber
         });
 
         // Store the block in the ring buffer

packages/protocol/contracts/common/LibStrings.sol

@@ -30,4 +30,5 @@ library LibStrings {
     bytes32 internal constant H_RETURN_LIVENESS_BOND = keccak256("RETURN_LIVENESS_BOND");
     bytes32 internal constant H_SIGNAL_ROOT = keccak256("SIGNAL_ROOT");
     bytes32 internal constant H_STATE_ROOT = keccak256("STATE_ROOT");
+    bytes32 internal constant B_SEQUENCER_REGISTRY = bytes32("sequencer_registry");
 }

packages/protocol/test/L1/TaikoL1.t.sol

@@ -242,7 +242,7 @@ contract TaikoL1Test is TaikoL1TestBase {
         vm.prank(proposer, proposer);
         vm.expectRevert(revertReason);
         L1.proposeBlock{ value: msgValue }(
-            abi.encode(TaikoData.BlockParams(address(0), address(0), 0, 0, hookcalls, "")),
+            abi.encode(TaikoData.BlockParams(address(0), address(0), 0, 0, hookcalls, "", 0)),
             new bytes(txListSize)
         );
     }

packages/protocol/test/L1/TaikoL1TestBase.sol

@@ -150,7 +150,7 @@ abstract contract TaikoL1TestBase is TaikoTest {
         TaikoData.HookCall[] memory hookcalls = new TaikoData.HookCall[](0);
         vm.prank(proposer, proposer);
         (meta, ethDeposits) = L1.proposeBlock{ value: msgValue }(
-            abi.encode(TaikoData.BlockParams(address(0), address(0), 0, 0, hookcalls, "")),
+            abi.encode(TaikoData.BlockParams(address(0), address(0), 0, 0, hookcalls, "", 0)),
             new bytes(txListSize)
         );
     }

packages/protocol/test/L1/TaikoL1TestGroupBase.sol

@@ -56,7 +56,7 @@ abstract contract TaikoL1TestGroupBase is TaikoL1TestBase {
         vm.prank(proposer);
         if (revertReason != "") vm.expectRevert(revertReason);
         (meta,) = L1.proposeBlock{ value: 3 ether }(
-            abi.encode(TaikoData.BlockParams(address(0), address(0), 0, 0, hookcalls, eoaSig)),
+            abi.encode(TaikoData.BlockParams(address(0), address(0), 0, 0, hookcalls, eoaSig, 0)),
             txList
         );
     }