chore: fix ci issues (#19)

.github/workflows/integration.yml

@@ -6,7 +6,7 @@ on:
   pull_request:
   merge_group:
   push:
-    branches: [main]
+    branches: [ main ]
 
 env:
   CARGO_TERM_COLOR: always
@@ -19,7 +19,7 @@ concurrency:
 jobs:
   test:
     name: test / ${{ matrix.network }}
-    runs-on: ubuntu-latest
+    runs-on: [ bnb-chain-ap-qa-cicd-runners ]
     env:
       RUST_BACKTRACE: 1
     strategy:
@@ -56,7 +56,7 @@ jobs:
     name: sync / 100k blocks
     # Only run sync tests in merge groups
     if: github.event_name == 'merge_group'
-    runs-on: ubuntu-latest
+    runs-on: [ bnb-chain-ap-qa-cicd-runners ]
     env:
       RUST_LOG: info,sync=error
       RUST_BACKTRACE: 1
@@ -84,7 +84,7 @@ jobs:
     name: integration success
     runs-on: ubuntu-latest
     if: always()
-    needs: [test]
+    needs: [ test ]
     timeout-minutes: 30
     steps:
       - name: Decide whether the needed jobs succeeded or failed

.github/workflows/unit.yml

@@ -6,7 +6,7 @@ on:
   pull_request:
   merge_group:
   push:
-    branches: [main]
+    branches: [ main ]
 
 env:
   CARGO_TERM_COLOR: always
@@ -19,13 +19,13 @@ concurrency:
 jobs:
   test:
     name: test / ${{ matrix.network }} (${{ matrix.partition }}/2)
-    runs-on: ubuntu-latest
+    runs-on: [ bnb-chain-ap-qa-cicd-runners ]
     env:
       RUST_BACKTRACE: 1
     strategy:
       matrix:
-        partition: [1, 2]
-        network: [ethereum, optimism]
+        partition: [ 1, 2 ]
+        network: [ ethereum, optimism ]
     timeout-minutes: 30
     steps:
       - uses: actions/checkout@v4
@@ -53,7 +53,7 @@ jobs:
 
   state:
     name: Ethereum state tests
-    runs-on: ubuntu-latest
+    runs-on: [ bnb-chain-ap-qa-cicd-runners ]
     env:
       RUST_LOG: info,sync=error
       RUST_BACKTRACE: 1
@@ -77,7 +77,7 @@ jobs:
 
   doc:
     name: doc tests (${{ matrix.network }})
-    runs-on: ubuntu-latest
+    runs-on: [ bnb-chain-ap-qa-cicd-runners ]
     env:
       RUST_BACKTRACE: 1
     timeout-minutes: 30
@@ -101,7 +101,7 @@ jobs:
     name: unit success
     runs-on: ubuntu-latest
     if: always()
-    needs: [test, state, doc]
+    needs: [ test, state, doc ]
     timeout-minutes: 30
     steps:
       - name: Decide whether the needed jobs succeeded or failed

Cargo.toml

@@ -103,7 +103,7 @@ rust.missing_debug_implementations = "warn"
 rust.missing_docs = "warn"
 rust.unreachable_pub = "warn"
 rust.unused_must_use = "deny"
-rust.rust_2018_idioms = "deny"
+rust.rust_2018_idioms = { level = "deny", priority = -1 }
 rustdoc.all = "warn"
 
 [workspace.lints.clippy]
@@ -401,6 +401,6 @@ similar-asserts = "1.5.0"
 test-fuzz = "5"
 
 [patch.crates-io]
-revm = { git = "https://github.com/bnb-chain/revm.git", rev = "f5cc71d" }
-revm-primitives = { git = "https://github.com/bnb-chain/revm.git", rev = "f5cc71d" }
+revm = { git = "https://github.com/bnb-chain/revm.git", rev = "4be2578" }
+revm-primitives = { git = "https://github.com/bnb-chain/revm.git", rev = "4be2578" }
 alloy-chains = { git = "https://github.com/alloy-rs/chains.git", rev = "906d6fb" }

Makefile

@@ -414,9 +414,9 @@ fix-lint-other-targets:
 	-- -D warnings
 
 fix-lint:
-	make lint-reth && \
-	make lint-op-reth && \
-	make lint-other-targets && \
+	make fix-lint-reth && \
+	make fix-lint-op-reth && \
+	make fix-lint-other-targets && \
 	make fmt
 
 .PHONY: rustdocs

bin/reth/src/commands/db/stats.rs

@@ -376,7 +376,7 @@ impl Command {
         let max_widths = table.column_max_content_widths();
         let mut separator = Row::new();
         for width in max_widths {
-            separator.add_cell(Cell::new(&"-".repeat(width as usize)));
+            separator.add_cell(Cell::new("-".repeat(width as usize)));
         }
         table.add_row(separator);
 

crates/blockchain-tree/src/blockchain_tree.rs

@@ -297,7 +297,12 @@ where
             // get parent hashes
             let mut parent_block_hashes = self.all_chain_hashes(chain_id);
             let first_pending_block_number =
-                *parent_block_hashes.first_key_value().expect("There is at least one block hash").0;
+                if let Some(key_value) = parent_block_hashes.first_key_value() {
+                    *key_value.0
+                } else {
+                    debug!(target: "blockchain_tree", ?chain_id, "No blockhashes stored");
+                    return None
+                };
             let canonical_chain = canonical_chain
                 .iter()
                 .filter(|&(key, _)| key < first_pending_block_number)

crates/consensus/beacon/src/engine/hooks/prune.rs

@@ -78,10 +78,10 @@ impl<DB: Database + 'static> PruneHook<DB> {
 
     /// This will try to spawn the pruner if it is idle:
     /// 1. Check if pruning is needed through [Pruner::is_pruning_needed].
-    /// 2.
-    ///     1. If pruning is needed, pass tip block number to the [Pruner::run] and spawn it in a
-    /// separate task. Set pruner state to [PrunerState::Running].
-    ///     2. If pruning is not needed, set pruner state back to [PrunerState::Idle].
+    ///
+    /// 2.1. If pruning is needed, pass tip block number to the [Pruner::run] and spawn it in a
+    ///      separate task. Set pruner state to [PrunerState::Running].
+    /// 2.2. If pruning is not needed, set pruner state back to [PrunerState::Idle].
     ///
     /// If pruner is already running, do nothing.
     fn try_spawn_pruner(&mut self, tip_block_number: BlockNumber) -> Option<EngineHookEvent> {

crates/consensus/beacon/src/engine/hooks/static_file.rs

@@ -71,13 +71,13 @@ impl<DB: Database + 'static> StaticFileHook<DB> {
     /// 1. Check if producing static files is needed through
     ///    [StaticFileProducer::get_static_file_targets](reth_static_file::StaticFileProducerInner::get_static_file_targets)
     ///    and then [StaticFileTargets::any](reth_static_file::StaticFileTargets::any).
-    /// 2.
-    ///     1. If producing static files is needed, pass static file request to the
-    ///     [StaticFileProducer::run](reth_static_file::StaticFileProducerInner::run) and spawn
-    ///     it in a separate task. Set static file producer state to
-    ///     [StaticFileProducerState::Running].
-    ///     2. If producing static files is not needed, set static file producer state back to
-    ///     [StaticFileProducerState::Idle].
+    ///
+    /// 2.1. If producing static files is needed, pass static file request to the
+    ///      [StaticFileProducer::run](reth_static_file::StaticFileProducerInner::run) and
+    ///      spawn it in a separate task. Set static file producer state to
+    ///      [StaticFileProducerState::Running].
+    /// 2.2. If producing static files is not needed, set static file producer state back to
+    ///      [StaticFileProducerState::Idle].
     ///
     /// If static_file_producer is already running, do nothing.
     fn try_spawn_static_file_producer(

crates/consensus/beacon/src/engine/mod.rs

@@ -710,13 +710,13 @@ where
     /// If validation fails, the response MUST contain the latest valid hash:
     ///
     ///   - The block hash of the ancestor of the invalid payload satisfying the following two
-    ///    conditions:
+    ///     conditions:
     ///     - It is fully validated and deemed VALID
     ///     - Any other ancestor of the invalid payload with a higher blockNumber is INVALID
     ///   - 0x0000000000000000000000000000000000000000000000000000000000000000 if the above
-    ///    conditions are satisfied by a PoW block.
+    ///     conditions are satisfied by a PoW block.
     ///   - null if client software cannot determine the ancestor of the invalid payload satisfying
-    ///    the above conditions.
+    ///     the above conditions.
     fn latest_valid_hash_for_invalid_payload(
         &mut self,
         parent_hash: B256,
@@ -1110,8 +1110,8 @@ where
     ///    - invalid extra data
     ///    - invalid transactions
     ///    - incorrect hash
-    ///    - the versioned hashes passed with the payload do not exactly match transaction
-    ///    versioned hashes
+    ///    - the versioned hashes passed with the payload do not exactly match transaction versioned
+    ///      hashes
     ///    - the block does not contain blob transactions if it is pre-cancun
     ///
     /// This validates the following engine API rule:

crates/exex/src/manager.rs

@@ -160,7 +160,7 @@ pub struct ExExManagerMetrics {
 /// The manager is responsible for:
 ///
 /// - Receiving relevant events from the rest of the node, and sending these to the execution
-/// extensions
+///   extensions
 /// - Backpressure
 /// - Error handling
 /// - Monitoring

crates/interfaces/src/blockchain_tree/mod.rs

@@ -210,6 +210,7 @@ pub enum BlockStatus {
 /// This is required to:
 /// - differentiate whether trie state updates should be cached.
 /// - inform other
+///
 /// This is required because the state root check can only be performed if the targeted block can be
 /// traced back to the canonical __head__.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]

crates/net/ecies/src/algorithm.rs

@@ -45,8 +45,8 @@ fn ecdh_x(public_key: &PublicKey, secret_key: &SecretKey) -> B256 {
 /// # Panics
 /// * If the `dest` is empty
 /// * If the `dest` len is greater than or equal to the hash output len * the max counter value. In
-/// this case, the hash output len is 32 bytes, and the max counter value is 2^32 - 1. So the dest
-/// cannot have a len greater than 32 * 2^32 - 1.
+///   this case, the hash output len is 32 bytes, and the max counter value is 2^32 - 1. So the dest
+///   cannot have a len greater than 32 * 2^32 - 1.
 fn kdf(secret: B256, s1: &[u8], dest: &mut [u8]) {
     concat_kdf::derive_key_into::<Sha256>(secret.as_slice(), s1, dest).unwrap();
 }

crates/net/eth-wire-types/src/message.rs

@@ -169,7 +169,7 @@ impl From<EthBroadcastMessage> for ProtocolBroadcastMessage {
 /// The ethereum wire protocol is a set of messages that are broadcast to the network in two
 /// styles:
 ///  * A request message sent by a peer (such as [`GetPooledTransactions`]), and an associated
-///  response message (such as [`PooledTransactions`]).
+///    response message (such as [`PooledTransactions`]).
 ///  * A message that is broadcast to the network, without a corresponding request.
 ///
 /// The newer `eth/66` is an efficiency upgrade on top of `eth/65`, introducing a request id to

crates/node-core/src/args/utils.rs

@@ -152,7 +152,7 @@ pub enum SocketAddressParsingError {
 /// The following formats are checked:
 ///
 /// - If the value can be parsed as a `u16` or starts with `:` it is considered a port, and the
-/// hostname is set to `localhost`.
+///   hostname is set to `localhost`.
 /// - If the value contains `:` it is assumed to be the format `<host>:<port>`
 /// - Otherwise it is assumed to be a hostname
 ///

crates/node-core/src/dirs.rs

@@ -257,6 +257,7 @@ impl<D> From<PathBuf> for MaybePlatformPath<D> {
 ///  * mainnet: `<DIR>/mainnet`
 ///  * goerli: `<DIR>/goerli`
 ///  * sepolia: `<DIR>/sepolia`
+///
 /// Otherwise, the path will be dependent on the chain ID:
 ///  * `<DIR>/<CHAIN_ID>`
 #[derive(Clone, Debug, PartialEq, Eq)]

crates/optimism/evm/Cargo.toml

@@ -35,4 +35,4 @@ optimism = [
     "reth-provider/optimism",
     "reth-interfaces/optimism",
     "revm-primitives/optimism",
-]
+]

crates/optimism/evm/src/execute.rs

@@ -357,48 +357,49 @@ where
             block.withdrawals.as_ref().map(Withdrawals::as_ref),
         );
 
-        #[cfg(all(feature = "optimism", feature = "opbnb"))]
-        if self.chain_spec.fork(Hardfork::PreContractForkBlock).transitions_at_block(block.number) {
-            // WBNBContract WBNB preDeploy contract address
-            let w_bnb_contract_address =
-                Address::from_str("0x4200000000000000000000000000000000000006").unwrap();
-            let mut w_bnb_storage = PlainStorage::new();
-            // insert storage for wBNB contract
-            // nameSlot { Name: "Wrapped BNB" }
-            w_bnb_storage.insert(
-                U256::from_str(
-                    "0x0000000000000000000000000000000000000000000000000000000000000000",
-                )
-                    .unwrap(),
-                U256::from_str(
-                    "0x5772617070656420424e42000000000000000000000000000000000000000016",
-                )
-                    .unwrap(),
-            );
-            // symbolSlot { Symbol: "wBNB" }
-            w_bnb_storage.insert(
-                U256::from_str(
-                    "0x0000000000000000000000000000000000000000000000000000000000000001",
-                )
-                    .unwrap(),
-                U256::from_str(
-                    "0x57424e4200000000000000000000000000000000000000000000000000000008",
-                )
-                    .unwrap(),
-            );
-            // insert wBNB contract with storage
-            self.db_mut().insert_account_with_storage(
-                w_bnb_contract_address,
-                AccountInfo::default(),
-                w_bnb_storage,
-            );
-            // GovernanceToken contract address
-            let governance_token_contract_address =
-                Address::from_str("0x4200000000000000000000000000000000000042").unwrap();
-            // destruct the governance token contract
-            self.evm
-                .selfdestruct(governance_token_contract_address, governance_token_contract_address);
-        }
+        // TODO: rebase with the fix
+        // #[cfg(all(feature = "optimism", feature = "opbnb"))]
+        // if self.chain_spec.fork(Hardfork::PreContractForkBlock).transitions_at_block(block.
+        // number) {     // WBNBContract WBNB preDeploy contract address
+        //     let w_bnb_contract_address =
+        //         Address::from_str("0x4200000000000000000000000000000000000006").unwrap();
+        //     let mut w_bnb_storage = PlainStorage::new();
+        //     // insert storage for wBNB contract
+        //     // nameSlot { Name: "Wrapped BNB" }
+        //     w_bnb_storage.insert(
+        //         U256::from_str(
+        //             "0x0000000000000000000000000000000000000000000000000000000000000000",
+        //         )
+        //         .unwrap(),
+        //         U256::from_str(
+        //             "0x5772617070656420424e42000000000000000000000000000000000000000016",
+        //         )
+        //         .unwrap(),
+        //     );
+        //     // symbolSlot { Symbol: "wBNB" }
+        //     w_bnb_storage.insert(
+        //         U256::from_str(
+        //             "0x0000000000000000000000000000000000000000000000000000000000000001",
+        //         )
+        //         .unwrap(),
+        //         U256::from_str(
+        //             "0x57424e4200000000000000000000000000000000000000000000000000000008",
+        //         )
+        //         .unwrap(),
+        //     );
+        //     // insert wBNB contract with storage
+        //     self.db_mut().insert_account_with_storage(
+        //         w_bnb_contract_address,
+        //         AccountInfo::default(),
+        //         w_bnb_storage,
+        //     );
+        //     // GovernanceToken contract address
+        //     let governance_token_contract_address =
+        //         Address::from_str("0x4200000000000000000000000000000000000042").unwrap();
+        //     // destruct the governance token contract
+        //     self.evm
+        //         .selfdestruct(governance_token_contract_address,
+        // governance_token_contract_address); }
 
         // increment balances
         self.state