breaks

Author: dantaik

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

@@ -57,9 +57,8 @@ library LibProposing {
         public
         returns (TaikoData.BlockMetadataV2[] memory metas_)
     {
-        require(
-            _paramsArr.length != 0 && _paramsArr.length == _txListArr.length, L1_INVALID_PARAMS()
-        );
+        require(_paramsArr.length != 0, L1_INVALID_PARAMS());
+        require(_paramsArr.length == _txListArr.length, L1_INVALID_PARAMS());
 
         metas_ = new TaikoData.BlockMetadataV2[](_paramsArr.length);
 
@@ -149,22 +148,22 @@ library LibProposing {
         // The other constraint is that the L1 block number needs to be larger than or equal
         // the one in the previous L2 block.
         require(
-            local.params.anchorBlockId + _config.maxAnchorHeightOffset >= block.number //
-                && local.params.anchorBlockId < block.number
-                && local.params.anchorBlockId >= parentBlk.proposedIn,
+            local.params.anchorBlockId + _config.maxAnchorHeightOffset >= block.number,
             L1_INVALID_ANCHOR_BLOCK()
         );
+        require(local.params.anchorBlockId < block.number, L1_INVALID_ANCHOR_BLOCK());
+        require(local.params.anchorBlockId >= parentBlk.proposedIn, L1_INVALID_ANCHOR_BLOCK());
 
         // Verify the passed in timestamp.
         // We only allow the timestamp to be 2 epochs old.
         // The other constraint is that the timestamp needs to be larger than or equal the
         // one in the previous L2 block.
         require(
-            local.params.timestamp + _config.maxAnchorHeightOffset * 12 >= block.timestamp
-                && local.params.timestamp <= block.timestamp
-                && local.params.timestamp >= parentBlk.proposedAt,
+            local.params.timestamp + _config.maxAnchorHeightOffset * 12 >= block.timestamp,
             L1_INVALID_TIMESTAMP()
         );
+        require(local.params.timestamp <= block.timestamp, L1_INVALID_TIMESTAMP());
+        require(local.params.timestamp >= parentBlk.proposedAt, L1_INVALID_TIMESTAMP());
 
         // 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.

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

@@ -115,7 +115,8 @@ library LibProving {
     )
         public
     {
-        require(_blockIds.length != 0 && _blockIds.length == _inputs.length, L1_INVALID_PARAMS());
+        require(_blockIds.length != 0, L1_INVALID_PARAMS());
+        require(_blockIds.length == _inputs.length, L1_INVALID_PARAMS());
 
         TaikoData.TierProof memory batchProof;
         if (_batchProof.length != 0) {
@@ -206,16 +207,13 @@ library LibProving {
         // Make sure parentHash is not zero
         // To contest an existing transition, simply use any non-zero value as
         // the blockHash and stateRoot.
-        require(
-            ctx_.tran.parentHash != 0 && ctx_.tran.blockHash != 0 && ctx_.tran.stateRoot != 0,
-            L1_INVALID_TRANSITION()
-        );
+        require(ctx_.tran.parentHash != 0, L1_INVALID_TRANSITION());
+        require(ctx_.tran.blockHash != 0, L1_INVALID_TRANSITION());
+        require(ctx_.tran.stateRoot != 0, L1_INVALID_TRANSITION());
 
         // Check that the block has been proposed but has not yet been verified.
-        require(
-            local.meta.id > local.b.lastVerifiedBlockId && local.meta.id < local.b.numBlocks,
-            LibUtils.L1_INVALID_BLOCK_ID()
-        );
+        require(local.meta.id > local.b.lastVerifiedBlockId, LibUtils.L1_INVALID_BLOCK_ID());
+        require(local.meta.id < local.b.numBlocks, LibUtils.L1_INVALID_BLOCK_ID());
 
         local.slot = local.meta.id % _config.blockRingBufferSize;
         TaikoData.BlockV2 storage blk = _state.blocks[local.slot];
@@ -254,11 +252,9 @@ library LibProving {
 
         // The new proof must meet or exceed the minimum tier required by the
         // block or the previous proof; it cannot be on a lower tier.
-        require(
-            local.proof.tier != 0 && local.proof.tier >= local.meta.minTier
-                && local.proof.tier >= ts.tier,
-            L1_INVALID_TIER()
-        );
+        require(local.proof.tier != 0, L1_INVALID_TIER());
+        require(local.proof.tier >= local.meta.minTier, L1_INVALID_TIER());
+        require(local.proof.tier >= ts.tier, L1_INVALID_TIER());
 
         // Retrieve the tier configurations. If the tier is not supported, the
         // subsequent action will result in a revert.

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

@@ -128,7 +128,8 @@ library LibUtils {
     {
         (TaikoData.BlockV2 storage blk, uint64 slot) = getBlock(_state, _config, _blockId);
 
-        require(_tid != 0 && _tid < blk.nextTransitionId, L1_TRANSITION_NOT_FOUND());
+        require(_tid != 0, L1_TRANSITION_NOT_FOUND());
+        require(_tid < blk.nextTransitionId, L1_TRANSITION_NOT_FOUND());
         return _state.transitions[slot][_tid];
     }
 

packages/protocol/contracts/L1/provers/GuardianProver.sol

@@ -110,16 +110,13 @@ contract GuardianProver is IVerifier, EssentialContract {
         onlyOwner
     {
         // We need at most 255 guardians (so the approval bits fit in a uint256)
-        require(
-            _newGuardians.length != 0 && _newGuardians.length <= type(uint8).max,
-            GP_INVALID_GUARDIAN_SET()
-        );
+        require(_newGuardians.length != 0, GP_INVALID_GUARDIAN_SET());
+        require(_newGuardians.length <= type(uint8).max, GP_INVALID_GUARDIAN_SET());
 
         // Minimum number of guardians to approve is at least equal or greater than half the
         // guardians (rounded up) and less or equal than the total number of guardians
-        require(
-            _minGuardians != 0 && _minGuardians <= _newGuardians.length, GP_INVALID_MIN_GUARDIANS()
-        );
+        require(_minGuardians != 0, GP_INVALID_MIN_GUARDIANS());
+        require(_minGuardians <= _newGuardians.length, GP_INVALID_MIN_GUARDIANS());
 
         // Delete the current guardians
         for (uint256 i; i < guardians.length; ++i) {
@@ -201,7 +198,6 @@ contract GuardianProver is IVerifier, EssentialContract {
     /// @notice Pauses chain proving and verification.
     function pauseTaikoProving() external whenNotPaused {
         require(guardianIds[msg.sender] != 0, GP_INVALID_GUARDIAN());
-
         require(address(this) == resolve(LibStrings.B_CHAIN_WATCHDOG, true), GV_PERMISSION_DENIED());
 
         ITaikoL1(resolve(LibStrings.B_TAIKO, false)).pauseProving(true);

packages/protocol/contracts/L2/DelegateOwner.sol

@@ -56,7 +56,7 @@ contract DelegateOwner is EssentialContract, IMessageInvocable {
     error DO_PERMISSION_DENIED();
 
     modifier onlyAdminOrRemoteOwner() {
-        if (!_isAdminOrRemoteOwner(msg.sender)) revert DO_PERMISSION_DENIED();
+        require(_isAdminOrRemoteOwner(msg.sender), DO_PERMISSION_DENIED());
         _;
     }
 
@@ -78,9 +78,9 @@ contract DelegateOwner is EssentialContract, IMessageInvocable {
         // This contract's owner will be itself.
         __Essential_init(address(this), _sharedAddressManager);
 
-        if (_remoteOwner == address(0) || _remoteChainId == 0 || _remoteChainId == block.chainid) {
-            revert DO_INVALID_PARAM();
-        }
+        require(_remoteOwner != address(0), DO_INVALID_PARAM());
+        require(_remoteChainId != 0, DO_INVALID_PARAM());
+        require(_remoteChainId != block.chainid, DO_INVALID_PARAM());
 
         remoteChainId = _remoteChainId;
         remoteOwner = _remoteOwner;
@@ -104,7 +104,7 @@ contract DelegateOwner is EssentialContract, IMessageInvocable {
     /// @dev Updates the admin address.
     /// @param _admin The new admin address.
     function setAdmin(address _admin) external nonReentrant onlyOwner {
-        if (_admin == admin || _admin == address(this)) revert DO_INVALID_PARAM();
+        require(_admin != admin && _admin != address(this), DO_INVALID_PARAM());
 
         emit AdminUpdated(admin, _admin);
         admin = _admin;
@@ -125,14 +125,14 @@ contract DelegateOwner is EssentialContract, IMessageInvocable {
 
         if (call.txId == 0) {
             call.txId = nextTxId;
-        } else if (_verifyTxId && call.txId != nextTxId) {
-            revert DO_INVALID_TX_ID();
+        } else {
+            require(!_verifyTxId || call.txId == nextTxId, DO_INVALID_TX_ID());
         }
 
         nextTxId += 1;
 
         // By design, the target must be a contract address if the txdata is not empty
-        if (call.txdata.length != 0 && !Address.isContract(call.target)) revert DO_INVALID_TARGET();
+        require(call.txdata.length == 0 || Address.isContract(call.target), DO_INVALID_TARGET());
 
         (bool success, bytes memory result) = call.isDelegateCall //
             ? call.target.delegatecall(call.txdata)

packages/protocol/contracts/L2/TaikoL2.sol

@@ -84,8 +84,10 @@ contract TaikoL2 is EssentialContract {
     {
         __Essential_init(_owner, _rollupAddressManager);
 
-        require(_l1ChainId != 0 && _l1ChainId != block.chainid, L2_INVALID_L1_CHAIN_ID());
-        require(block.chainid > 1 && block.chainid <= type(uint64).max, L2_INVALID_L2_CHAIN_ID());
+        require(_l1ChainId != 0, L2_INVALID_L1_CHAIN_ID());
+        require(_l1ChainId != block.chainid, L2_INVALID_L1_CHAIN_ID());
+        require(block.chainid > 1, L2_INVALID_L2_CHAIN_ID());
+        require(block.chainid <= type(uint64).max, L2_INVALID_L2_CHAIN_ID());
 
         if (block.number == 0) {
             // This is the case in real L2 genesis