refactor(protocol): optimize core protocol and bridge implementation

packages/protocol/contracts/L1/ProofVerifier.sol

@@ -71,5 +71,5 @@ contract ProofVerifier is EssentialContract, IProofVerifier {
 }
 
 /// @title ProxiedProofVerifier
-/// @notice Proxied version of the ProofVerifier contract.
+/// @notice Proxied version of the parent contract.
 contract ProxiedProofVerifier is Proxied, ProofVerifier { }

packages/protocol/contracts/L1/ProverPool.sol

@@ -83,12 +83,7 @@ contract ProverPool is EssentialContract, IProverPool {
         EssentialContract._init(_addressManager);
     }
 
-    /// @notice Protocol specifies the current feePerGas and assigns a prover to
-    /// a block.
-    /// @param blockId The block id.
-    /// @param feePerGas The current fee per gas.
-    /// @return prover The address of the assigned prover.
-    /// @return rewardPerGas The reward per gas for the assigned prover.
+    /// @inheritdoc IProverPool
     function assignProver(
         uint64 blockId,
         uint32 feePerGas
@@ -116,8 +111,7 @@ contract ProverPool is EssentialContract, IProverPool {
         }
     }
 
-    /// @notice Increases the capacity of the prover by releasing a prover.
-    /// @param addr The address of the prover to release.
+    /// @inheritdoc IProverPool
     function releaseProver(address addr) external onlyFromProtocol {
         (Staker memory staker, Prover memory prover) = getStaker(addr);
 
@@ -129,10 +123,7 @@ contract ProverPool is EssentialContract, IProverPool {
         }
     }
 
-    /// @notice Slashes a prover.
-    /// @param addr The address of the prover to slash.
-    /// @param blockId The block id of the block which was not proved in time.
-    /// @param proofReward The reward that was set for the block's proof.
+    /// @inheritdoc IProverPool
     function slashProver(
         uint64 blockId,
         address addr,
@@ -473,5 +464,5 @@ contract ProverPool is EssentialContract, IProverPool {
 }
 
 /// @title ProxiedProverPool
-/// @notice Proxied version of the ProverPool contract.
+/// @notice Proxied version of the parent contract.
 contract ProxiedProverPool is Proxied, ProverPool { }

packages/protocol/contracts/L1/TaikoData.sol

@@ -183,6 +183,33 @@ library TaikoData {
         uint64 id;
     }
 
+    /// @dev Forge is only able to run coverage in case the contracts by default
+    /// capable of compiling without any optimization (neither optimizer runs,
+    /// no compiling --via-ir flag).
+    /// In order to resolve stack too deep without optimizations, we needed to
+    /// introduce outsourcing vars into structs below.
+    struct SlotA {
+        uint64 genesisHeight;
+        uint64 genesisTimestamp;
+        uint64 __reserved70;
+        uint64 __reserved71;
+    }
+
+    struct SlotB {
+        uint64 numOpenBlocks;
+        uint64 numEthDeposits;
+        uint64 numBlocks;
+        uint64 nextEthDepositToProcess;
+    }
+
+    struct SlotC {
+        uint64 lastVerifiedAt;
+        uint64 lastVerifiedBlockId;
+        uint64 __reserved90;
+        uint32 feePerGas;
+        uint16 avgProofDelay;
+    }
+
     /// @dev Struct holding the state variables for the {TaikoL1} contract.
     struct State {
         // Ring buffer for proposed blocks and a some recent verified blocks.
@@ -198,22 +225,12 @@ library TaikoData {
         mapping(uint256 depositId_mode_ethDepositRingBufferSize => uint256)
             ethDeposits;
         mapping(address account => uint256 balance) taikoTokenBalances;
-        // Slot 7: never or rarely changed
-        uint64 genesisHeight;
-        uint64 genesisTimestamp;
-        uint64 __reserved70;
-        uint64 __reserved71;
+        // Slot 6: never or rarely changed
+        SlotA slotA;
+        // Slot 7
+        SlotB slotB;
         // Slot 8
-        uint64 numOpenBlocks;
-        uint64 numEthDeposits;
-        uint64 numBlocks;
-        uint64 nextEthDepositToProcess;
-        // Slot 9
-        uint64 lastVerifiedAt;
-        uint64 lastVerifiedBlockId;
-        uint64 __reserved90;
-        uint32 feePerGas;
-        uint16 avgProofDelay;
+        SlotC slotC;
         // Reserved
         uint256[42] __gap;
     }

packages/protocol/contracts/L1/TaikoL1.sol

@@ -44,7 +44,7 @@ contract TaikoL1 is
         depositEtherToL2(address(0));
     }
 
-    /// @notice Initialize the rollup.
+    /// @notice Initializes the rollup.
     /// @param _addressManager The {AddressManager} address.
     /// @param _genesisBlockHash The block hash of the genesis block.
     /// @param _initFeePerGas Initial (reasonable) block fee value.
@@ -68,7 +68,7 @@ contract TaikoL1 is
         });
     }
 
-    /// @notice Propose a Taiko L2 block.
+    /// @notice Proposes a Taiko L2 block.
     /// @param input An abi-encoded BlockMetadataInput that the actual L2 block
     /// header must satisfy.
     /// @param txList A list of transactions in this block, encoded with RLP.
@@ -102,7 +102,7 @@ contract TaikoL1 is
         }
     }
 
-    /// @notice Prove a block with a zero-knowledge proof.
+    /// @notice Proves a block with a zero-knowledge proof.
     /// @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.BlockEvidence} object.
@@ -131,7 +131,7 @@ contract TaikoL1 is
         }
     }
 
-    /// @notice Verify up to N blocks.
+    /// @notice Verifies up to N blocks.
     /// @param maxBlocks Max number of blocks to verify.
     function verifyBlocks(uint256 maxBlocks) external nonReentrant {
         if (maxBlocks == 0) revert L1_INVALID_PARAM();
@@ -143,7 +143,7 @@ contract TaikoL1 is
         });
     }
 
-    /// @notice Deposit Ether to Layer 2.
+    /// @notice Deposits Ether to Layer 2.
     /// @param recipient Address of the recipient for the deposited Ether on
     /// Layer 2.
     function depositEtherToL2(address recipient) public payable {
@@ -155,19 +155,19 @@ contract TaikoL1 is
         });
     }
 
-    /// @notice Deposit Taiko tokens to the contract.
+    /// @notice Deposits Taiko tokens to the contract.
     /// @param amount Amount of Taiko tokens to deposit.
     function depositTaikoToken(uint256 amount) public nonReentrant {
         LibTaikoToken.depositTaikoToken(state, AddressResolver(this), amount);
     }
 
-    /// @notice Withdraw Taiko tokens from the contract.
+    /// @notice Withdraws Taiko tokens from the contract.
     /// @param amount Amount of Taiko tokens to withdraw.
     function withdrawTaikoToken(uint256 amount) public nonReentrant {
         LibTaikoToken.withdrawTaikoToken(state, AddressResolver(this), amount);
     }
 
-    /// @notice Check if Ether deposit is allowed for Layer 2.
+    /// @notice Checks if Ether deposit is allowed for Layer 2.
     /// @param amount Amount of Ether to be deposited.
     /// @return true if Ether deposit is allowed, false otherwise.
     function canDepositEthToL2(uint256 amount) public view returns (bool) {
@@ -178,7 +178,7 @@ contract TaikoL1 is
         });
     }
 
-    /// @notice Get the block fee for a given gas limit.
+    /// @notice Gets the block fee for a given gas limit.
     /// @param gasLimit Gas limit for the block.
     /// @return The block fee in Taiko tokens.
     function getBlockFee(uint32 gasLimit) public view returns (uint64) {
@@ -189,14 +189,14 @@ contract TaikoL1 is
         });
     }
 
-    /// @notice Get the Taiko token balance for a specific address.
+    /// @notice Gets the Taiko token balance for a specific address.
     /// @param addr Address to check the Taiko token balance.
     /// @return The Taiko token balance of the address.
     function getTaikoTokenBalance(address addr) public view returns (uint256) {
         return state.taikoTokenBalances[addr];
     }
 
-    /// @notice Get the details of a block.
+    /// @notice Gets the details of a block.
     /// @param blockId Index of the block.
     /// @return _metaHash Metadata hash of the block.
     /// @return _gasLimit Gas limit of the block.
@@ -245,7 +245,7 @@ contract TaikoL1 is
         _proofWindow = blk.proofWindow;
     }
 
-    /// @notice Get the fork choice for a specific block.
+    /// @notice Gets the fork choice for a specific block.
     /// @param blockId Index of the block.
     /// @param parentHash Parent hash of the block.
     /// @param parentGasUsed Gas used by the parent block.
@@ -268,7 +268,7 @@ contract TaikoL1 is
         });
     }
 
-    /// @notice Get the block hash of the specified Layer 2 block.
+    /// @notice Gets the block hash of the specified Layer 2 block.
     /// @param blockId Index of the block.
     /// @return Block hash of the specified block.
     function getCrossChainBlockHash(uint256 blockId)
@@ -287,7 +287,7 @@ contract TaikoL1 is
             : bytes32(0);
     }
 
-    /// @notice Get the signal root of the specified Layer 2 block.
+    /// @notice Gets the signal root of the specified Layer 2 block.
     /// @param blockId Index of the block.
     /// @return Signal root of the specified block.
     function getCrossChainSignalRoot(uint256 blockId)
@@ -307,7 +307,7 @@ contract TaikoL1 is
             : bytes32(0);
     }
 
-    /// @notice Get the state variables of the TaikoL1 contract.
+    /// @notice Gets the state variables of the TaikoL1 contract.
     /// @return StateVariables struct containing state variables.
     function getStateVariables()
         public
@@ -317,7 +317,7 @@ contract TaikoL1 is
         return state.getStateVariables();
     }
 
-    /// @notice Get the configuration of the TaikoL1 contract.
+    /// @notice Gets the configuration of the TaikoL1 contract.
     /// @return Config struct containing configuration parameters.
     function getConfig()
         public
@@ -328,7 +328,7 @@ contract TaikoL1 is
         return TaikoConfig.getConfig();
     }
 
-    /// @notice Get the name of the proof verifier by ID.
+    /// @notice Gets the name of the proof verifier by ID.
     /// @param id ID of the verifier.
     /// @return Verifier name.
     function getVerifierName(uint16 id) public pure returns (bytes32) {
@@ -337,5 +337,5 @@ contract TaikoL1 is
 }
 
 /// @title TaikoL1
-/// @notice Proxied version of the TaikoL1 contract.
+/// @notice Proxied version of the parent contract.
 contract ProxiedTaikoL1 is Proxied, TaikoL1 { }

packages/protocol/contracts/L1/TaikoToken.sol

@@ -46,10 +46,6 @@ contract TaikoToken is
     error TKO_INVALID_PREMINT_PARAMS();
     error TKO_MINT_DISALLOWED();
 
-    /*//////////////////////////////////////////////////////////////
-                         USER-FACING FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
     /// @notice Initializes the TaikoToken contract and mints initial tokens to
     /// specified recipients.
     /// @param _addressManager The {AddressManager} address.
@@ -163,10 +159,6 @@ contract TaikoToken is
         return LibTaikoTokenConfig.DECIMALS;
     }
 
-    /*//////////////////////////////////////////////////////////////
-                           INTERNAL FUNCTIONS
-    //////////////////////////////////////////////////////////////*/
-
     function _beforeTokenTransfer(
         address from,
         address to,

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

@@ -46,19 +46,20 @@ library LibEthDepositing {
 
         // Append the deposit to the queue.
         address _recipient = recipient == address(0) ? msg.sender : recipient;
-        uint256 slot = state.numEthDeposits % config.ethDepositRingBufferSize;
+        uint256 slot =
+            state.slotB.numEthDeposits % config.ethDepositRingBufferSize;
         state.ethDeposits[slot] = _encodeEthDeposit(_recipient, msg.value);
 
         emit EthDeposited(
             TaikoData.EthDeposit({
                 recipient: _recipient,
                 amount: uint96(msg.value),
-                id: state.numEthDeposits
+                id: state.slotB.numEthDeposits
             })
         );
 
         unchecked {
-            state.numEthDeposits++;
+            state.slotB.numEthDeposits++;
         }
     }
 
@@ -77,7 +78,7 @@ library LibEthDepositing {
     {
         // Calculate the number of pending deposits.
         uint256 numPending =
-            state.numEthDeposits - state.nextEthDepositToProcess;
+            state.slotB.numEthDeposits - state.slotB.nextEthDepositToProcess;
 
         if (numPending < config.ethDepositMinCountPerBlock) {
             deposits = new TaikoData.EthDeposit[](0);
@@ -90,7 +91,7 @@ library LibEthDepositing {
                     block.basefee * config.ethDepositGas
                 )
             );
-            uint64 j = state.nextEthDepositToProcess;
+            uint64 j = state.slotB.nextEthDepositToProcess;
             uint96 totalFee;
             for (uint256 i; i < deposits.length;) {
                 uint256 data =
@@ -109,13 +110,13 @@ library LibEthDepositing {
                     ++j;
                 }
             }
-            state.nextEthDepositToProcess = j;
+            state.slotB.nextEthDepositToProcess = j;
             // This is the fee deposit
-            state.ethDeposits[state.numEthDeposits
+            state.ethDeposits[state.slotB.numEthDeposits
                 % config.ethDepositRingBufferSize] =
                 _encodeEthDeposit(feeRecipient, totalFee);
             unchecked {
-                state.numEthDeposits++;
+                state.slotB.numEthDeposits++;
             }
         }
     }
@@ -137,7 +138,7 @@ library LibEthDepositing {
         unchecked {
             return amount >= config.ethDepositMinAmount
                 && amount <= config.ethDepositMaxAmount
-                && state.numEthDeposits - state.nextEthDepositToProcess
+                && state.slotB.numEthDeposits - state.slotB.nextEthDepositToProcess
                     < config.ethDepositRingBufferSize - 1;
         }
     }