feat(protocol): Based Contestable Rollup with multi-proofs and multi-hop bridging

packages/protocol/contracts/L1/IProver.sol

@@ -16,11 +16,11 @@ interface IProver {
     /// @param blockId The ID of the proposed block. Note that the ID is only
     /// known when the block is proposed, therefore, it should not be used for
     /// verifying prover authorization.
-    /// @param input The block's BlockMetadataInput data.
+    /// @param txListHash The block's txList hash
     /// @param assignment The assignment to evaluate
     function onBlockAssigned(
         uint64 blockId,
-        TaikoData.BlockMetadataInput calldata input,
+        bytes32 txListHash,
         TaikoData.ProverAssignment calldata assignment
     )
         external

packages/protocol/contracts/L1/TaikoData.sol

@@ -35,25 +35,17 @@ library TaikoData {
         uint32 blockFeeBaseGas;
         // The maximum allowed bytes for the proposed transaction list calldata.
         uint24 blockMaxTxListBytes;
-        // The expiration time for the block transaction list.
-        uint256 blockTxListExpiry;
         // Amount of token to reward to the first block propsoed in each L1
         // block.
         uint256 proposerRewardPerSecond;
         uint256 proposerRewardMax;
         // ---------------------------------------------------------------------
         // Group 3: Proof related configs
         // ---------------------------------------------------------------------
-        // The cooldown period for regular proofs (in minutes).
-        uint256 proofRegularCooldown;
-        // The cooldown period for oracle proofs (in minutes).
-        uint256 proofOracleCooldown;
-        // The maximum time window allowed for a proof submission (in minutes).
-        uint16 proofWindow;
-        // The amount of Taiko token as a bond
-        uint96 proofBond;
+        // The amount of Taiko token as a zk proof bond
+        uint96 assignmentBond;
         // True to skip proof verification
-        bool skipProverAssignmentVerificaiton;
+        bool skipAssignmentVerificaiton;
         // ---------------------------------------------------------------------
         // Group 4: ETH deposit related configs
         // ---------------------------------------------------------------------
@@ -73,23 +65,22 @@ library TaikoData {
         uint256 ethDepositMaxFee;
     }
 
+    struct TierConfig {
+        bytes32 verifierName;
+        uint96 proofBond;
+        uint96 contestBond;
+        uint24 cooldownWindow;
+        uint16 provingWindow;
+    }
+
     /// @dev Struct holding state variables.
     struct StateVariables {
         uint64 genesisHeight;
         uint64 genesisTimestamp;
-        uint64 numBlocks;
-        uint64 lastVerifiedBlockId;
         uint64 nextEthDepositToProcess;
         uint64 numEthDeposits;
-    }
-
-    /// @dev Struct representing input data for block metadata.
-    struct BlockMetadataInput {
-        bytes32 txListHash;
-        address proposer;
-        uint24 txListByteStart; // byte-wise start index (inclusive)
-        uint24 txListByteEnd; // byte-wise end index (exclusive)
-        bool cacheTxListInfo;
+        uint64 numBlocks;
+        uint64 lastVerifiedBlockId;
     }
 
     /// @dev Struct representing prover assignment
@@ -100,19 +91,13 @@ library TaikoData {
     }
 
     /// @dev Struct containing data only required for proving a block
-    /// Warning: changing this struct requires changing {LibUtils.hashMetadata}
-    /// accordingly.
     struct BlockMetadata {
-        uint64 id;
-        uint64 timestamp;
-        uint64 l1Height;
         bytes32 l1Hash;
         bytes32 mixHash;
         bytes32 txListHash;
-        uint24 txListByteStart;
-        uint24 txListByteEnd;
+        uint64 timestamp;
+        uint64 l1Height;
         uint32 gasLimit;
-        address proposer;
         TaikoData.EthDeposit[] depositsProcessed;
     }
 
@@ -123,31 +108,36 @@ library TaikoData {
         bytes32 blockHash;
         bytes32 signalRoot;
         bytes32 graffiti;
-        address prover;
-        bytes proofs;
+        uint16 tier;
+        bytes proof;
     }
 
     /// @dev Struct representing state transition data.
-    /// 10 slots reserved for upgradability, 4 slots used.
+    /// 10 slots reserved for upgradability, 6 slots used.
     struct Transition {
-        bytes32 key; //only written/read for the 1st state transition.
-        bytes32 blockHash;
-        bytes32 signalRoot;
-        address prover;
-        uint64 provenAt;
-        bytes32[6] __reserved;
+        bytes32 key; // slot 1, only written/read for the 1st state transition.
+        bytes32 blockHash; // slot 2
+        bytes32 signalRoot; // slot 3
+        address prover; // slot 4
+        uint96 proofBond;
+        address contester; // slot 5
+        uint96 contestBond;
+        uint64 timestamp; // slot 6 (82 bits)
+        uint16 tier;
+        bytes32[4] __reserved;
     }
 
     /// @dev Struct containing data required for verifying a block.
     /// 10 slots reserved for upgradability, 3 slots used.
     struct Block {
         bytes32 metaHash; // slot 1
-        address prover; // slot 2
-        uint96 proofBond;
+        address assignedProver; // slot 2
+        uint96 assignmentBond;
         uint64 blockId; // slot 3
         uint64 proposedAt;
         uint32 nextTransitionId;
         uint32 verifiedTransitionId;
+        uint16 minTier;
         bytes32[7] __reserved;
     }
 
@@ -198,15 +188,11 @@ library TaikoData {
             uint64 blockId_mod_blockRingBufferSize
                 => mapping(uint32 transitionId => Transition)
             ) transitions;
-        // txList cached info
-        mapping(bytes32 txListHash => TxListInfo) txListInfo;
         // Ring buffer for Ether deposits
         mapping(uint256 depositId_mod_ethDepositRingBufferSize => uint256)
             ethDeposits;
-        // In-protocol Taiko token balances
-        mapping(address account => uint256 balance) taikoTokenBalances;
-        SlotA slotA; // slot 7
-        SlotB slotB; // slot 8
-        uint256[142] __gap;
+        SlotA slotA; // slot 5
+        SlotB slotB; // slot 6
+        uint256[144] __gap;
     }
 }

packages/protocol/contracts/L1/TaikoErrors.sol

@@ -13,29 +13,32 @@ pragma solidity ^0.8.20;
 abstract contract TaikoErrors {
     // NOTE: The following custom errors must match the definitions in
     // `L1/libs/*.sol`.
-    error L1_ALREADY_PROVEN();
-    error L1_BLOCK_ID_MISMATCH();
-    error L1_EVIDENCE_MISMATCH();
-    error L1_INSUFFICIENT_TOKEN();
+    error L1_ALREADY_CONTESTED();
+    error L1_ALREADY_PROVED();
+    error L1_ASSIGNED_PROVER_NOT_ALLOWED();
+    error L1_BLOCK_MISMATCH();
     error L1_INVALID_ASSIGNMENT();
     error L1_INVALID_BLOCK_ID();
     error L1_INVALID_CONFIG();
     error L1_INVALID_ETH_DEPOSIT();
     error L1_INVALID_EVIDENCE();
     error L1_INVALID_METADATA();
-    error L1_INVALID_ORACLE_PROVER();
     error L1_INVALID_PARAM();
     error L1_INVALID_PROOF();
     error L1_INVALID_PROPOSER();
     error L1_INVALID_PROVER();
     error L1_INVALID_PROVER_SIG();
-    error L1_NOT_PROVEABLE();
-    error L1_SAME_PROOF();
+    error L1_INVALID_TIER();
+    error L1_NOT_ASSIGNED_PROVER();
+    error L1_TIER_NOT_FOUND();
     error L1_TOO_MANY_BLOCKS();
+    error L1_TRANSITION_ID_ZERO();
     error L1_TRANSITION_NOT_FOUND();
-    error L1_TX_LIST_NOT_EXIST();
-    error L1_TX_LIST_HASH();
-    error L1_TX_LIST_RANGE();
-    error L1_TX_LIST();
+    error L1_TXLIST_INVALID_RANGE();
+    error L1_TXLIST_MISMATCH();
+    error L1_TXLIST_NOT_FOUND();
+    error L1_TXLIST_TOO_LARGE();
+    error L1_UNAUTHORIZED();
     error L1_UNEXPECTED_TRANSITION_ID();
+    error L1_UNEXPECTED_TRANSITION_TIER();
 }

packages/protocol/contracts/L1/TaikoEvents.sol

@@ -17,50 +17,56 @@ import { TaikoData } from "./TaikoData.sol";
 abstract contract TaikoEvents {
     /// @dev Emitted when a block is proposed.
     /// @param blockId The ID of the proposed block.
-    /// @param prover The address of the assigned prover for the block.
+    /// @param assignedProver The block's assigned prover
     /// @param reward The proposer's block reward in Taiko token.
     /// @param meta The block metadata containing information about the proposed
     /// block.
     event BlockProposed(
         uint256 indexed blockId,
-        address indexed prover,
+        address indexed assignedProver,
+        uint96 assignmentBond,
         uint256 reward,
         TaikoData.BlockMetadata meta
     );
 
-    /// @dev Emitted when a block is proven.
-    /// @param blockId The ID of the proven block.
-    /// @param parentHash The hash of the parent block.
-    /// @param blockHash The hash of the proven block.
-    /// @param signalRoot The signal root of the proven block.
-    /// @param prover The address of the prover who submitted the proof.
-    event BlockProven(
+    /// @dev Emitted when a block is verified.
+    /// @param blockId The ID of the verified block.
+    /// @param assignedProver The block's assigned prover
+    /// @param prover The prover whose transition is used for verifing the
+    /// block.
+    /// @param blockHash The hash of the verified block.
+    event BlockVerified(
+        uint256 indexed blockId,
+        address indexed assignedProver,
+        address indexed prover,
+        bytes32 blockHash,
+        bytes32 signalRoot
+    );
+
+    /// @dev Emitted when a block transition is proved or re-proved.
+    event TransitionProved(
         uint256 indexed blockId,
         bytes32 parentHash,
         bytes32 blockHash,
         bytes32 signalRoot,
-        address prover
+        address prover,
+        uint96 proofBond,
+        uint16 tier
     );
 
-    /// @dev Emitted when a block is verified.
-    /// @param blockId The ID of the verified block.
-    /// @param prover The address of the prover that proved the block which is
-    /// verified.
-    /// @param blockHash The hash of the verified block.
-    event BlockVerified(
-        uint256 indexed blockId, address indexed prover, bytes32 blockHash
+    /// @dev Emitted when a block transition is contested.
+    event TransitionContested(
+        uint256 indexed blockId,
+        bytes32 parentHash,
+        bytes32 blockHash,
+        bytes32 signalRoot,
+        address contester,
+        uint96 contestBond,
+        uint16 tier
     );
 
     /// @dev Emitted when an Ethereum deposit is made.
     /// @param deposit The Ethereum deposit information including recipient,
     /// amount, and ID.
     event EthDeposited(TaikoData.EthDeposit deposit);
-
-    /// @dev The following events are emitted when bonds are received, returned,
-    /// or rewarded. Note that no event is emitted when a bond is kept/burnt as
-    /// for a single block, multiple bonds may get burned or retained by the
-    /// protocol, emitting events will consume more gas.
-    event BondReceived(address indexed from, uint64 blockId, uint256 bond);
-    event BondReturned(address indexed to, uint64 blockId, uint256 bond);
-    event BondRewarded(address indexed to, uint64 blockId, uint256 bond);
 }