refactor(protocol): remove unused code post Ontake fork

_typos.toml

@@ -5,6 +5,8 @@ extend-ignore-identifiers-re = [
   "bafybeiegdqpwx3he5dvoxqklspdjekjepjcobfaakyficksratn73qbbyy",
   "TGE",
   "tge",
+  "preconf",
+  "preconfer",
   "baed",
   "Groth",
   "groth",

packages/protocol/.gitignore

@@ -34,6 +34,9 @@ broadcast
 lcov.info
 
 simulation/out/
+test/genesis/data/genesis.json
+test/genesis/data/genesis_alloc.json
+test/genesis/data/genesis_storage_layout.json
 
 # Serverless directories
 .serverless

packages/protocol/.solhint.json

@@ -14,6 +14,7 @@
     "no-inline-assembly": "off",
     "not-rely-on-time": "off",
     "gas-custom-errors": "off",
+    "immutable-vars-naming": "off",
     "one-contract-per-file": "off"
   }
 }

packages/protocol/.solhintignore

@@ -1,4 +1,6 @@
 node_modules/
 lib/
 contracts/layer1/automata-attestation/
+contracts/layer1/preconf/avs-mvp/
+contracts/layer1/preconf/libs/LibBLS12381.sol
 test/shared/thirdparty/

packages/protocol/contracts/layer1/based/ITaikoL1.sol

@@ -6,19 +6,6 @@ import "./TaikoData.sol";
 /// @title ITaikoL1
 /// @custom:security-contact security@taiko.xyz
 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.
-    /// @return meta_ The metadata of the proposed L2 block.
-    /// @return deposits_ The Ether deposits processed.
-    function proposeBlock(
-        bytes calldata _params,
-        bytes calldata _txList
-    )
-        external
-        payable
-        returns (TaikoData.BlockMetadata memory meta_, TaikoData.EthDeposit[] memory deposits_);
-
     /// @notice Proposes a Taiko L2 block (version 2)
     /// @param _params Block parameters, an encoded BlockParamsV2 object.
     /// @param _txList txList data if calldata is used for DA.
@@ -42,9 +29,9 @@ interface ITaikoL1 {
         returns (TaikoData.BlockMetadataV2[] memory metaArr_);
 
     /// @notice Proves or contests a block transition.
-    /// @param _blockId The index of the block to prove. This is also used to
-    /// select the right implementation version.
-    /// @param _input An abi-encoded (TaikoData.BlockMetadata, TaikoData.Transition,
+    /// @param _blockId Index of the block to prove. This is also used to select the right
+    /// implementation version.
+    /// @param _input ABI-encoded (TaikoData.BlockMetadata, TaikoData.Transition,
     /// TaikoData.TierProof) tuple.
     function proveBlock(uint64 _blockId, bytes calldata _input) external;
 
@@ -61,14 +48,27 @@ interface ITaikoL1 {
     )
         external;
 
-    /// @notice Verifies up to a certain number of blocks.
-    /// @param _maxBlocksToVerify Max number of blocks to verify.
+    /// @notice Verifies up to a specified number of blocks.
+    /// @param _maxBlocksToVerify Maximum number of blocks to verify.
     function verifyBlocks(uint64 _maxBlocksToVerify) external;
 
-    /// @notice Pause block proving.
-    /// @param _pause True if paused.
+    /// @notice Pauses or unpauses block proving.
+    /// @param _pause True to pause, false to unpause.
     function pauseProving(bool _pause) external;
 
+    /// @notice Deposits Taiko token to be used as bonds.
+    /// @param _amount The amount of Taiko token to deposit.
+    function depositBond(uint256 _amount) external;
+
+    /// @notice Withdraws Taiko tokens.
+    /// @param _amount Amount of Taiko tokens to withdraw.
+    function withdrawBond(uint256 _amount) external;
+
+    /// @notice Gets the prover that actually proved a verified block.
+    /// @param _blockId Index of the block.
+    /// @return The prover's address. If the block is not verified yet, address(0) will be returned.
+    function getVerifiedBlockProver(uint64 _blockId) external view returns (address);
+
     /// @notice Gets the details of a block.
     /// @param _blockId Index of the block.
     /// @return blk_ The block.
@@ -77,7 +77,8 @@ interface ITaikoL1 {
     /// @notice Gets the state transition for a specific block.
     /// @param _blockId Index of the block.
     /// @param _tid The transition id.
-    /// @return The state transition data of the block.
+    /// @return The state transition data of the block. The transition's state root will be zero if
+    /// the block is not a sync-block.
     function getTransition(
         uint64 _blockId,
         uint32 _tid
@@ -86,19 +87,6 @@ interface ITaikoL1 {
         view
         returns (TaikoData.TransitionState memory);
 
-    /// @notice Deposits Taiko token to be used as bonds.
-    /// @param _amount The amount of Taiko token to deposit.
-    function depositBond(uint256 _amount) external;
-
-    /// @notice Withdraws Taiko token.
-    /// @param _amount The amount of Taiko token to withdraw.
-    function withdrawBond(uint256 _amount) external;
-
-    /// @notice Gets the prover that actually proved a verified block.
-    /// @param _blockId The index of the block.
-    /// @return The prover's address. If the block is not verified yet, address(0) will be returned.
-    function getVerifiedBlockProver(uint64 _blockId) external view returns (address);
-
     /// @notice Gets the configuration of the TaikoL1 contract.
     /// @return Config struct containing configuration parameters.
     function getConfig() external pure returns (TaikoData.Config memory);

packages/protocol/contracts/layer1/based/LibBonds.sol

@@ -11,80 +11,113 @@ import "./TaikoData.sol";
 /// @notice A library that offers helper functions to handle bonds.
 /// @custom:security-contact security@taiko.xyz
 library LibBonds {
-    /// @dev Emitted when token is credited back to a user's bond balance.
-    event BondCredited(address indexed user, uint256 amount);
+    /// @dev Emitted when tokens are deposited into a user's bond balance.
+    /// @param user The address of the user who deposited the tokens.
+    /// @param amount The amount of tokens deposited.
+    event BondDeposited(address indexed user, uint256 amount);
 
-    /// @dev Emitted when token is debited from a user's bond balance.
-    event BondDebited(address indexed user, uint256 amount);
+    /// @dev Emitted when tokens are withdrawn from a user's bond balance.
+    /// @param user The address of the user who withdrew the tokens.
+    /// @param amount The amount of tokens withdrawn.
+    event BondWithdrawn(address indexed user, uint256 amount);
 
-    /// @dev Deposits Taiko token to be used as bonds.
-    /// @param _state Current TaikoData.State.
-    /// @param _resolver Address resolver interface.
-    /// @param _amount The amount of token to deposit.
+    /// @dev Emitted when a token is credited back to a user's bond balance.
+    /// @param user The address of the user whose bond balance is credited.
+    /// @param blockId The ID of the block to credit for.
+    /// @param amount The amount of tokens credited.
+    event BondCredited(address indexed user, uint256 blockId, uint256 amount);
+
+    /// @dev Emitted when a token is debited from a user's bond balance.
+    /// @param user The address of the user whose bond balance is debited.
+    /// @param blockId The ID of the block to debit for.
+    /// @param amount The amount of tokens debited.
+    event BondDebited(address indexed user, uint256 blockId, uint256 amount);
+
+    /// @dev Deposits TAIKO tokens to be used as bonds.
+    /// @param _state The current state of TaikoData.
+    /// @param _resolver The address resolver interface.
+    /// @param _amount The amount of tokens to deposit.
     function depositBond(
         TaikoData.State storage _state,
         IAddressResolver _resolver,
         uint256 _amount
     )
         internal
     {
+        emit BondDeposited(msg.sender, _amount);
         _state.bondBalance[msg.sender] += _amount;
         _tko(_resolver).transferFrom(msg.sender, address(this), _amount);
     }
 
-    /// @dev Withdraws Taiko token.
-    /// @param _state Current TaikoData.State.
-    /// @param _resolver Address resolver interface.
-    /// @param _amount The amount of token to withdraw.
+    /// @dev Withdraws TAIKO tokens.
+    /// @param _state The current state of TaikoData.
+    /// @param _resolver The address resolver interface.
+    /// @param _amount The amount of tokens to withdraw.
     function withdrawBond(
         TaikoData.State storage _state,
         IAddressResolver _resolver,
         uint256 _amount
     )
         internal
     {
+        emit BondWithdrawn(msg.sender, _amount);
         _state.bondBalance[msg.sender] -= _amount;
         _tko(_resolver).transfer(msg.sender, _amount);
     }
 
-    /// @dev Debits Taiko tokens as bonds.
-    /// @param _state Current TaikoData.State.
-    /// @param _resolver Address resolver interface.
-    /// @param _user The user address to debit.
-    /// @param _amount The amount of token to debit.
+    /// @dev Debits TAIKO tokens as bonds.
+    /// @param _state The current state of TaikoData.
+    /// @param _resolver The address resolver interface.
+    /// @param _user The address of the user to debit.
+    /// @param _blockId The ID of the block to debit for.
+    /// @param _amount The amount of tokens to debit.
     function debitBond(
         TaikoData.State storage _state,
         IAddressResolver _resolver,
         address _user,
+        uint256 _blockId,
         uint256 _amount
     )
         internal
     {
-        uint256 balance = _state.bondBalance[_user];
+        if (_amount == 0) return;
 
+        uint256 balance = _state.bondBalance[_user];
         if (balance >= _amount) {
             unchecked {
                 _state.bondBalance[_user] = balance - _amount;
             }
-            emit BondDebited(_user, _amount);
         } else {
+            emit BondDeposited(msg.sender, _amount);
             _tko(_resolver).transferFrom(_user, address(this), _amount);
         }
+        emit BondDebited(_user, _blockId, _amount);
     }
 
-    /// @dev Credits Taiko tokens to user's bond balance.
-    /// @param _state Current TaikoData.State.
-    /// @param _user The user address to credit.
-    /// @param _amount The amount of token to credit.
-    function creditBond(TaikoData.State storage _state, address _user, uint256 _amount) internal {
-        _state.bondBalance[_user] += _amount;
-        emit BondCredited(_user, _amount);
+    /// @dev Credits TAIKO tokens to a user's bond balance.
+    /// @param _state The current state of TaikoData.
+    /// @param _user The address of the user to credit.
+    /// @param _blockId The ID of the block to credit for.
+    /// @param _amount The amount of tokens to credit.
+    function creditBond(
+        TaikoData.State storage _state,
+        address _user,
+        uint256 _blockId,
+        uint256 _amount
+    )
+        internal
+    {
+        if (_amount == 0) return;
+        unchecked {
+            _state.bondBalance[_user] += _amount;
+        }
+        emit BondCredited(_user, _blockId, _amount);
     }
 
-    /// @dev Gets a user's current Taiko token bond balance.
-    /// @param _state Current TaikoData.State.
-    /// @param _user The user address to credit.
-    /// @return  The current token balance.
+    /// @dev Gets a user's current TAIKO token bond balance.
+    /// @param _state The current state of TaikoData.
+    /// @param _user The address of the user.
+    /// @return The current token balance.
     function bondBalanceOf(
         TaikoData.State storage _state,
         address _user
@@ -96,6 +129,9 @@ library LibBonds {
         return _state.bondBalance[_user];
     }
 
+    /// @dev Resolves the TAIKO token address using the address resolver.
+    /// @param _resolver The address resolver interface.
+    /// @return tko_ The IERC20 interface of the TAIKO token.
     function _tko(IAddressResolver _resolver) private view returns (IERC20) {
         return IERC20(_resolver.resolve(LibStrings.B_TAIKO_TOKEN, false));
     }

packages/protocol/contracts/layer1/based/LibData.sol

@@ -5,100 +5,33 @@ import "../verifiers/IVerifier.sol";
 import "./TaikoData.sol";
 
 /// @title LibData
-/// @notice A library that offers helper functions.
+/// @notice A library that offers helper functions for data conversion.
 /// @custom:security-contact security@taiko.xyz
 library LibData {
-    // = keccak256(abi.encode(new TaikoData.EthDeposit[](0)))
-    bytes32 internal constant EMPTY_ETH_DEPOSIT_HASH =
-        0x569e75fc77c1a856f6daaf9e69d8a9566ca34aa47f9133711ce065a571af0cfd;
-
-    function blockParamsV1ToV2(TaikoData.BlockParams memory _v1)
-        internal
-        pure
-        returns (TaikoData.BlockParamsV2 memory)
-    {
-        return TaikoData.BlockParamsV2({
-            proposer: address(0),
-            coinbase: _v1.coinbase,
-            parentMetaHash: _v1.parentMetaHash,
-            anchorBlockId: 0,
-            timestamp: 0,
-            blobTxListOffset: 0,
-            blobTxListLength: 0,
-            blobIndex: 0
-        });
-    }
-
-    function blockMetadataV2toV1(TaikoData.BlockMetadataV2 memory _v2)
-        internal
-        pure
-        returns (TaikoData.BlockMetadata memory)
-    {
-        return TaikoData.BlockMetadata({
-            l1Hash: _v2.anchorBlockHash,
-            difficulty: _v2.difficulty,
-            blobHash: _v2.blobHash,
-            extraData: _v2.extraData,
-            depositsHash: EMPTY_ETH_DEPOSIT_HASH,
-            coinbase: _v2.coinbase,
-            id: _v2.id,
-            gasLimit: _v2.gasLimit,
-            timestamp: _v2.timestamp,
-            l1Height: _v2.anchorBlockId,
-            minTier: _v2.minTier,
-            blobUsed: _v2.blobUsed,
-            parentMetaHash: _v2.parentMetaHash,
-            sender: _v2.proposer
-        });
-    }
-
-    function blockMetadataV1toV2(TaikoData.BlockMetadata memory _v1)
-        internal
-        pure
-        returns (TaikoData.BlockMetadataV2 memory)
-    {
-        return TaikoData.BlockMetadataV2({
-            anchorBlockHash: _v1.l1Hash,
-            difficulty: _v1.difficulty,
-            blobHash: _v1.blobHash,
-            extraData: _v1.extraData,
-            coinbase: _v1.coinbase,
-            id: _v1.id,
-            gasLimit: _v1.gasLimit,
-            timestamp: _v1.timestamp,
-            anchorBlockId: _v1.l1Height,
-            minTier: _v1.minTier,
-            blobUsed: _v1.blobUsed,
-            parentMetaHash: _v1.parentMetaHash,
-            proposer: _v1.sender,
-            livenessBond: 0,
-            proposedAt: 0,
-            proposedIn: 0,
-            blobTxListOffset: 0,
-            blobTxListLength: 0,
-            blobIndex: 0,
-            baseFeeConfig: LibSharedData.BaseFeeConfig(0, 0, 0, 0, 0)
-        });
-    }
-
-    function blockV2toV1(TaikoData.BlockV2 memory _v2)
+    /// @dev Converts a BlockV2 struct to a Block struct.
+    /// @param _v2 The BlockV2 struct to convert.
+    /// @return The converted Block struct.
+    function blockV2ToV1(TaikoData.BlockV2 memory _v2)
         internal
         pure
         returns (TaikoData.Block memory)
     {
         return TaikoData.Block({
             metaHash: _v2.metaHash,
-            assignedProver: _v2.assignedProver,
-            livenessBond: _v2.livenessBond,
+            assignedProver: address(0), // assigned prover is now meta.proposer.
+            livenessBond: 0, // liveness bond is now meta.livenessBond
             blockId: _v2.blockId,
-            proposedAt: _v2.proposedAt,
-            proposedIn: _v2.proposedIn,
+            proposedAt: 0,
+            proposedIn: 0,
             nextTransitionId: _v2.nextTransitionId,
             verifiedTransitionId: _v2.verifiedTransitionId
         });
     }
 
-    function verifierContextV2toV1(IVerifier.ContextV2 memory _v2)
+    /// @dev Converts a ContextV2 struct to a Context struct.
+    /// @param _v2 The ContextV2 struct to convert.
+    /// @return The converted Context struct.
+    function verifierContextV2ToV1(IVerifier.ContextV2 memory _v2)
         internal
         pure
         returns (IVerifier.Context memory)