diff --git a/Cargo.lock b/Cargo.lock index 6af0e92d7a..20e4e0e174 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1590,6 +1590,24 @@ dependencies = [ "syn 2.0.106", ] +[[package]] +name = "bindgen" +version = "0.71.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5f58bf3d7db68cfbac37cfc485a8d711e87e064c3d0fe0435b92f7a407f9d6b3" +dependencies = [ + "bitflags 2.9.4", + "cexpr", + "clang-sys", + "itertools 0.13.0", + "proc-macro2", + "quote", + "regex", + "rustc-hash 2.1.1", + "shlex", + "syn 2.0.106", +] + [[package]] name = "bit-set" version = "0.8.0" @@ -5353,7 +5371,7 @@ version = "0.14.10" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "e78a09b56be5adbcad5aa1197371688dc6bb249a26da3bca2011ee2fb987ebfb" dependencies = [ - "bindgen", + "bindgen 0.70.1", "errno", "libc", ] @@ -8651,7 +8669,7 @@ dependencies = [ name = "reth-mdbx-sys" version = "1.8.1" dependencies = [ - "bindgen", + "bindgen 0.71.1", "cc", ] diff --git a/Cargo.toml b/Cargo.toml index 0ce9b94a21..bf8bee1a03 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -1,6 +1,6 @@ [workspace.package] version = "1.8.1" -edition = "2021" +edition = "2024" rust-version = "1.88" license = "MIT OR Apache-2.0" homepage = "https://paradigmxyz.github.io/reth" @@ -188,6 +188,7 @@ rust.missing_docs = "warn" rust.rust_2018_idioms = { level = "deny", priority = -1 } rust.unreachable_pub = "warn" rust.unused_must_use = "deny" +rust.rust_2024_incompatible_pat = "warn" rustdoc.all = "warn" # rust.unnameable-types = "warn" @@ -666,7 +667,7 @@ snmalloc-rs = { version = "0.3.7", features = ["build_cc"] } aes = "0.8.1" ahash = "0.8" anyhow = "1.0" -bindgen = { version = "0.70", default-features = false } +bindgen = { version = "0.71", default-features = false } block-padding = "0.3.2" cc = "=1.2.15" cipher = "0.4.3" diff --git a/bin/reth-bench/src/main.rs b/bin/reth-bench/src/main.rs index f146af0f70..7d7305591b 100644 --- a/bin/reth-bench/src/main.rs +++ b/bin/reth-bench/src/main.rs @@ -26,7 +26,9 @@ use reth_cli_runner::CliRunner; fn main() { // Enable backtraces unless a RUST_BACKTRACE value has already been explicitly provided. if std::env::var_os("RUST_BACKTRACE").is_none() { - std::env::set_var("RUST_BACKTRACE", "1"); + unsafe { + std::env::set_var("RUST_BACKTRACE", "1"); + } } // Run until either exit or sigint or sigterm diff --git a/crates/cli/commands/src/download.rs b/crates/cli/commands/src/download.rs index 6661cd074e..8f09dc9b89 100644 --- a/crates/cli/commands/src/download.rs +++ b/crates/cli/commands/src/download.rs @@ -141,10 +141,10 @@ impl ProgressReader { impl Read for ProgressReader { fn read(&mut self, buf: &mut [u8]) -> io::Result { let bytes = self.reader.read(buf)?; - if bytes > 0 { - if let Err(e) = self.progress.update(bytes as u64) { - return Err(io::Error::other(e)); - } + if bytes > 0 && + let Err(e) = self.progress.update(bytes as u64) + { + return Err(io::Error::other(e)); } Ok(bytes) } diff --git a/crates/cli/commands/src/import_core.rs b/crates/cli/commands/src/import_core.rs index 4bd37f036b..2370ebaa03 100644 --- a/crates/cli/commands/src/import_core.rs +++ b/crates/cli/commands/src/import_core.rs @@ -192,7 +192,7 @@ pub fn build_import_pipeline_impl( static_file_producer: StaticFileProducer>, disable_exec: bool, evm_config: E, -) -> eyre::Result<(Pipeline, impl futures::Stream>)> +) -> eyre::Result<(Pipeline, impl futures::Stream> + use)> where N: ProviderNodeTypes, C: FullConsensus + 'static, diff --git a/crates/cli/util/src/sigsegv_handler.rs b/crates/cli/util/src/sigsegv_handler.rs index b0a195391f..dabbf866ce 100644 --- a/crates/cli/util/src/sigsegv_handler.rs +++ b/crates/cli/util/src/sigsegv_handler.rs @@ -7,7 +7,7 @@ use std::{ fmt, mem, ptr, }; -extern "C" { +unsafe extern "C" { fn backtrace_symbols_fd(buffer: *const *mut libc::c_void, size: libc::c_int, fd: libc::c_int); } diff --git a/crates/e2e-test-utils/src/lib.rs b/crates/e2e-test-utils/src/lib.rs index 0037197f26..a51b78ae65 100644 --- a/crates/e2e-test-utils/src/lib.rs +++ b/crates/e2e-test-utils/src/lib.rs @@ -96,10 +96,11 @@ where } // Connect last node with the first if there are more than two - if idx + 1 == num_nodes && num_nodes > 2 { - if let Some(first_node) = nodes.first_mut() { - node.connect(first_node).await; - } + if idx + 1 == num_nodes && + num_nodes > 2 && + let Some(first_node) = nodes.first_mut() + { + node.connect(first_node).await; } nodes.push(node); @@ -207,10 +208,11 @@ where } // Connect last node with the first if there are more than two - if idx + 1 == num_nodes && num_nodes > 2 { - if let Some(first_node) = nodes.first_mut() { - node.connect(first_node).await; - } + if idx + 1 == num_nodes && + num_nodes > 2 && + let Some(first_node) = nodes.first_mut() + { + node.connect(first_node).await; } } diff --git a/crates/e2e-test-utils/src/node.rs b/crates/e2e-test-utils/src/node.rs index 8611da2dae..ad1f807b08 100644 --- a/crates/e2e-test-utils/src/node.rs +++ b/crates/e2e-test-utils/src/node.rs @@ -150,14 +150,13 @@ where loop { tokio::time::sleep(std::time::Duration::from_millis(20)).await; - if !check && wait_finish_checkpoint { - if let Some(checkpoint) = - self.inner.provider.get_stage_checkpoint(StageId::Finish)? - { - if checkpoint.block_number >= number { - check = true - } - } + if !check && + wait_finish_checkpoint && + let Some(checkpoint) = + self.inner.provider.get_stage_checkpoint(StageId::Finish)? && + checkpoint.block_number >= number + { + check = true } if check { @@ -178,10 +177,10 @@ where pub async fn wait_unwind(&self, number: BlockNumber) -> eyre::Result<()> { loop { tokio::time::sleep(std::time::Duration::from_millis(10)).await; - if let Some(checkpoint) = self.inner.provider.get_stage_checkpoint(StageId::Headers)? { - if checkpoint.block_number == number { - break - } + if let Some(checkpoint) = self.inner.provider.get_stage_checkpoint(StageId::Headers)? && + checkpoint.block_number == number + { + break } } Ok(()) @@ -207,14 +206,13 @@ where // wait for the block to commit tokio::time::sleep(std::time::Duration::from_millis(20)).await; if let Some(latest_block) = - self.inner.provider.block_by_number_or_tag(BlockNumberOrTag::Latest)? + self.inner.provider.block_by_number_or_tag(BlockNumberOrTag::Latest)? && + latest_block.header().number() == block_number { - if latest_block.header().number() == block_number { - // make sure the block hash we submitted via FCU engine api is the new latest - // block using an RPC call - assert_eq!(latest_block.header().hash_slow(), block_hash); - break - } + // make sure the block hash we submitted via FCU engine api is the new latest + // block using an RPC call + assert_eq!(latest_block.header().hash_slow(), block_hash); + break } } Ok(()) diff --git a/crates/e2e-test-utils/src/testsuite/actions/mod.rs b/crates/e2e-test-utils/src/testsuite/actions/mod.rs index 8543444bff..d491626569 100644 --- a/crates/e2e-test-utils/src/testsuite/actions/mod.rs +++ b/crates/e2e-test-utils/src/testsuite/actions/mod.rs @@ -174,16 +174,13 @@ where ]; // if we're on a fork, validate it now that it's canonical - if let Ok(active_state) = env.active_node_state() { - if let Some(fork_base) = active_state.current_fork_base { - debug!( - "MakeCanonical: Adding fork validation from base block {}", - fork_base - ); - actions.push(Box::new(ValidateFork::new(fork_base))); - // clear the fork base since we're now canonical - env.active_node_state_mut()?.current_fork_base = None; - } + if let Ok(active_state) = env.active_node_state() && + let Some(fork_base) = active_state.current_fork_base + { + debug!("MakeCanonical: Adding fork validation from base block {}", fork_base); + actions.push(Box::new(ValidateFork::new(fork_base))); + // clear the fork base since we're now canonical + env.active_node_state_mut()?.current_fork_base = None; } let mut sequence = Sequence::new(actions); diff --git a/crates/e2e-test-utils/src/testsuite/actions/node_ops.rs b/crates/e2e-test-utils/src/testsuite/actions/node_ops.rs index f42951fc57..a00ab5e867 100644 --- a/crates/e2e-test-utils/src/testsuite/actions/node_ops.rs +++ b/crates/e2e-test-utils/src/testsuite/actions/node_ops.rs @@ -195,15 +195,15 @@ where .copied() .ok_or_else(|| eyre::eyre!("Block tag '{}' not found in registry", self.tag))?; - if let Some(expected_node) = self.expected_node_idx { - if node_idx != expected_node { - return Err(eyre::eyre!( - "Block tag '{}' came from node {} but expected node {}", - self.tag, - node_idx, - expected_node - )); - } + if let Some(expected_node) = self.expected_node_idx && + node_idx != expected_node + { + return Err(eyre::eyre!( + "Block tag '{}' came from node {} but expected node {}", + self.tag, + node_idx, + expected_node + )); } debug!( diff --git a/crates/e2e-test-utils/src/testsuite/setup.rs b/crates/e2e-test-utils/src/testsuite/setup.rs index a13518149f..1425d53411 100644 --- a/crates/e2e-test-utils/src/testsuite/setup.rs +++ b/crates/e2e-test-utils/src/testsuite/setup.rs @@ -219,7 +219,7 @@ where let is_dev = self.is_dev; let node_count = self.network.node_count; - let attributes_generator = self.create_attributes_generator::(); + let attributes_generator = Self::create_static_attributes_generator::(); let result = setup_engine_with_connection::( node_count, @@ -304,10 +304,11 @@ where .await } - /// Create the attributes generator function - fn create_attributes_generator( - &self, - ) -> impl Fn(u64) -> <::Payload as PayloadTypes>::PayloadBuilderAttributes + Copy + /// Create a static attributes generator that doesn't capture any instance data + fn create_static_attributes_generator( + ) -> impl Fn(u64) -> <::Payload as PayloadTypes>::PayloadBuilderAttributes + + Copy + + use where N: NodeBuilderHelper, LocalPayloadAttributesBuilder: PayloadAttributesBuilder< diff --git a/crates/e2e-test-utils/tests/e2e-testsuite/main.rs b/crates/e2e-test-utils/tests/e2e-testsuite/main.rs index 96c976a44c..5cd1bfe8c6 100644 --- a/crates/e2e-test-utils/tests/e2e-testsuite/main.rs +++ b/crates/e2e-test-utils/tests/e2e-testsuite/main.rs @@ -89,11 +89,11 @@ async fn test_apply_with_import() -> Result<()> { ) .await; - if let Ok(Some(block)) = block_result { - if block.header.number == 10 { - debug!("Pipeline finished, block 10 is fully available"); - break; - } + if let Ok(Some(block)) = block_result && + block.header.number == 10 + { + debug!("Pipeline finished, block 10 is fully available"); + break; } if start.elapsed() > std::time::Duration::from_secs(10) { diff --git a/crates/engine/tree/src/tree/cached_state.rs b/crates/engine/tree/src/tree/cached_state.rs index 2fbeed1509..504a19fbbd 100644 --- a/crates/engine/tree/src/tree/cached_state.rs +++ b/crates/engine/tree/src/tree/cached_state.rs @@ -664,7 +664,7 @@ mod tests { unsafe impl GlobalAlloc for TrackingAllocator { unsafe fn alloc(&self, layout: Layout) -> *mut u8 { - let ret = self.inner.alloc(layout); + let ret = unsafe { self.inner.alloc(layout) }; if !ret.is_null() { self.allocated.fetch_add(layout.size(), Ordering::SeqCst); self.total_allocated.fetch_add(layout.size(), Ordering::SeqCst); @@ -674,7 +674,7 @@ mod tests { unsafe fn dealloc(&self, ptr: *mut u8, layout: Layout) { self.allocated.fetch_sub(layout.size(), Ordering::SeqCst); - self.inner.dealloc(ptr, layout) + unsafe { self.inner.dealloc(ptr, layout) } } } } diff --git a/crates/engine/tree/src/tree/mod.rs b/crates/engine/tree/src/tree/mod.rs index 4cdb17477b..5faf8318e7 100644 --- a/crates/engine/tree/src/tree/mod.rs +++ b/crates/engine/tree/src/tree/mod.rs @@ -1801,10 +1801,10 @@ where fn prepare_invalid_response(&mut self, mut parent_hash: B256) -> ProviderResult { // Edge case: the `latestValid` field is the zero hash if the parent block is the terminal // PoW block, which we need to identify by looking at the parent's block difficulty - if let Some(parent) = self.sealed_header_by_hash(parent_hash)? { - if !parent.difficulty().is_zero() { - parent_hash = B256::ZERO; - } + if let Some(parent) = self.sealed_header_by_hash(parent_hash)? && + !parent.difficulty().is_zero() + { + parent_hash = B256::ZERO; } let valid_parent_hash = self.latest_valid_hash_for_invalid_payload(parent_hash)?; @@ -1970,62 +1970,65 @@ where let sync_target_state = self.state.forkchoice_state_tracker.sync_target_state(); // check if the downloaded block is the tracked finalized block - let mut exceeds_backfill_threshold = if let Some(buffered_finalized) = sync_target_state - .as_ref() - .and_then(|state| self.state.buffer.block(&state.finalized_block_hash)) - { - // if we have buffered the finalized block, we should check how far - // we're off - self.exceeds_backfill_run_threshold(canonical_tip_num, buffered_finalized.number()) - } else { - // check if the distance exceeds the threshold for backfill sync - self.exceeds_backfill_run_threshold(canonical_tip_num, target_block_number) - }; - - // If this is invoked after we downloaded a block we can check if this block is the - // finalized block - if let (Some(downloaded_block), Some(ref state)) = (downloaded_block, sync_target_state) { - if downloaded_block.hash == state.finalized_block_hash { - // we downloaded the finalized block and can now check how far we're off - exceeds_backfill_threshold = - self.exceeds_backfill_run_threshold(canonical_tip_num, downloaded_block.number); - } - } + let exceeds_backfill_threshold = + match (downloaded_block.as_ref(), sync_target_state.as_ref()) { + // if we downloaded the finalized block we can now check how far we're off + (Some(downloaded_block), Some(state)) + if downloaded_block.hash == state.finalized_block_hash => + { + self.exceeds_backfill_run_threshold(canonical_tip_num, downloaded_block.number) + } + _ => match sync_target_state + .as_ref() + .and_then(|state| self.state.buffer.block(&state.finalized_block_hash)) + { + Some(buffered_finalized) => { + // if we have buffered the finalized block, we should check how far we're + // off + self.exceeds_backfill_run_threshold( + canonical_tip_num, + buffered_finalized.number(), + ) + } + None => { + // check if the distance exceeds the threshold for backfill sync + self.exceeds_backfill_run_threshold(canonical_tip_num, target_block_number) + } + }, + }; // if the number of missing blocks is greater than the max, trigger backfill - if exceeds_backfill_threshold { - if let Some(state) = sync_target_state { - // if we have already canonicalized the finalized block, we should skip backfill - match self.provider.header_by_hash_or_number(state.finalized_block_hash.into()) { - Err(err) => { - warn!(target: "engine::tree", %err, "Failed to get finalized block header"); + if exceeds_backfill_threshold && let Some(state) = sync_target_state { + // if we have already canonicalized the finalized block, we should skip backfill + match self.provider.header_by_hash_or_number(state.finalized_block_hash.into()) { + Err(err) => { + warn!(target: "engine::tree", %err, "Failed to get finalized block header"); + } + Ok(None) => { + // ensure the finalized block is known (not the zero hash) + if !state.finalized_block_hash.is_zero() { + // we don't have the block yet and the distance exceeds the allowed + // threshold + return Some(state.finalized_block_hash) } - Ok(None) => { - // ensure the finalized block is known (not the zero hash) - if !state.finalized_block_hash.is_zero() { - // we don't have the block yet and the distance exceeds the allowed - // threshold - return Some(state.finalized_block_hash) - } - // OPTIMISTIC SYNCING - // - // It can happen when the node is doing an - // optimistic sync, where the CL has no knowledge of the finalized hash, - // but is expecting the EL to sync as high - // as possible before finalizing. - // - // This usually doesn't happen on ETH mainnet since CLs use the more - // secure checkpoint syncing. - // - // However, optimism chains will do this. The risk of a reorg is however - // low. - debug!(target: "engine::tree", hash=?state.head_block_hash, "Setting head hash as an optimistic backfill target."); - return Some(state.head_block_hash) - } - Ok(Some(_)) => { - // we're fully synced to the finalized block - } + // OPTIMISTIC SYNCING + // + // It can happen when the node is doing an + // optimistic sync, where the CL has no knowledge of the finalized hash, + // but is expecting the EL to sync as high + // as possible before finalizing. + // + // This usually doesn't happen on ETH mainnet since CLs use the more + // secure checkpoint syncing. + // + // However, optimism chains will do this. The risk of a reorg is however + // low. + debug!(target: "engine::tree", hash=?state.head_block_hash, "Setting head hash as an optimistic backfill target."); + return Some(state.head_block_hash) + } + Ok(Some(_)) => { + // we're fully synced to the finalized block } } } diff --git a/crates/engine/util/src/engine_store.rs b/crates/engine/util/src/engine_store.rs index 4f9ccb586e..a79504db30 100644 --- a/crates/engine/util/src/engine_store.rs +++ b/crates/engine/util/src/engine_store.rs @@ -140,10 +140,10 @@ where fn poll_next(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll> { let mut this = self.project(); let next = ready!(this.stream.poll_next_unpin(cx)); - if let Some(msg) = &next { - if let Err(error) = this.store.on_message(msg, SystemTime::now()) { - error!(target: "engine::stream::store", ?msg, %error, "Error handling Engine API message"); - } + if let Some(msg) = &next && + let Err(error) = this.store.on_message(msg, SystemTime::now()) + { + error!(target: "engine::stream::store", ?msg, %error, "Error handling Engine API message"); } Poll::Ready(next) } diff --git a/crates/era-downloader/src/client.rs b/crates/era-downloader/src/client.rs index 41b9e22c1b..298248ff3e 100644 --- a/crates/era-downloader/src/client.rs +++ b/crates/era-downloader/src/client.rs @@ -106,12 +106,11 @@ impl EraClient { if let Ok(mut dir) = fs::read_dir(&self.folder).await { while let Ok(Some(entry)) = dir.next_entry().await { - if let Some(name) = entry.file_name().to_str() { - if let Some(number) = self.file_name_to_number(name) { - if max.is_none() || matches!(max, Some(max) if number > max) { - max.replace(number + 1); - } - } + if let Some(name) = entry.file_name().to_str() && + let Some(number) = self.file_name_to_number(name) && + (max.is_none() || matches!(max, Some(max) if number > max)) + { + max.replace(number + 1); } } } @@ -125,14 +124,13 @@ impl EraClient { if let Ok(mut dir) = fs::read_dir(&self.folder).await { while let Ok(Some(entry)) = dir.next_entry().await { - if let Some(name) = entry.file_name().to_str() { - if let Some(number) = self.file_name_to_number(name) { - if number < index || number >= last { - eprintln!("Deleting file {}", entry.path().display()); - eprintln!("{number} < {index} || {number} >= {last}"); - reth_fs_util::remove_file(entry.path())?; - } - } + if let Some(name) = entry.file_name().to_str() && + let Some(number) = self.file_name_to_number(name) && + (number < index || number >= last) + { + eprintln!("Deleting file {}", entry.path().display()); + eprintln!("{number} < {index} || {number} >= {last}"); + reth_fs_util::remove_file(entry.path())?; } } } @@ -208,12 +206,12 @@ impl EraClient { let mut writer = io::BufWriter::new(file); while let Some(line) = lines.next_line().await? { - if let Some(j) = line.find(".era1") { - if let Some(i) = line[..j].rfind(|c: char| !c.is_alphanumeric() && c != '-') { - let era = &line[i + 1..j + 5]; - writer.write_all(era.as_bytes()).await?; - writer.write_all(b"\n").await?; - } + if let Some(j) = line.find(".era1") && + let Some(i) = line[..j].rfind(|c: char| !c.is_alphanumeric() && c != '-') + { + let era = &line[i + 1..j + 5]; + writer.write_all(era.as_bytes()).await?; + writer.write_all(b"\n").await?; } } writer.flush().await?; diff --git a/crates/era-downloader/src/fs.rs b/crates/era-downloader/src/fs.rs index 17a2d46d26..19532f01cf 100644 --- a/crates/era-downloader/src/fs.rs +++ b/crates/era-downloader/src/fs.rs @@ -17,16 +17,16 @@ pub fn read_dir( (|| { let path = entry?.path(); - if path.extension() == Some("era1".as_ref()) { - if let Some(last) = path.components().next_back() { - let str = last.as_os_str().to_string_lossy().to_string(); - let parts = str.split('-').collect::>(); + if path.extension() == Some("era1".as_ref()) && + let Some(last) = path.components().next_back() + { + let str = last.as_os_str().to_string_lossy().to_string(); + let parts = str.split('-').collect::>(); - if parts.len() == 3 { - let number = usize::from_str(parts[1])?; + if parts.len() == 3 { + let number = usize::from_str(parts[1])?; - return Ok(Some((number, path.into_boxed_path()))); - } + return Ok(Some((number, path.into_boxed_path()))); } } if path.file_name() == Some("checksums.txt".as_ref()) { diff --git a/crates/era-downloader/src/stream.rs b/crates/era-downloader/src/stream.rs index a488e098ab..4e8a178e57 100644 --- a/crates/era-downloader/src/stream.rs +++ b/crates/era-downloader/src/stream.rs @@ -262,47 +262,47 @@ impl Stream for Starti self.fetch_file_list(); } - if self.state == State::FetchFileList { - if let Poll::Ready(result) = self.fetch_file_list.poll_unpin(cx) { - match result { - Ok(_) => self.delete_outside_range(), - Err(e) => { - self.fetch_file_list(); + if self.state == State::FetchFileList && + let Poll::Ready(result) = self.fetch_file_list.poll_unpin(cx) + { + match result { + Ok(_) => self.delete_outside_range(), + Err(e) => { + self.fetch_file_list(); - return Poll::Ready(Some(Box::pin(async move { Err(e) }))); - } + return Poll::Ready(Some(Box::pin(async move { Err(e) }))); } } } - if self.state == State::DeleteOutsideRange { - if let Poll::Ready(result) = self.delete_outside_range.poll_unpin(cx) { - match result { - Ok(_) => self.recover_index(), - Err(e) => { - self.delete_outside_range(); + if self.state == State::DeleteOutsideRange && + let Poll::Ready(result) = self.delete_outside_range.poll_unpin(cx) + { + match result { + Ok(_) => self.recover_index(), + Err(e) => { + self.delete_outside_range(); - return Poll::Ready(Some(Box::pin(async move { Err(e) }))); - } + return Poll::Ready(Some(Box::pin(async move { Err(e) }))); } } } - if self.state == State::RecoverIndex { - if let Poll::Ready(last) = self.recover_index.poll_unpin(cx) { - self.last = last; - self.count_files(); - } + if self.state == State::RecoverIndex && + let Poll::Ready(last) = self.recover_index.poll_unpin(cx) + { + self.last = last; + self.count_files(); } - if self.state == State::CountFiles { - if let Poll::Ready(downloaded) = self.files_count.poll_unpin(cx) { - let max_missing = self - .max_files - .saturating_sub(downloaded + self.downloading) - .max(self.last.unwrap_or_default().saturating_sub(self.index)); - self.state = State::Missing(max_missing); - } + if self.state == State::CountFiles && + let Poll::Ready(downloaded) = self.files_count.poll_unpin(cx) + { + let max_missing = self + .max_files + .saturating_sub(downloaded + self.downloading) + .max(self.last.unwrap_or_default().saturating_sub(self.index)); + self.state = State::Missing(max_missing); } if let State::Missing(max_missing) = self.state { @@ -316,18 +316,16 @@ impl Stream for Starti } } - if let State::NextUrl(max_missing) = self.state { - if let Poll::Ready(url) = self.next_url.poll_unpin(cx) { - self.state = State::Missing(max_missing - 1); + if let State::NextUrl(max_missing) = self.state && + let Poll::Ready(url) = self.next_url.poll_unpin(cx) + { + self.state = State::Missing(max_missing - 1); - return Poll::Ready(url.transpose().map(|url| -> DownloadFuture { - let mut client = self.client.clone(); + return Poll::Ready(url.transpose().map(|url| -> DownloadFuture { + let mut client = self.client.clone(); - Box::pin( - async move { client.download_to_file(url?).await.map(EraRemoteMeta::new) }, - ) - })); - } + Box::pin(async move { client.download_to_file(url?).await.map(EraRemoteMeta::new) }) + })); } Poll::Pending diff --git a/crates/era-utils/src/history.rs b/crates/era-utils/src/history.rs index 822fc3e154..31ac8825dc 100644 --- a/crates/era-utils/src/history.rs +++ b/crates/era-utils/src/history.rs @@ -302,10 +302,10 @@ where if number <= last_header_number { continue; } - if let Some(target) = target { - if number > target { - break; - } + if let Some(target) = target && + number > target + { + break; } let hash = header.hash_slow(); @@ -351,19 +351,18 @@ where // Database cursor for hash to number index let mut cursor_header_numbers = provider.tx_ref().cursor_write::>()?; - let mut first_sync = false; - // If we only have the genesis block hash, then we are at first sync, and we can remove it, // add it to the collector and use tx.append on all hashes. - if provider.tx_ref().entries::>()? == 1 { - if let Some((hash, block_number)) = cursor_header_numbers.last()? { - if block_number.value()? == 0 { - hash_collector.insert(hash.key()?, 0)?; - cursor_header_numbers.delete_current()?; - first_sync = true; - } - } - } + let first_sync = if provider.tx_ref().entries::>()? == 1 && + let Some((hash, block_number)) = cursor_header_numbers.last()? && + block_number.value()? == 0 + { + hash_collector.insert(hash.key()?, 0)?; + cursor_header_numbers.delete_current()?; + true + } else { + false + }; let interval = (total_headers / 10).max(8192); diff --git a/crates/ethereum/consensus/src/validation.rs b/crates/ethereum/consensus/src/validation.rs index 485828e608..71affffeb0 100644 --- a/crates/ethereum/consensus/src/validation.rs +++ b/crates/ethereum/consensus/src/validation.rs @@ -37,17 +37,19 @@ where // operation as hashing that is required for state root got calculated in every // transaction This was replaced with is_success flag. // See more about EIP here: https://eips.ethereum.org/EIPS/eip-658 - if chain_spec.is_byzantium_active_at_block(block.header().number()) { - if let Err(error) = - verify_receipts(block.header().receipts_root(), block.header().logs_bloom(), receipts) - { - let receipts = receipts - .iter() - .map(|r| Bytes::from(r.with_bloom_ref().encoded_2718())) - .collect::>(); - tracing::debug!(%error, ?receipts, "receipts verification failed"); - return Err(error) - } + if chain_spec.is_byzantium_active_at_block(block.header().number()) && + let Err(error) = verify_receipts( + block.header().receipts_root(), + block.header().logs_bloom(), + receipts, + ) + { + let receipts = receipts + .iter() + .map(|r| Bytes::from(r.with_bloom_ref().encoded_2718())) + .collect::>(); + tracing::debug!(%error, ?receipts, "receipts verification failed"); + return Err(error) } // Validate that the header requests hash matches the calculated requests hash diff --git a/crates/exex/exex/src/manager.rs b/crates/exex/exex/src/manager.rs index d5006dd9f1..d69d04c0e3 100644 --- a/crates/exex/exex/src/manager.rs +++ b/crates/exex/exex/src/manager.rs @@ -501,11 +501,11 @@ where .next_notification_id .checked_sub(this.min_id) .expect("exex expected notification ID outside the manager's range"); - if let Some(notification) = this.buffer.get(notification_index) { - if let Poll::Ready(Err(err)) = exex.send(cx, notification) { - // The channel was closed, which is irrecoverable for the manager - return Poll::Ready(Err(err.into())) - } + if let Some(notification) = this.buffer.get(notification_index) && + let Poll::Ready(Err(err)) = exex.send(cx, notification) + { + // The channel was closed, which is irrecoverable for the manager + return Poll::Ready(Err(err.into())) } min_id = min_id.min(exex.next_notification_id); this.exex_handles.push(exex); diff --git a/crates/net/banlist/src/lib.rs b/crates/net/banlist/src/lib.rs index 29cf8eb76a..9aa90fe7d9 100644 --- a/crates/net/banlist/src/lib.rs +++ b/crates/net/banlist/src/lib.rs @@ -59,11 +59,11 @@ impl BanList { pub fn evict_peers(&mut self, now: Instant) -> Vec { let mut evicted = Vec::new(); self.banned_peers.retain(|peer, until| { - if let Some(until) = until { - if now > *until { - evicted.push(*peer); - return false - } + if let Some(until) = until && + now > *until + { + evicted.push(*peer); + return false } true }); @@ -74,11 +74,11 @@ impl BanList { pub fn evict_ips(&mut self, now: Instant) -> Vec { let mut evicted = Vec::new(); self.banned_ips.retain(|peer, until| { - if let Some(until) = until { - if now > *until { - evicted.push(*peer); - return false - } + if let Some(until) = until && + now > *until + { + evicted.push(*peer); + return false } true }); diff --git a/crates/net/discv4/src/lib.rs b/crates/net/discv4/src/lib.rs index 976ade1728..426a8f3e0f 100644 --- a/crates/net/discv4/src/lib.rs +++ b/crates/net/discv4/src/lib.rs @@ -627,10 +627,10 @@ impl Discv4Service { /// Sets the external Ip to the configured external IP if [`NatResolver::ExternalIp`]. fn resolve_external_ip(&mut self) { - if let Some(r) = &self.resolve_external_ip_interval { - if let Some(external_ip) = r.resolver().as_external_ip() { - self.set_external_ip_addr(external_ip); - } + if let Some(r) = &self.resolve_external_ip_interval && + let Some(external_ip) = r.resolver().as_external_ip() + { + self.set_external_ip_addr(external_ip); } } @@ -904,10 +904,10 @@ impl Discv4Service { /// Check if the peer has an active bond. fn has_bond(&self, remote_id: PeerId, remote_ip: IpAddr) -> bool { - if let Some(timestamp) = self.received_pongs.last_pong(remote_id, remote_ip) { - if timestamp.elapsed() < self.config.bond_expiration { - return true - } + if let Some(timestamp) = self.received_pongs.last_pong(remote_id, remote_ip) && + timestamp.elapsed() < self.config.bond_expiration + { + return true } false } @@ -3048,12 +3048,11 @@ mod tests { loop { tokio::select! { Some(update) = updates.next() => { - if let DiscoveryUpdate::Added(record) = update { - if record.id == peerid_1 { + if let DiscoveryUpdate::Added(record) = update + && record.id == peerid_1 { bootnode_appeared = true; break; } - } } _ = &mut timeout => break, } diff --git a/crates/net/discv5/src/config.rs b/crates/net/discv5/src/config.rs index ef89e72da5..c567754441 100644 --- a/crates/net/discv5/src/config.rs +++ b/crates/net/discv5/src/config.rs @@ -152,10 +152,10 @@ impl ConfigBuilder { /// Adds a comma-separated list of enodes, serialized unsigned node records, to boot nodes. pub fn add_serialized_unsigned_boot_nodes(mut self, enodes: &[&str]) -> Self { for node in enodes { - if let Ok(node) = node.parse() { - if let Ok(node) = BootNode::from_unsigned(node) { - self.bootstrap_nodes.insert(node); - } + if let Ok(node) = node.parse() && + let Ok(node) = BootNode::from_unsigned(node) + { + self.bootstrap_nodes.insert(node); } } @@ -411,14 +411,14 @@ pub fn discv5_sockets_wrt_rlpx_addr( let discv5_socket_ipv6 = discv5_addr_ipv6.map(|ip| SocketAddrV6::new(ip, discv5_port_ipv6, 0, 0)); - if let Some(discv5_addr) = discv5_addr_ipv4 { - if discv5_addr != rlpx_addr { - debug!(target: "net::discv5", - %discv5_addr, - %rlpx_addr, - "Overwriting discv5 IPv4 address with RLPx IPv4 address, limited to one advertised IP address per IP version" - ); - } + if let Some(discv5_addr) = discv5_addr_ipv4 && + discv5_addr != rlpx_addr + { + debug!(target: "net::discv5", + %discv5_addr, + %rlpx_addr, + "Overwriting discv5 IPv4 address with RLPx IPv4 address, limited to one advertised IP address per IP version" + ); } // overwrite discv5 ipv4 addr with RLPx address. this is since there is no @@ -430,14 +430,14 @@ pub fn discv5_sockets_wrt_rlpx_addr( let discv5_socket_ipv4 = discv5_addr_ipv4.map(|ip| SocketAddrV4::new(ip, discv5_port_ipv4)); - if let Some(discv5_addr) = discv5_addr_ipv6 { - if discv5_addr != rlpx_addr { - debug!(target: "net::discv5", - %discv5_addr, - %rlpx_addr, - "Overwriting discv5 IPv6 address with RLPx IPv6 address, limited to one advertised IP address per IP version" - ); - } + if let Some(discv5_addr) = discv5_addr_ipv6 && + discv5_addr != rlpx_addr + { + debug!(target: "net::discv5", + %discv5_addr, + %rlpx_addr, + "Overwriting discv5 IPv6 address with RLPx IPv6 address, limited to one advertised IP address per IP version" + ); } // overwrite discv5 ipv6 addr with RLPx address. this is since there is no diff --git a/crates/net/dns/src/query.rs b/crates/net/dns/src/query.rs index edf387ec5c..f64551f42f 100644 --- a/crates/net/dns/src/query.rs +++ b/crates/net/dns/src/query.rs @@ -80,12 +80,12 @@ impl QueryPool { // queue in new queries if we have capacity 'queries: while self.active_queries.len() < self.rate_limit.limit() as usize { - if self.rate_limit.poll_ready(cx).is_ready() { - if let Some(query) = self.queued_queries.pop_front() { - self.rate_limit.tick(); - self.active_queries.push(query); - continue 'queries - } + if self.rate_limit.poll_ready(cx).is_ready() && + let Some(query) = self.queued_queries.pop_front() + { + self.rate_limit.tick(); + self.active_queries.push(query); + continue 'queries } break } diff --git a/crates/net/downloaders/src/headers/reverse_headers.rs b/crates/net/downloaders/src/headers/reverse_headers.rs index a0876ea216..cb6b36c9ff 100644 --- a/crates/net/downloaders/src/headers/reverse_headers.rs +++ b/crates/net/downloaders/src/headers/reverse_headers.rs @@ -172,19 +172,16 @@ where /// /// Returns `None` if no more requests are required. fn next_request(&mut self) -> Option { - if let Some(local_head) = self.local_block_number() { - if self.next_request_block_number > local_head { - let request = calc_next_request( - local_head, - self.next_request_block_number, - self.request_limit, - ); - // need to shift the tracked request block number based on the number of requested - // headers so follow-up requests will use that as start. - self.next_request_block_number -= request.limit; + if let Some(local_head) = self.local_block_number() && + self.next_request_block_number > local_head + { + let request = + calc_next_request(local_head, self.next_request_block_number, self.request_limit); + // need to shift the tracked request block number based on the number of requested + // headers so follow-up requests will use that as start. + self.next_request_block_number -= request.limit; - return Some(request) - } + return Some(request) } None diff --git a/crates/net/eth-wire/src/handshake.rs b/crates/net/eth-wire/src/handshake.rs index d9656180f9..8d412c349e 100644 --- a/crates/net/eth-wire/src/handshake.rs +++ b/crates/net/eth-wire/src/handshake.rs @@ -179,18 +179,18 @@ where } // Ensure peer's total difficulty is reasonable - if let StatusMessage::Legacy(s) = their_status_message { - if s.total_difficulty.bit_len() > 160 { - unauth - .disconnect(DisconnectReason::ProtocolBreach) - .await - .map_err(EthStreamError::from)?; - return Err(EthHandshakeError::TotalDifficultyBitLenTooLarge { - got: s.total_difficulty.bit_len(), - maximum: 160, - } - .into()); + if let StatusMessage::Legacy(s) = their_status_message && + s.total_difficulty.bit_len() > 160 + { + unauth + .disconnect(DisconnectReason::ProtocolBreach) + .await + .map_err(EthStreamError::from)?; + return Err(EthHandshakeError::TotalDifficultyBitLenTooLarge { + got: s.total_difficulty.bit_len(), + maximum: 160, } + .into()); } // Fork validation diff --git a/crates/net/network/src/config.rs b/crates/net/network/src/config.rs index dda3428126..8e8d11fe69 100644 --- a/crates/net/network/src/config.rs +++ b/crates/net/network/src/config.rs @@ -656,13 +656,11 @@ impl NetworkConfigBuilder { // If default DNS config is used then we add the known dns network to bootstrap from if let Some(dns_networks) = - dns_discovery_config.as_mut().and_then(|c| c.bootstrap_dns_networks.as_mut()) + dns_discovery_config.as_mut().and_then(|c| c.bootstrap_dns_networks.as_mut()) && + dns_networks.is_empty() && + let Some(link) = chain_spec.chain().public_dns_network_protocol() { - if dns_networks.is_empty() { - if let Some(link) = chain_spec.chain().public_dns_network_protocol() { - dns_networks.insert(link.parse().expect("is valid DNS link entry")); - } - } + dns_networks.insert(link.parse().expect("is valid DNS link entry")); } NetworkConfig { diff --git a/crates/net/network/src/discovery.rs b/crates/net/network/src/discovery.rs index 5809380aa8..6b95b1e3a6 100644 --- a/crates/net/network/src/discovery.rs +++ b/crates/net/network/src/discovery.rs @@ -267,12 +267,11 @@ impl Discovery { while let Some(Poll::Ready(Some(update))) = self.discv5_updates.as_mut().map(|updates| updates.poll_next_unpin(cx)) { - if let Some(discv5) = self.discv5.as_mut() { - if let Some(DiscoveredPeer { node_record, fork_id }) = + if let Some(discv5) = self.discv5.as_mut() && + let Some(DiscoveredPeer { node_record, fork_id }) = discv5.on_discv5_update(update) - { - self.on_node_record_update(node_record, fork_id); - } + { + self.on_node_record_update(node_record, fork_id); } } diff --git a/crates/net/network/src/fetch/mod.rs b/crates/net/network/src/fetch/mod.rs index ece4fb626a..6c14e99400 100644 --- a/crates/net/network/src/fetch/mod.rs +++ b/crates/net/network/src/fetch/mod.rs @@ -116,12 +116,12 @@ impl StateFetcher { /// /// Returns `true` if this a newer block pub(crate) fn update_peer_block(&mut self, peer_id: &PeerId, hash: B256, number: u64) -> bool { - if let Some(peer) = self.peers.get_mut(peer_id) { - if number > peer.best_number { - peer.best_hash = hash; - peer.best_number = number; - return true - } + if let Some(peer) = self.peers.get_mut(peer_id) && + number > peer.best_number + { + peer.best_hash = hash; + peer.best_number = number; + return true } false } diff --git a/crates/net/network/src/peers.rs b/crates/net/network/src/peers.rs index 0120325ff4..39a8e11a26 100644 --- a/crates/net/network/src/peers.rs +++ b/crates/net/network/src/peers.rs @@ -382,14 +382,15 @@ impl PeersManager { /// Bans the peer temporarily with the configured ban timeout fn ban_peer(&mut self, peer_id: PeerId) { - let mut ban_duration = self.ban_duration; - if let Some(peer) = self.peers.get(&peer_id) { - if peer.is_trusted() || peer.is_static() { - // For misbehaving trusted or static peers, we provide a bit more leeway when - // penalizing them. - ban_duration = self.backoff_durations.low / 2; - } - } + let ban_duration = if let Some(peer) = self.peers.get(&peer_id) && + (peer.is_trusted() || peer.is_static()) + { + // For misbehaving trusted or static peers, we provide a bit more leeway when + // penalizing them. + self.backoff_durations.low / 2 + } else { + self.ban_duration + }; self.ban_list.ban_peer_until(peer_id, std::time::Instant::now() + ban_duration); self.queued_actions.push_back(PeerAction::BanPeer { peer_id }); diff --git a/crates/net/network/src/session/active.rs b/crates/net/network/src/session/active.rs index 4a70289bfd..48aadd05e0 100644 --- a/crates/net/network/src/session/active.rs +++ b/crates/net/network/src/session/active.rs @@ -738,11 +738,11 @@ impl Future for ActiveSession { while this.internal_request_timeout_interval.poll_tick(cx).is_ready() { // check for timed out requests - if this.check_timed_out_requests(Instant::now()) { - if let Poll::Ready(Ok(_)) = this.to_session_manager.poll_reserve(cx) { - let msg = ActiveSessionMessage::ProtocolBreach { peer_id: this.remote_peer_id }; - this.pending_message_to_session = Some(msg); - } + if this.check_timed_out_requests(Instant::now()) && + let Poll::Ready(Ok(_)) = this.to_session_manager.poll_reserve(cx) + { + let msg = ActiveSessionMessage::ProtocolBreach { peer_id: this.remote_peer_id }; + this.pending_message_to_session = Some(msg); } } diff --git a/crates/net/network/src/session/counter.rs b/crates/net/network/src/session/counter.rs index 215c7279d1..db9bd16cda 100644 --- a/crates/net/network/src/session/counter.rs +++ b/crates/net/network/src/session/counter.rs @@ -80,10 +80,10 @@ impl SessionCounter { } const fn ensure(current: u32, limit: Option) -> Result<(), ExceedsSessionLimit> { - if let Some(limit) = limit { - if current >= limit { - return Err(ExceedsSessionLimit(limit)) - } + if let Some(limit) = limit && + current >= limit + { + return Err(ExceedsSessionLimit(limit)) } Ok(()) } diff --git a/crates/net/network/src/transactions/mod.rs b/crates/net/network/src/transactions/mod.rs index 841a0f063f..eca7535ec9 100644 --- a/crates/net/network/src/transactions/mod.rs +++ b/crates/net/network/src/transactions/mod.rs @@ -697,12 +697,11 @@ impl } }; - if is_eth68_message { - if let Some((actual_ty_byte, _)) = *metadata_ref_mut { - if let Ok(parsed_tx_type) = TxType::try_from(actual_ty_byte) { - tx_types_counter.increase_by_tx_type(parsed_tx_type); - } - } + if is_eth68_message && + let Some((actual_ty_byte, _)) = *metadata_ref_mut && + let Ok(parsed_tx_type) = TxType::try_from(actual_ty_byte) + { + tx_types_counter.increase_by_tx_type(parsed_tx_type); } let decision = self diff --git a/crates/net/p2p/src/full_block.rs b/crates/net/p2p/src/full_block.rs index 8dbf3ce569..06128c6b54 100644 --- a/crates/net/p2p/src/full_block.rs +++ b/crates/net/p2p/src/full_block.rs @@ -280,18 +280,18 @@ where Client: BlockClient, { fn poll(&mut self, cx: &mut Context<'_>) -> Poll> { - if let Some(fut) = Pin::new(&mut self.header).as_pin_mut() { - if let Poll::Ready(res) = fut.poll(cx) { - self.header = None; - return Poll::Ready(ResponseResult::Header(res)) - } + if let Some(fut) = Pin::new(&mut self.header).as_pin_mut() && + let Poll::Ready(res) = fut.poll(cx) + { + self.header = None; + return Poll::Ready(ResponseResult::Header(res)) } - if let Some(fut) = Pin::new(&mut self.body).as_pin_mut() { - if let Poll::Ready(res) = fut.poll(cx) { - self.body = None; - return Poll::Ready(ResponseResult::Body(res)) - } + if let Some(fut) = Pin::new(&mut self.body).as_pin_mut() && + let Poll::Ready(res) = fut.poll(cx) + { + self.body = None; + return Poll::Ready(ResponseResult::Body(res)) } Poll::Pending @@ -621,18 +621,18 @@ where &mut self, cx: &mut Context<'_>, ) -> Poll> { - if let Some(fut) = Pin::new(&mut self.headers).as_pin_mut() { - if let Poll::Ready(res) = fut.poll(cx) { - self.headers = None; - return Poll::Ready(RangeResponseResult::Header(res)) - } + if let Some(fut) = Pin::new(&mut self.headers).as_pin_mut() && + let Poll::Ready(res) = fut.poll(cx) + { + self.headers = None; + return Poll::Ready(RangeResponseResult::Header(res)) } - if let Some(fut) = Pin::new(&mut self.bodies).as_pin_mut() { - if let Poll::Ready(res) = fut.poll(cx) { - self.bodies = None; - return Poll::Ready(RangeResponseResult::Body(res)) - } + if let Some(fut) = Pin::new(&mut self.bodies).as_pin_mut() && + let Poll::Ready(res) = fut.poll(cx) + { + self.bodies = None; + return Poll::Ready(RangeResponseResult::Body(res)) } Poll::Pending diff --git a/crates/net/peers/src/node_record.rs b/crates/net/peers/src/node_record.rs index d9f10ebdbe..0b1ef38b3d 100644 --- a/crates/net/peers/src/node_record.rs +++ b/crates/net/peers/src/node_record.rs @@ -63,11 +63,11 @@ impl NodeRecord { /// See also [`std::net::Ipv6Addr::to_ipv4_mapped`] pub fn convert_ipv4_mapped(&mut self) -> bool { // convert IPv4 mapped IPv6 address - if let IpAddr::V6(v6) = self.address { - if let Some(v4) = v6.to_ipv4_mapped() { - self.address = v4.into(); - return true - } + if let IpAddr::V6(v6) = self.address && + let Some(v4) = v6.to_ipv4_mapped() + { + self.address = v4.into(); + return true } false } diff --git a/crates/node/builder/src/launch/common.rs b/crates/node/builder/src/launch/common.rs index f24586b0d7..e2bca82252 100644 --- a/crates/node/builder/src/launch/common.rs +++ b/crates/node/builder/src/launch/common.rs @@ -956,23 +956,24 @@ where where T: FullNodeTypes, { - if self.node_config().pruning.bodies_pre_merge { - if let Some(merge_block) = - self.chain_spec().ethereum_fork_activation(EthereumHardfork::Paris).block_number() - { - // Ensure we only expire transactions after we synced past the merge block. - let Some(latest) = self.blockchain_db().latest_header()? else { return Ok(()) }; - if latest.number() > merge_block { - let provider = self.blockchain_db().static_file_provider(); - if provider - .get_lowest_transaction_static_file_block() - .is_some_and(|lowest| lowest < merge_block) - { - info!(target: "reth::cli", merge_block, "Expiring pre-merge transactions"); - provider.delete_transactions_below(merge_block)?; - } else { - debug!(target: "reth::cli", merge_block, "No pre-merge transactions to expire"); - } + if self.node_config().pruning.bodies_pre_merge && + let Some(merge_block) = self + .chain_spec() + .ethereum_fork_activation(EthereumHardfork::Paris) + .block_number() + { + // Ensure we only expire transactions after we synced past the merge block. + let Some(latest) = self.blockchain_db().latest_header()? else { return Ok(()) }; + if latest.number() > merge_block { + let provider = self.blockchain_db().static_file_provider(); + if provider + .get_lowest_transaction_static_file_block() + .is_some_and(|lowest| lowest < merge_block) + { + info!(target: "reth::cli", merge_block, "Expiring pre-merge transactions"); + provider.delete_transactions_below(merge_block)?; + } else { + debug!(target: "reth::cli", merge_block, "No pre-merge transactions to expire"); } } } diff --git a/crates/node/ethstats/src/ethstats.rs b/crates/node/ethstats/src/ethstats.rs index aea8a160fc..b9fe5e4727 100644 --- a/crates/node/ethstats/src/ethstats.rs +++ b/crates/node/ethstats/src/ethstats.rs @@ -181,14 +181,14 @@ where let response = timeout(READ_TIMEOUT, conn.read_json()).await.map_err(|_| EthStatsError::Timeout)??; - if let Some(ack) = response.get("emit") { - if ack.get(0) == Some(&Value::String("ready".to_string())) { - info!( - target: "ethstats", - "Login successful to EthStats server as node_id {}", self.credentials.node_id - ); - return Ok(()); - } + if let Some(ack) = response.get("emit") && + ack.get(0) == Some(&Value::String("ready".to_string())) + { + info!( + target: "ethstats", + "Login successful to EthStats server as node_id {}", self.credentials.node_id + ); + return Ok(()); } debug!(target: "ethstats", "Login failed: Unauthorized or unexpected login response"); @@ -595,10 +595,10 @@ where tokio::spawn(async move { loop { let head = canonical_stream.next().await; - if let Some(head) = head { - if head_tx.send(head).await.is_err() { - break; - } + if let Some(head) = head && + head_tx.send(head).await.is_err() + { + break; } } @@ -681,10 +681,10 @@ where /// Attempts to close the connection cleanly and logs any errors /// that occur during the process. async fn disconnect(&self) { - if let Some(conn) = self.conn.write().await.take() { - if let Err(e) = conn.close().await { - debug!(target: "ethstats", "Error closing connection: {}", e); - } + if let Some(conn) = self.conn.write().await.take() && + let Err(e) = conn.close().await + { + debug!(target: "ethstats", "Error closing connection: {}", e); } } @@ -733,16 +733,13 @@ mod tests { // Handle ping while let Some(Ok(msg)) = ws_stream.next().await { - if let Message::Text(text) = msg { - if text.contains("node-ping") { - let pong = json!({ - "emit": ["node-pong", {"id": "test-node"}] - }); - ws_stream - .send(Message::Text(Utf8Bytes::from(pong.to_string()))) - .await - .unwrap(); - } + if let Message::Text(text) = msg && + text.contains("node-ping") + { + let pong = json!({ + "emit": ["node-pong", {"id": "test-node"}] + }); + ws_stream.send(Message::Text(Utf8Bytes::from(pong.to_string()))).await.unwrap(); } } }); diff --git a/crates/optimism/bin/src/main.rs b/crates/optimism/bin/src/main.rs index e1567ef1c9..b8f87ac77e 100644 --- a/crates/optimism/bin/src/main.rs +++ b/crates/optimism/bin/src/main.rs @@ -13,7 +13,9 @@ fn main() { // Enable backtraces unless a RUST_BACKTRACE value has already been explicitly provided. if std::env::var_os("RUST_BACKTRACE").is_none() { - std::env::set_var("RUST_BACKTRACE", "1"); + unsafe { + std::env::set_var("RUST_BACKTRACE", "1"); + } } if let Err(err) = diff --git a/crates/optimism/chainspec/src/lib.rs b/crates/optimism/chainspec/src/lib.rs index c04d1df4b8..d64da95d77 100644 --- a/crates/optimism/chainspec/src/lib.rs +++ b/crates/optimism/chainspec/src/lib.rs @@ -459,33 +459,33 @@ impl OpGenesisInfo { .unwrap_or_default(), ..Default::default() }; - if let Some(optimism_base_fee_info) = &info.optimism_chain_info.base_fee_info { - if let (Some(elasticity), Some(denominator)) = ( + if let Some(optimism_base_fee_info) = &info.optimism_chain_info.base_fee_info && + let (Some(elasticity), Some(denominator)) = ( optimism_base_fee_info.eip1559_elasticity, optimism_base_fee_info.eip1559_denominator, - ) { - let base_fee_params = if let Some(canyon_denominator) = - optimism_base_fee_info.eip1559_denominator_canyon - { - BaseFeeParamsKind::Variable( - vec![ - ( - EthereumHardfork::London.boxed(), - BaseFeeParams::new(denominator as u128, elasticity as u128), - ), - ( - OpHardfork::Canyon.boxed(), - BaseFeeParams::new(canyon_denominator as u128, elasticity as u128), - ), - ] - .into(), - ) - } else { - BaseFeeParams::new(denominator as u128, elasticity as u128).into() - }; + ) + { + let base_fee_params = if let Some(canyon_denominator) = + optimism_base_fee_info.eip1559_denominator_canyon + { + BaseFeeParamsKind::Variable( + vec![ + ( + EthereumHardfork::London.boxed(), + BaseFeeParams::new(denominator as u128, elasticity as u128), + ), + ( + OpHardfork::Canyon.boxed(), + BaseFeeParams::new(canyon_denominator as u128, elasticity as u128), + ), + ] + .into(), + ) + } else { + BaseFeeParams::new(denominator as u128, elasticity as u128).into() + }; - info.base_fee_params = base_fee_params; - } + info.base_fee_params = base_fee_params; } info @@ -498,19 +498,18 @@ pub fn make_op_genesis_header(genesis: &Genesis, hardforks: &ChainHardforks) -> // If Isthmus is active, overwrite the withdrawals root with the storage root of predeploy // `L2ToL1MessagePasser.sol` - if hardforks.fork(OpHardfork::Isthmus).active_at_timestamp(header.timestamp) { - if let Some(predeploy) = genesis.alloc.get(&ADDRESS_L2_TO_L1_MESSAGE_PASSER) { - if let Some(storage) = &predeploy.storage { - header.withdrawals_root = - Some(storage_root_unhashed(storage.iter().filter_map(|(k, v)| { - if v.is_zero() { - None - } else { - Some((*k, (*v).into())) - } - }))); - } - } + if hardforks.fork(OpHardfork::Isthmus).active_at_timestamp(header.timestamp) && + let Some(predeploy) = genesis.alloc.get(&ADDRESS_L2_TO_L1_MESSAGE_PASSER) && + let Some(storage) = &predeploy.storage + { + header.withdrawals_root = + Some(storage_root_unhashed(storage.iter().filter_map(|(k, v)| { + if v.is_zero() { + None + } else { + Some((*k, (*v).into())) + } + }))); } header diff --git a/crates/optimism/cli/src/commands/import_receipts.rs b/crates/optimism/cli/src/commands/import_receipts.rs index b155bbb9e3..c07af28c9f 100644 --- a/crates/optimism/cli/src/commands/import_receipts.rs +++ b/crates/optimism/cli/src/commands/import_receipts.rs @@ -141,11 +141,10 @@ where // Ensure that receipts hasn't been initialized apart from `init_genesis`. if let Some(num_receipts) = - static_file_provider.get_highest_static_file_tx(StaticFileSegment::Receipts) + static_file_provider.get_highest_static_file_tx(StaticFileSegment::Receipts) && + num_receipts > 0 { - if num_receipts > 0 { - eyre::bail!("Expected no receipts in storage, but found {num_receipts}."); - } + eyre::bail!("Expected no receipts in storage, but found {num_receipts}."); } match static_file_provider.get_highest_static_file_block(StaticFileSegment::Receipts) { Some(receipts_block) => { diff --git a/crates/optimism/cli/src/ovm_file_codec.rs b/crates/optimism/cli/src/ovm_file_codec.rs index eca58b1d0c..83f3e48728 100644 --- a/crates/optimism/cli/src/ovm_file_codec.rs +++ b/crates/optimism/cli/src/ovm_file_codec.rs @@ -303,7 +303,7 @@ mod tests { // Verify deposit transaction let deposit_tx = match &deposit_decoded.transaction { - OpTypedTransaction::Legacy(ref tx) => tx, + OpTypedTransaction::Legacy(tx) => tx, _ => panic!("Expected legacy transaction for NFT deposit"), }; @@ -345,7 +345,7 @@ mod tests { assert!(system_decoded.is_legacy()); let system_tx = match &system_decoded.transaction { - OpTypedTransaction::Legacy(ref tx) => tx, + OpTypedTransaction::Legacy(tx) => tx, _ => panic!("Expected Legacy transaction"), }; diff --git a/crates/optimism/consensus/src/validation/mod.rs b/crates/optimism/consensus/src/validation/mod.rs index 416179d765..2dd4cea090 100644 --- a/crates/optimism/consensus/src/validation/mod.rs +++ b/crates/optimism/consensus/src/validation/mod.rs @@ -93,21 +93,21 @@ pub fn validate_block_post_execution( // operation as hashing that is required for state root got calculated in every // transaction This was replaced with is_success flag. // See more about EIP here: https://eips.ethereum.org/EIPS/eip-658 - if chain_spec.is_byzantium_active_at_block(header.number()) { - if let Err(error) = verify_receipts_optimism( + if chain_spec.is_byzantium_active_at_block(header.number()) && + let Err(error) = verify_receipts_optimism( header.receipts_root(), header.logs_bloom(), receipts, chain_spec, header.timestamp(), - ) { - let receipts = receipts - .iter() - .map(|r| Bytes::from(r.with_bloom_ref().encoded_2718())) - .collect::>(); - tracing::debug!(%error, ?receipts, "receipts verification failed"); - return Err(error) - } + ) + { + let receipts = receipts + .iter() + .map(|r| Bytes::from(r.with_bloom_ref().encoded_2718())) + .collect::>(); + tracing::debug!(%error, ?receipts, "receipts verification failed"); + return Err(error) } // Check if gas used matches the value set in header. diff --git a/crates/optimism/flashblocks/src/service.rs b/crates/optimism/flashblocks/src/service.rs index 831aac550f..bb411f078c 100644 --- a/crates/optimism/flashblocks/src/service.rs +++ b/crates/optimism/flashblocks/src/service.rs @@ -103,7 +103,12 @@ where /// Returns `None` if the flashblock have no `base` or the base is not a child block of latest. fn build_args( &mut self, - ) -> Option>>>> { + ) -> Option< + BuildArgs< + impl IntoIterator>> + + use, + >, + > { let Some(base) = self.blocks.payload_base() else { trace!( flashblock_number = ?self.blocks.block_number(), @@ -115,11 +120,11 @@ where }; // attempt an initial consecutive check - if let Some(latest) = self.builder.provider().latest_header().ok().flatten() { - if latest.hash() != base.parent_hash { - trace!(flashblock_parent=?base.parent_hash, flashblock_number=base.block_number, local_latest=?latest.num_hash(), "Skipping non consecutive build attempt"); - return None; - } + if let Some(latest) = self.builder.provider().latest_header().ok().flatten() && + latest.hash() != base.parent_hash + { + trace!(flashblock_parent=?base.parent_hash, flashblock_number=base.block_number, local_latest=?latest.num_hash(), "Skipping non consecutive build attempt"); + return None; } Some(BuildArgs { @@ -216,16 +221,15 @@ where let fut = this.canon_receiver.recv(); pin!(fut); fut.poll_unpin(cx) - } { - if let Some(current) = this.on_new_tip(state) { - trace!( - parent_hash = %current.block().parent_hash(), - block_number = current.block().number(), - "Clearing current flashblock on new canonical block" - ); + } && let Some(current) = this.on_new_tip(state) + { + trace!( + parent_hash = %current.block().parent_hash(), + block_number = current.block().number(), + "Clearing current flashblock on new canonical block" + ); - return Poll::Ready(Some(Ok(None))) - } + return Poll::Ready(Some(Ok(None))) } if !this.rebuild && this.current.is_some() { diff --git a/crates/optimism/payload/src/builder.rs b/crates/optimism/payload/src/builder.rs index 2fb2500e90..1d73464e17 100644 --- a/crates/optimism/payload/src/builder.rs +++ b/crates/optimism/payload/src/builder.rs @@ -690,11 +690,11 @@ where // We skip invalid cross chain txs, they would be removed on the next block update in // the maintenance job - if let Some(interop) = interop { - if !is_valid_interop(interop, self.config.attributes.timestamp()) { - best_txs.mark_invalid(tx.signer(), tx.nonce()); - continue - } + if let Some(interop) = interop && + !is_valid_interop(interop, self.config.attributes.timestamp()) + { + best_txs.mark_invalid(tx.signer(), tx.nonce()); + continue } // check if the job was cancelled, if so we can exit early if self.cancel.is_cancelled() { diff --git a/crates/optimism/rpc/src/eth/transaction.rs b/crates/optimism/rpc/src/eth/transaction.rs index 27d1ad831b..fb98569db1 100644 --- a/crates/optimism/rpc/src/eth/transaction.rs +++ b/crates/optimism/rpc/src/eth/transaction.rs @@ -108,11 +108,10 @@ where if let Some(notification) = canonical_notification { let chain = notification.committed(); for block in chain.blocks_iter() { - if block.body().contains_transaction(&hash) { - if let Some(receipt) = this.transaction_receipt(hash).await? { + if block.body().contains_transaction(&hash) + && let Some(receipt) = this.transaction_receipt(hash).await? { return Ok(receipt); } - } } } else { // Canonical stream ended @@ -130,11 +129,10 @@ where // Check flashblocks for faster confirmation (Optimism-specific) if let Ok(Some(pending_block)) = this.pending_flashblock() { let block_and_receipts = pending_block.into_block_and_receipts(); - if block_and_receipts.block.body().contains_transaction(&hash) { - if let Some(receipt) = this.transaction_receipt(hash).await? { + if block_and_receipts.block.body().contains_transaction(&hash) + && let Some(receipt) = this.transaction_receipt(hash).await? { return Ok(receipt); } - } } } } diff --git a/crates/payload/basic/src/lib.rs b/crates/payload/basic/src/lib.rs index fa55a63134..b60640abe4 100644 --- a/crates/payload/basic/src/lib.rs +++ b/crates/payload/basic/src/lib.rs @@ -587,15 +587,15 @@ where let this = self.get_mut(); // check if there is a better payload before returning the best payload - if let Some(fut) = Pin::new(&mut this.maybe_better).as_pin_mut() { - if let Poll::Ready(res) = fut.poll(cx) { - this.maybe_better = None; - if let Ok(Some(payload)) = res.map(|out| out.into_payload()) - .inspect_err(|err| warn!(target: "payload_builder", %err, "failed to resolve pending payload")) - { - debug!(target: "payload_builder", "resolving better payload"); - return Poll::Ready(Ok(payload)) - } + if let Some(fut) = Pin::new(&mut this.maybe_better).as_pin_mut() && + let Poll::Ready(res) = fut.poll(cx) + { + this.maybe_better = None; + if let Ok(Some(payload)) = res.map(|out| out.into_payload()).inspect_err( + |err| warn!(target: "payload_builder", %err, "failed to resolve pending payload"), + ) { + debug!(target: "payload_builder", "resolving better payload"); + return Poll::Ready(Ok(payload)) } } @@ -604,20 +604,20 @@ where return Poll::Ready(Ok(best)) } - if let Some(fut) = Pin::new(&mut this.empty_payload).as_pin_mut() { - if let Poll::Ready(res) = fut.poll(cx) { - this.empty_payload = None; - return match res { - Ok(res) => { - if let Err(err) = &res { - warn!(target: "payload_builder", %err, "failed to resolve empty payload"); - } else { - debug!(target: "payload_builder", "resolving empty payload"); - } - Poll::Ready(res) + if let Some(fut) = Pin::new(&mut this.empty_payload).as_pin_mut() && + let Poll::Ready(res) = fut.poll(cx) + { + this.empty_payload = None; + return match res { + Ok(res) => { + if let Err(err) = &res { + warn!(target: "payload_builder", %err, "failed to resolve empty payload"); + } else { + debug!(target: "payload_builder", "resolving empty payload"); } - Err(err) => Poll::Ready(Err(err.into())), + Poll::Ready(res) } + Err(err) => Poll::Ready(Err(err.into())), } } diff --git a/crates/payload/builder/src/service.rs b/crates/payload/builder/src/service.rs index 0c5bb1a5cc..f9530d003f 100644 --- a/crates/payload/builder/src/service.rs +++ b/crates/payload/builder/src/service.rs @@ -305,10 +305,10 @@ where ) -> Option> { debug!(target: "payload_builder", %id, "resolving payload job"); - if let Some((cached, _, payload)) = &*self.cached_payload_rx.borrow() { - if *cached == id { - return Some(Box::pin(core::future::ready(Ok(payload.clone())))); - } + if let Some((cached, _, payload)) = &*self.cached_payload_rx.borrow() && + *cached == id + { + return Some(Box::pin(core::future::ready(Ok(payload.clone())))); } let job = self.payload_jobs.iter().position(|(_, job_id)| *job_id == id)?; @@ -356,10 +356,10 @@ where { /// Returns the payload timestamp for the given payload. fn payload_timestamp(&self, id: PayloadId) -> Option> { - if let Some((cached_id, timestamp, _)) = *self.cached_payload_rx.borrow() { - if cached_id == id { - return Some(Ok(timestamp)); - } + if let Some((cached_id, timestamp, _)) = *self.cached_payload_rx.borrow() && + cached_id == id + { + return Some(Ok(timestamp)); } let timestamp = self diff --git a/crates/prune/prune/src/segments/user/transaction_lookup.rs b/crates/prune/prune/src/segments/user/transaction_lookup.rs index 478a9c4534..dcf7c195d9 100644 --- a/crates/prune/prune/src/segments/user/transaction_lookup.rs +++ b/crates/prune/prune/src/segments/user/transaction_lookup.rs @@ -48,18 +48,17 @@ where // data. If the TransactionLookup checkpoint is lagging behind (which can happen e.g. when // pre-merge history is dropped and then later tx lookup pruning is enabled) then we can // only prune from the tx checkpoint and onwards. - if let Some(txs_checkpoint) = provider.get_prune_checkpoint(PruneSegment::Transactions)? { - if input + if let Some(txs_checkpoint) = provider.get_prune_checkpoint(PruneSegment::Transactions)? && + input .previous_checkpoint .is_none_or(|checkpoint| checkpoint.block_number < txs_checkpoint.block_number) - { - input.previous_checkpoint = Some(txs_checkpoint); - debug!( - target: "pruner", - transactions_checkpoint = ?input.previous_checkpoint, - "No TransactionLookup checkpoint found, using Transactions checkpoint as fallback" - ); - } + { + input.previous_checkpoint = Some(txs_checkpoint); + debug!( + target: "pruner", + transactions_checkpoint = ?input.previous_checkpoint, + "No TransactionLookup checkpoint found, using Transactions checkpoint as fallback" + ); } let (start, end) = match input.get_next_tx_num_range(provider)? { diff --git a/crates/prune/types/src/lib.rs b/crates/prune/types/src/lib.rs index c1d268a0fb..639d3bde92 100644 --- a/crates/prune/types/src/lib.rs +++ b/crates/prune/types/src/lib.rs @@ -96,12 +96,11 @@ impl ReceiptsLogPruneConfig { let mut lowest = None; for mode in self.values() { - if mode.is_distance() { - if let Some((block, _)) = + if mode.is_distance() && + let Some((block, _)) = mode.prune_target_block(tip, PruneSegment::ContractLogs, PrunePurpose::User)? - { - lowest = Some(lowest.unwrap_or(u64::MAX).min(block)); - } + { + lowest = Some(lowest.unwrap_or(u64::MAX).min(block)); } } diff --git a/crates/ress/provider/src/lib.rs b/crates/ress/provider/src/lib.rs index 41318ebaaf..c157b5adf4 100644 --- a/crates/ress/provider/src/lib.rs +++ b/crates/ress/provider/src/lib.rs @@ -120,19 +120,15 @@ where let mut executed = self.pending_state.executed_block(&ancestor_hash); // If it's not present, attempt to lookup invalid block. - if executed.is_none() { - if let Some(invalid) = + if executed.is_none() && + let Some(invalid) = self.pending_state.invalid_recovered_block(&ancestor_hash) - { - trace!(target: "reth::ress_provider", %block_hash, %ancestor_hash, "Using invalid ancestor block for witness construction"); - executed = Some(ExecutedBlockWithTrieUpdates { - block: ExecutedBlock { - recovered_block: invalid, - ..Default::default() - }, - trie: ExecutedTrieUpdates::empty(), - }); - } + { + trace!(target: "reth::ress_provider", %block_hash, %ancestor_hash, "Using invalid ancestor block for witness construction"); + executed = Some(ExecutedBlockWithTrieUpdates { + block: ExecutedBlock { recovered_block: invalid, ..Default::default() }, + trie: ExecutedTrieUpdates::empty(), + }); } let Some(executed) = executed else { diff --git a/crates/rpc/ipc/src/server/mod.rs b/crates/rpc/ipc/src/server/mod.rs index ece2eef780..b6114938d2 100644 --- a/crates/rpc/ipc/src/server/mod.rs +++ b/crates/rpc/ipc/src/server/mod.rs @@ -144,11 +144,11 @@ where { // set permissions only on unix use std::os::unix::fs::PermissionsExt; - if let Some(perms_str) = &self.cfg.ipc_socket_permissions { - if let Ok(mode) = u32::from_str_radix(&perms_str.replace("0o", ""), 8) { - let perms = std::fs::Permissions::from_mode(mode); - let _ = std::fs::set_permissions(&self.endpoint, perms); - } + if let Some(perms_str) = &self.cfg.ipc_socket_permissions && + let Ok(mode) = u32::from_str_radix(&perms_str.replace("0o", ""), 8) + { + let perms = std::fs::Permissions::from_mode(mode); + let _ = std::fs::set_permissions(&self.endpoint, perms); } } listener diff --git a/crates/rpc/rpc-engine-api/src/engine_api.rs b/crates/rpc/rpc-engine-api/src/engine_api.rs index 2dc42e9a1b..1654519912 100644 --- a/crates/rpc/rpc-engine-api/src/engine_api.rs +++ b/crates/rpc/rpc-engine-api/src/engine_api.rs @@ -572,11 +572,10 @@ where // > Client software MUST NOT return trailing null values if the request extends past the current latest known block. // truncate the end if it's greater than the last block - if let Ok(best_block) = inner.provider.best_block_number() { - if end > best_block { + if let Ok(best_block) = inner.provider.best_block_number() + && end > best_block { end = best_block; } - } for num in start..=end { let block_result = inner.provider.block(BlockHashOrNumber::Number(num)); diff --git a/crates/rpc/rpc-eth-api/src/helpers/block.rs b/crates/rpc/rpc-eth-api/src/helpers/block.rs index dcb28c7e8a..17e4b000b3 100644 --- a/crates/rpc/rpc-eth-api/src/helpers/block.rs +++ b/crates/rpc/rpc-eth-api/src/helpers/block.rs @@ -195,16 +195,14 @@ pub trait EthBlocks: } if let Some(block_hash) = - self.provider().block_hash_for_id(block_id).map_err(Self::Error::from_eth_err)? - { - if let Some((block, receipts)) = self + self.provider().block_hash_for_id(block_id).map_err(Self::Error::from_eth_err)? && + let Some((block, receipts)) = self .cache() .get_block_and_receipts(block_hash) .await .map_err(Self::Error::from_eth_err)? - { - return Ok(Some((block, receipts))); - } + { + return Ok(Some((block, receipts))); } Ok(None) diff --git a/crates/rpc/rpc-eth-api/src/helpers/call.rs b/crates/rpc/rpc-eth-api/src/helpers/call.rs index fda12c12cb..78a3e984e4 100644 --- a/crates/rpc/rpc-eth-api/src/helpers/call.rs +++ b/crates/rpc/rpc-eth-api/src/helpers/call.rs @@ -122,14 +122,11 @@ pub trait EthCall: EstimateCall + Call + LoadPendingBlock + LoadBlock + FullEthA if let Some(block_overrides) = block_overrides { // ensure we don't allow uncapped gas limit per block - if let Some(gas_limit_override) = block_overrides.gas_limit { - if gas_limit_override > evm_env.block_env.gas_limit && - gas_limit_override > this.call_gas_limit() - { - return Err( - EthApiError::other(EthSimulateError::GasLimitReached).into() - ) - } + if let Some(gas_limit_override) = block_overrides.gas_limit && + gas_limit_override > evm_env.block_env.gas_limit && + gas_limit_override > this.call_gas_limit() + { + return Err(EthApiError::other(EthSimulateError::GasLimitReached).into()) } apply_block_overrides(block_overrides, &mut db, &mut evm_env.block_env); } diff --git a/crates/rpc/rpc-eth-api/src/helpers/config.rs b/crates/rpc/rpc-eth-api/src/helpers/config.rs index 3d65336cff..19a6e9c379 100644 --- a/crates/rpc/rpc-eth-api/src/helpers/config.rs +++ b/crates/rpc/rpc-eth-api/src/helpers/config.rs @@ -115,19 +115,19 @@ where let mut config = EthConfig { current, next: None, last: None }; - if let Some(last_fork_idx) = current_fork_idx.checked_sub(1) { - if let Some(last_fork_timestamp) = fork_timestamps.get(last_fork_idx).copied() { - let fake_header = { - let mut header = latest.clone(); - header.timestamp = last_fork_timestamp; - header - }; - let last_precompiles = evm_to_precompiles_map( - self.evm_config.evm_for_block(EmptyDB::default(), &fake_header), - ); + if let Some(last_fork_idx) = current_fork_idx.checked_sub(1) && + let Some(last_fork_timestamp) = fork_timestamps.get(last_fork_idx).copied() + { + let fake_header = { + let mut header = latest.clone(); + header.timestamp = last_fork_timestamp; + header + }; + let last_precompiles = evm_to_precompiles_map( + self.evm_config.evm_for_block(EmptyDB::default(), &fake_header), + ); - config.last = self.build_fork_config_at(last_fork_timestamp, last_precompiles); - } + config.last = self.build_fork_config_at(last_fork_timestamp, last_precompiles); } if let Some(next_fork_timestamp) = fork_timestamps.get(current_fork_idx + 1).copied() { diff --git a/crates/rpc/rpc-eth-api/src/helpers/estimate.rs b/crates/rpc/rpc-eth-api/src/helpers/estimate.rs index 65f41ce938..cca674e973 100644 --- a/crates/rpc/rpc-eth-api/src/helpers/estimate.rs +++ b/crates/rpc/rpc-eth-api/src/helpers/estimate.rs @@ -88,14 +88,14 @@ pub trait EstimateCall: Call { let mut tx_env = self.create_txn_env(&evm_env, request, &mut db)?; // Check if this is a basic transfer (no input data to account with no code) - let mut is_basic_transfer = false; - if tx_env.input().is_empty() { - if let TxKind::Call(to) = tx_env.kind() { - if let Ok(code) = db.db.account_code(&to) { - is_basic_transfer = code.map(|code| code.is_empty()).unwrap_or(true); - } - } - } + let is_basic_transfer = if tx_env.input().is_empty() && + let TxKind::Call(to) = tx_env.kind() && + let Ok(code) = db.db.account_code(&to) + { + code.map(|code| code.is_empty()).unwrap_or(true) + } else { + false + }; // Check funds of the sender (only useful to check if transaction gas price is more than 0). // @@ -123,10 +123,10 @@ pub trait EstimateCall: Call { min_tx_env.set_gas_limit(MIN_TRANSACTION_GAS); // Reuse the same EVM instance - if let Ok(res) = evm.transact(min_tx_env).map_err(Self::Error::from_evm_err) { - if res.result.is_success() { - return Ok(U256::from(MIN_TRANSACTION_GAS)) - } + if let Ok(res) = evm.transact(min_tx_env).map_err(Self::Error::from_evm_err) && + res.result.is_success() + { + return Ok(U256::from(MIN_TRANSACTION_GAS)) } } diff --git a/crates/rpc/rpc-eth-api/src/helpers/fee.rs b/crates/rpc/rpc-eth-api/src/helpers/fee.rs index ae558d4055..b0d736981c 100644 --- a/crates/rpc/rpc-eth-api/src/helpers/fee.rs +++ b/crates/rpc/rpc-eth-api/src/helpers/fee.rs @@ -109,10 +109,10 @@ pub trait EthFees: // need to validate that they are monotonically // increasing and 0 <= p <= 100 // Note: The types used ensure that the percentiles are never < 0 - if let Some(percentiles) = &reward_percentiles { - if percentiles.windows(2).any(|w| w[0] > w[1] || w[0] > 100.) { - return Err(EthApiError::InvalidRewardPercentiles.into()) - } + if let Some(percentiles) = &reward_percentiles && + percentiles.windows(2).any(|w| w[0] > w[1] || w[0] > 100.) + { + return Err(EthApiError::InvalidRewardPercentiles.into()) } // Fetch the headers and ensure we got all of them diff --git a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs index bfcb8a7fa5..75c5004f2b 100644 --- a/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs +++ b/crates/rpc/rpc-eth-api/src/helpers/pending_block.rs @@ -72,22 +72,21 @@ pub trait LoadPendingBlock: >, Self::Error, > { - if let Some(block) = self.provider().pending_block().map_err(Self::Error::from_eth_err)? { - if let Some(receipts) = self + if let Some(block) = self.provider().pending_block().map_err(Self::Error::from_eth_err)? && + let Some(receipts) = self .provider() .receipts_by_block(block.hash().into()) .map_err(Self::Error::from_eth_err)? - { - // Note: for the PENDING block we assume it is past the known merge block and - // thus this will not fail when looking up the total - // difficulty value for the blockenv. - let evm_env = self.evm_config().evm_env(block.header()); + { + // Note: for the PENDING block we assume it is past the known merge block and + // thus this will not fail when looking up the total + // difficulty value for the blockenv. + let evm_env = self.evm_config().evm_env(block.header()); - return Ok(PendingBlockEnv::new( - evm_env, - PendingBlockEnvOrigin::ActualPending(Arc::new(block), Arc::new(receipts)), - )); - } + return Ok(PendingBlockEnv::new( + evm_env, + PendingBlockEnvOrigin::ActualPending(Arc::new(block), Arc::new(receipts)), + )); } // no pending block from the CL yet, so we use the latest block and modify the env @@ -309,21 +308,21 @@ pub trait LoadPendingBlock: // There's only limited amount of blob space available per block, so we need to // check if the EIP-4844 can still fit in the block - if let Some(tx_blob_gas) = tx.blob_gas_used() { - if sum_blob_gas_used + tx_blob_gas > blob_params.max_blob_gas_per_block() { - // we can't fit this _blob_ transaction into the block, so we mark it as - // invalid, which removes its dependent transactions from - // the iterator. This is similar to the gas limit condition - // for regular transactions above. - best_txs.mark_invalid( - &pool_tx, - InvalidPoolTransactionError::ExceedsGasLimit( - tx_blob_gas, - blob_params.max_blob_gas_per_block(), - ), - ); - continue - } + if let Some(tx_blob_gas) = tx.blob_gas_used() && + sum_blob_gas_used + tx_blob_gas > blob_params.max_blob_gas_per_block() + { + // we can't fit this _blob_ transaction into the block, so we mark it as + // invalid, which removes its dependent transactions from + // the iterator. This is similar to the gas limit condition + // for regular transactions above. + best_txs.mark_invalid( + &pool_tx, + InvalidPoolTransactionError::ExceedsGasLimit( + tx_blob_gas, + blob_params.max_blob_gas_per_block(), + ), + ); + continue } let gas_used = match builder.execute_transaction(tx.clone()) { diff --git a/crates/rpc/rpc-eth-api/src/helpers/state.rs b/crates/rpc/rpc-eth-api/src/helpers/state.rs index eab08450c8..82fac70512 100644 --- a/crates/rpc/rpc-eth-api/src/helpers/state.rs +++ b/crates/rpc/rpc-eth-api/src/helpers/state.rs @@ -221,10 +221,10 @@ pub trait LoadState: Self: SpawnBlocking, { async move { - if at.is_pending() { - if let Ok(Some(state)) = self.local_pending_state().await { - return Ok(state) - } + if at.is_pending() && + let Ok(Some(state)) = self.local_pending_state().await + { + return Ok(state) } self.provider().state_by_block_id(at).map_err(Self::Error::from_eth_err) diff --git a/crates/rpc/rpc-eth-api/src/helpers/transaction.rs b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs index c9fa6a0431..6d3615f865 100644 --- a/crates/rpc/rpc-eth-api/src/helpers/transaction.rs +++ b/crates/rpc/rpc-eth-api/src/helpers/transaction.rs @@ -92,10 +92,10 @@ pub trait EthTransactions: LoadTransaction { while let Some(notification) = stream.next().await { let chain = notification.committed(); for block in chain.blocks_iter() { - if block.body().contains_transaction(&hash) { - if let Some(receipt) = this.transaction_receipt(hash).await? { - return Ok(receipt); - } + if block.body().contains_transaction(&hash) && + let Some(receipt) = this.transaction_receipt(hash).await? + { + return Ok(receipt); } } } @@ -294,13 +294,12 @@ pub trait EthTransactions: LoadTransaction { { async move { // Check the pool first - if include_pending { - if let Some(tx) = + if include_pending && + let Some(tx) = RpcNodeCore::pool(self).get_transaction_by_sender_and_nonce(sender, nonce) - { - let transaction = tx.transaction.clone_into_consensus(); - return Ok(Some(self.tx_resp_builder().fill_pending(transaction)?)); - } + { + let transaction = tx.transaction.clone_into_consensus(); + return Ok(Some(self.tx_resp_builder().fill_pending(transaction)?)); } // Check if the sender is a contract @@ -370,10 +369,10 @@ pub trait EthTransactions: LoadTransaction { Self: LoadBlock, { async move { - if let Some(block) = self.recovered_block(block_id).await? { - if let Some(tx) = block.body().transactions().get(index) { - return Ok(Some(tx.encoded_2718().into())) - } + if let Some(block) = self.recovered_block(block_id).await? && + let Some(tx) = block.body().transactions().get(index) + { + return Ok(Some(tx.encoded_2718().into())) } Ok(None) diff --git a/crates/rpc/rpc-eth-types/src/cache/multi_consumer.rs b/crates/rpc/rpc-eth-types/src/cache/multi_consumer.rs index bae39c78f0..dec5dcb09a 100644 --- a/crates/rpc/rpc-eth-types/src/cache/multi_consumer.rs +++ b/crates/rpc/rpc-eth-types/src/cache/multi_consumer.rs @@ -100,11 +100,11 @@ where { let size = value.size(); - if self.cache.limiter().is_over_the_limit(self.cache.len() + 1) { - if let Some((_, evicted)) = self.cache.pop_oldest() { - // update tracked memory with the evicted value - self.memory_usage = self.memory_usage.saturating_sub(evicted.size()); - } + if self.cache.limiter().is_over_the_limit(self.cache.len() + 1) && + let Some((_, evicted)) = self.cache.pop_oldest() + { + // update tracked memory with the evicted value + self.memory_usage = self.memory_usage.saturating_sub(evicted.size()); } if self.cache.insert(key, value) { diff --git a/crates/rpc/rpc-eth-types/src/fee_history.rs b/crates/rpc/rpc-eth-types/src/fee_history.rs index dd27fbfd10..3eaf69d2c4 100644 --- a/crates/rpc/rpc-eth-types/src/fee_history.rs +++ b/crates/rpc/rpc-eth-types/src/fee_history.rs @@ -234,13 +234,13 @@ pub async fn fee_history_cache_new_blocks_task( let mut fetch_missing_block = Fuse::terminated(); loop { - if fetch_missing_block.is_terminated() { - if let Some(block_number) = missing_blocks.pop_front() { - trace!(target: "rpc::fee", ?block_number, "Fetching missing block for fee history cache"); - if let Ok(Some(hash)) = provider.block_hash(block_number) { - // fetch missing block - fetch_missing_block = cache.get_block_and_receipts(hash).boxed().fuse(); - } + if fetch_missing_block.is_terminated() && + let Some(block_number) = missing_blocks.pop_front() + { + trace!(target: "rpc::fee", ?block_number, "Fetching missing block for fee history cache"); + if let Ok(Some(hash)) = provider.block_hash(block_number) { + // fetch missing block + fetch_missing_block = cache.get_block_and_receipts(hash).boxed().fuse(); } } diff --git a/crates/rpc/rpc-eth-types/src/gas_oracle.rs b/crates/rpc/rpc-eth-types/src/gas_oracle.rs index 95eca0ffd1..7bbf6433c6 100644 --- a/crates/rpc/rpc-eth-types/src/gas_oracle.rs +++ b/crates/rpc/rpc-eth-types/src/gas_oracle.rs @@ -204,10 +204,10 @@ where }; // constrain to the max price - if let Some(max_price) = self.oracle_config.max_price { - if price > max_price { - price = max_price; - } + if let Some(max_price) = self.oracle_config.max_price && + price > max_price + { + price = max_price; } inner.last_price = GasPriceOracleResult { block_hash: header.hash(), price }; @@ -254,10 +254,10 @@ where }; // ignore transactions with a tip under the configured threshold - if let Some(ignore_under) = self.ignore_price { - if effective_tip < Some(ignore_under) { - continue - } + if let Some(ignore_under) = self.ignore_price && + effective_tip < Some(ignore_under) + { + continue } // check if the sender was the coinbase, if so, ignore @@ -338,10 +338,10 @@ where } // constrain to the max price - if let Some(max_price) = self.oracle_config.max_price { - if suggestion > max_price { - suggestion = max_price; - } + if let Some(max_price) = self.oracle_config.max_price && + suggestion > max_price + { + suggestion = max_price; } inner.last_price = GasPriceOracleResult { block_hash: header.hash(), price: suggestion }; diff --git a/crates/rpc/rpc/src/eth/filter.rs b/crates/rpc/rpc/src/eth/filter.rs index b9c168e148..01b6a94158 100644 --- a/crates/rpc/rpc/src/eth/filter.rs +++ b/crates/rpc/rpc/src/eth/filter.rs @@ -501,11 +501,11 @@ where .transpose()? .flatten(); - if let Some(f) = from { - if f > info.best_number { - // start block higher than local head, can return empty - return Ok(Vec::new()); - } + if let Some(f) = from && + f > info.best_number + { + // start block higher than local head, can return empty + return Ok(Vec::new()); } let (from_block_number, to_block_number) = @@ -658,22 +658,23 @@ where // size check but only if range is multiple blocks, so we always return all // logs of a single block let is_multi_block_range = from_block != to_block; - if let Some(max_logs_per_response) = limits.max_logs_per_response { - if is_multi_block_range && all_logs.len() > max_logs_per_response { - debug!( - target: "rpc::eth::filter", - logs_found = all_logs.len(), - max_logs_per_response, - from_block, - to_block = num_hash.number.saturating_sub(1), - "Query exceeded max logs per response limit" - ); - return Err(EthFilterError::QueryExceedsMaxResults { - max_logs: max_logs_per_response, - from_block, - to_block: num_hash.number.saturating_sub(1), - }); - } + if let Some(max_logs_per_response) = limits.max_logs_per_response && + is_multi_block_range && + all_logs.len() > max_logs_per_response + { + debug!( + target: "rpc::eth::filter", + logs_found = all_logs.len(), + max_logs_per_response, + from_block, + to_block = num_hash.number.saturating_sub(1), + "Query exceeded max logs per response limit" + ); + return Err(EthFilterError::QueryExceedsMaxResults { + max_logs: max_logs_per_response, + from_block, + to_block: num_hash.number.saturating_sub(1), + }); } } diff --git a/crates/rpc/rpc/src/trace.rs b/crates/rpc/rpc/src/trace.rs index 445ee97684..4ed42bc721 100644 --- a/crates/rpc/rpc/src/trace.rs +++ b/crates/rpc/rpc/src/trace.rs @@ -490,14 +490,14 @@ where let mut maybe_traces = maybe_traces.map(|traces| traces.into_iter().flatten().collect::>()); - if let (Some(block), Some(traces)) = (maybe_block, maybe_traces.as_mut()) { - if let Some(base_block_reward) = self.calculate_base_block_reward(block.header())? { - traces.extend(self.extract_reward_traces( - block.header(), - block.body().ommers(), - base_block_reward, - )); - } + if let (Some(block), Some(traces)) = (maybe_block, maybe_traces.as_mut()) && + let Some(base_block_reward) = self.calculate_base_block_reward(block.header())? + { + traces.extend(self.extract_reward_traces( + block.header(), + block.body().ommers(), + base_block_reward, + )); } Ok(maybe_traces) diff --git a/crates/rpc/rpc/src/validation.rs b/crates/rpc/rpc/src/validation.rs index 6f7988dda8..d03846a427 100644 --- a/crates/rpc/rpc/src/validation.rs +++ b/crates/rpc/rpc/src/validation.rs @@ -143,10 +143,10 @@ where if self.disallow.contains(sender) { return Err(ValidationApiError::Blacklist(*sender)) } - if let Some(to) = tx.to() { - if self.disallow.contains(&to) { - return Err(ValidationApiError::Blacklist(to)) - } + if let Some(to) = tx.to() && + self.disallow.contains(&to) + { + return Err(ValidationApiError::Blacklist(to)) } } } @@ -334,10 +334,10 @@ where return Err(ValidationApiError::ProposerPayment) } - if let Some(block_base_fee) = block.header().base_fee_per_gas() { - if tx.effective_tip_per_gas(block_base_fee).unwrap_or_default() != 0 { - return Err(ValidationApiError::ProposerPayment) - } + if let Some(block_base_fee) = block.header().base_fee_per_gas() && + tx.effective_tip_per_gas(block_base_fee).unwrap_or_default() != 0 + { + return Err(ValidationApiError::ProposerPayment) } Ok(()) diff --git a/crates/stages/api/src/pipeline/set.rs b/crates/stages/api/src/pipeline/set.rs index 8aea87ba03..c39dafae99 100644 --- a/crates/stages/api/src/pipeline/set.rs +++ b/crates/stages/api/src/pipeline/set.rs @@ -73,16 +73,15 @@ impl StageSetBuilder { fn upsert_stage_state(&mut self, stage: Box>, added_at_index: usize) { let stage_id = stage.id(); - if self.stages.insert(stage.id(), StageEntry { stage, enabled: true }).is_some() { - if let Some(to_remove) = self + if self.stages.insert(stage.id(), StageEntry { stage, enabled: true }).is_some() && + let Some(to_remove) = self .order .iter() .enumerate() .find(|(i, id)| *i != added_at_index && **id == stage_id) .map(|(i, _)| i) - { - self.order.remove(to_remove); - } + { + self.order.remove(to_remove); } } @@ -264,10 +263,10 @@ impl StageSetBuilder { pub fn build(mut self) -> Vec>> { let mut stages = Vec::new(); for id in &self.order { - if let Some(entry) = self.stages.remove(id) { - if entry.enabled { - stages.push(entry.stage); - } + if let Some(entry) = self.stages.remove(id) && + entry.enabled + { + stages.push(entry.stage); } } stages diff --git a/crates/stages/stages/src/stages/bodies.rs b/crates/stages/stages/src/stages/bodies.rs index e503d8b5d5..4eca51d00a 100644 --- a/crates/stages/stages/src/stages/bodies.rs +++ b/crates/stages/stages/src/stages/bodies.rs @@ -702,11 +702,10 @@ mod tests { // Validate sequentiality only after prev progress, // since the data before is mocked and can contain gaps - if number > prev_progress { - if let Some(prev_key) = prev_number { + if number > prev_progress + && let Some(prev_key) = prev_number { assert_eq!(prev_key + 1, number, "Body entries must be sequential"); } - } // Validate that the current entry is below or equals to the highest allowed block assert!( diff --git a/crates/stages/stages/src/stages/era.rs b/crates/stages/stages/src/stages/era.rs index 561afde279..436ee76965 100644 --- a/crates/stages/stages/src/stages/era.rs +++ b/crates/stages/stages/src/stages/era.rs @@ -150,18 +150,17 @@ where return Poll::Ready(Ok(())); } - if self.stream.is_none() { - if let Some(source) = self.source.clone() { - self.stream.replace(source.create(input)?); - } + if self.stream.is_none() && + let Some(source) = self.source.clone() + { + self.stream.replace(source.create(input)?); } - if let Some(stream) = &mut self.stream { - if let Some(next) = ready!(stream.poll_next_unpin(cx)) + if let Some(stream) = &mut self.stream && + let Some(next) = ready!(stream.poll_next_unpin(cx)) .transpose() .map_err(|e| StageError::Fatal(e.into()))? - { - self.item.replace(next); - } + { + self.item.replace(next); } Poll::Ready(Ok(())) @@ -546,11 +545,10 @@ mod tests { // Validate sequentiality only after prev progress, // since the data before is mocked and can contain gaps - if number > prev_progress { - if let Some(prev_key) = prev_number { + if number > prev_progress + && let Some(prev_key) = prev_number { assert_eq!(prev_key + 1, number, "Body entries must be sequential"); } - } // Validate that the current entry is below or equals to the highest allowed block assert!( diff --git a/crates/stages/stages/src/stages/headers.rs b/crates/stages/stages/src/stages/headers.rs index 0c3b21c2d6..9147ebb844 100644 --- a/crates/stages/stages/src/stages/headers.rs +++ b/crates/stages/stages/src/stages/headers.rs @@ -145,19 +145,18 @@ where let mut cursor_header_numbers = provider.tx_ref().cursor_write::>()?; - let mut first_sync = false; - // If we only have the genesis block hash, then we are at first sync, and we can remove it, // add it to the collector and use tx.append on all hashes. - if provider.tx_ref().entries::>()? == 1 { - if let Some((hash, block_number)) = cursor_header_numbers.last()? { - if block_number.value()? == 0 { - self.hash_collector.insert(hash.key()?, 0)?; - cursor_header_numbers.delete_current()?; - first_sync = true; - } - } - } + let first_sync = if provider.tx_ref().entries::>()? == 1 && + let Some((hash, block_number)) = cursor_header_numbers.last()? && + block_number.value()? == 0 + { + self.hash_collector.insert(hash.key()?, 0)?; + cursor_header_numbers.delete_current()?; + true + } else { + false + }; // Since ETL sorts all entries by hashes, we are either appending (first sync) or inserting // in order (further syncs). diff --git a/crates/stages/stages/src/stages/index_account_history.rs b/crates/stages/stages/src/stages/index_account_history.rs index 37db4f5f9f..c8d6464cf3 100644 --- a/crates/stages/stages/src/stages/index_account_history.rs +++ b/crates/stages/stages/src/stages/index_account_history.rs @@ -67,23 +67,22 @@ where ) }) .transpose()? - .flatten() + .flatten() && + target_prunable_block > input.checkpoint().block_number { - if target_prunable_block > input.checkpoint().block_number { - input.checkpoint = Some(StageCheckpoint::new(target_prunable_block)); + input.checkpoint = Some(StageCheckpoint::new(target_prunable_block)); - // Save prune checkpoint only if we don't have one already. - // Otherwise, pruner may skip the unpruned range of blocks. - if provider.get_prune_checkpoint(PruneSegment::AccountHistory)?.is_none() { - provider.save_prune_checkpoint( - PruneSegment::AccountHistory, - PruneCheckpoint { - block_number: Some(target_prunable_block), - tx_number: None, - prune_mode, - }, - )?; - } + // Save prune checkpoint only if we don't have one already. + // Otherwise, pruner may skip the unpruned range of blocks. + if provider.get_prune_checkpoint(PruneSegment::AccountHistory)?.is_none() { + provider.save_prune_checkpoint( + PruneSegment::AccountHistory, + PruneCheckpoint { + block_number: Some(target_prunable_block), + tx_number: None, + prune_mode, + }, + )?; } } diff --git a/crates/stages/stages/src/stages/index_storage_history.rs b/crates/stages/stages/src/stages/index_storage_history.rs index 09c9030cb3..2ec4094c1e 100644 --- a/crates/stages/stages/src/stages/index_storage_history.rs +++ b/crates/stages/stages/src/stages/index_storage_history.rs @@ -70,23 +70,22 @@ where ) }) .transpose()? - .flatten() + .flatten() && + target_prunable_block > input.checkpoint().block_number { - if target_prunable_block > input.checkpoint().block_number { - input.checkpoint = Some(StageCheckpoint::new(target_prunable_block)); + input.checkpoint = Some(StageCheckpoint::new(target_prunable_block)); - // Save prune checkpoint only if we don't have one already. - // Otherwise, pruner may skip the unpruned range of blocks. - if provider.get_prune_checkpoint(PruneSegment::StorageHistory)?.is_none() { - provider.save_prune_checkpoint( - PruneSegment::StorageHistory, - PruneCheckpoint { - block_number: Some(target_prunable_block), - tx_number: None, - prune_mode, - }, - )?; - } + // Save prune checkpoint only if we don't have one already. + // Otherwise, pruner may skip the unpruned range of blocks. + if provider.get_prune_checkpoint(PruneSegment::StorageHistory)?.is_none() { + provider.save_prune_checkpoint( + PruneSegment::StorageHistory, + PruneCheckpoint { + block_number: Some(target_prunable_block), + tx_number: None, + prune_mode, + }, + )?; } } diff --git a/crates/stages/stages/src/stages/tx_lookup.rs b/crates/stages/stages/src/stages/tx_lookup.rs index 84dae25167..20a0770d8c 100644 --- a/crates/stages/stages/src/stages/tx_lookup.rs +++ b/crates/stages/stages/src/stages/tx_lookup.rs @@ -88,28 +88,27 @@ where ) }) .transpose()? - .flatten() + .flatten() && + target_prunable_block > input.checkpoint().block_number { - if target_prunable_block > input.checkpoint().block_number { - input.checkpoint = Some(StageCheckpoint::new(target_prunable_block)); + input.checkpoint = Some(StageCheckpoint::new(target_prunable_block)); - // Save prune checkpoint only if we don't have one already. - // Otherwise, pruner may skip the unpruned range of blocks. - if provider.get_prune_checkpoint(PruneSegment::TransactionLookup)?.is_none() { - let target_prunable_tx_number = provider - .block_body_indices(target_prunable_block)? - .ok_or(ProviderError::BlockBodyIndicesNotFound(target_prunable_block))? - .last_tx_num(); + // Save prune checkpoint only if we don't have one already. + // Otherwise, pruner may skip the unpruned range of blocks. + if provider.get_prune_checkpoint(PruneSegment::TransactionLookup)?.is_none() { + let target_prunable_tx_number = provider + .block_body_indices(target_prunable_block)? + .ok_or(ProviderError::BlockBodyIndicesNotFound(target_prunable_block))? + .last_tx_num(); - provider.save_prune_checkpoint( - PruneSegment::TransactionLookup, - PruneCheckpoint { - block_number: Some(target_prunable_block), - tx_number: Some(target_prunable_tx_number), - prune_mode, - }, - )?; - } + provider.save_prune_checkpoint( + PruneSegment::TransactionLookup, + PruneCheckpoint { + block_number: Some(target_prunable_block), + tx_number: Some(target_prunable_tx_number), + prune_mode, + }, + )?; } } if input.target_reached() { @@ -213,10 +212,10 @@ where // Delete all transactions that belong to this block for tx_id in body.tx_num_range() { // First delete the transaction and hash to id mapping - if let Some(transaction) = static_file_provider.transaction_by_id(tx_id)? { - if tx_hash_number_cursor.seek_exact(transaction.trie_hash())?.is_some() { - tx_hash_number_cursor.delete_current()?; - } + if let Some(transaction) = static_file_provider.transaction_by_id(tx_id)? && + tx_hash_number_cursor.seek_exact(transaction.trie_hash())?.is_some() + { + tx_hash_number_cursor.delete_current()?; } } } @@ -538,11 +537,10 @@ mod tests { }) .transpose() .expect("prune target block for transaction lookup") - .flatten() + .flatten() && + target_prunable_block > input.checkpoint().block_number { - if target_prunable_block > input.checkpoint().block_number { - input.checkpoint = Some(StageCheckpoint::new(target_prunable_block)); - } + input.checkpoint = Some(StageCheckpoint::new(target_prunable_block)); } let start_block = input.next_block(); let end_block = output.checkpoint.block_number; diff --git a/crates/stages/stages/src/stages/utils.rs b/crates/stages/stages/src/stages/utils.rs index 55d59606a2..f4bb960e7a 100644 --- a/crates/stages/stages/src/stages/utils.rs +++ b/crates/stages/stages/src/stages/utils.rs @@ -156,12 +156,11 @@ where // If it's not the first sync, there might an existing shard already, so we need to // merge it with the one coming from the collector - if !append_only { - if let Some((_, last_database_shard)) = + if !append_only && + let Some((_, last_database_shard)) = write_cursor.seek_exact(sharded_key_factory(current_partial, u64::MAX))? - { - current_list.extend(last_database_shard.iter()); - } + { + current_list.extend(last_database_shard.iter()); } } @@ -265,10 +264,10 @@ where // To be extra safe, we make sure that the last tx num matches the last block from its indices. // If not, get it. loop { - if let Some(indices) = provider.block_body_indices(last_block)? { - if indices.last_tx_num() <= last_tx_num { - break - } + if let Some(indices) = provider.block_body_indices(last_block)? && + indices.last_tx_num() <= last_tx_num + { + break } if last_block == 0 { break diff --git a/crates/storage/codecs/derive/src/arbitrary.rs b/crates/storage/codecs/derive/src/arbitrary.rs index 5713bb9b0f..552e7d592d 100644 --- a/crates/storage/codecs/derive/src/arbitrary.rs +++ b/crates/storage/codecs/derive/src/arbitrary.rs @@ -23,11 +23,11 @@ pub fn maybe_generate_tests( let mut iter = args.into_iter().peekable(); // we check if there's a crate argument which is used from inside the codecs crate directly - if let Some(arg) = iter.peek() { - if arg.to_string() == "crate" { - is_crate = true; - iter.next(); - } + if let Some(arg) = iter.peek() && + arg.to_string() == "crate" + { + is_crate = true; + iter.next(); } for arg in iter { diff --git a/crates/storage/codecs/derive/src/compact/mod.rs b/crates/storage/codecs/derive/src/compact/mod.rs index ae349cd06e..30082a3212 100644 --- a/crates/storage/codecs/derive/src/compact/mod.rs +++ b/crates/storage/codecs/derive/src/compact/mod.rs @@ -171,28 +171,14 @@ fn load_field_from_segments( /// /// If so, we use another impl to code/decode its data. fn should_use_alt_impl(ftype: &str, segment: &syn::PathSegment) -> bool { - if ftype == "Vec" || ftype == "Option" { - if let syn::PathArguments::AngleBracketed(ref args) = segment.arguments { - if let Some(syn::GenericArgument::Type(syn::Type::Path(arg_path))) = args.args.last() { - if let (Some(path), 1) = - (arg_path.path.segments.first(), arg_path.path.segments.len()) - { - if [ - "B256", - "Address", - "Address", - "Bloom", - "TxHash", - "BlockHash", - "CompactPlaceholder", - ] - .contains(&path.ident.to_string().as_str()) - { - return true - } - } - } - } + if (ftype == "Vec" || ftype == "Option") && + let syn::PathArguments::AngleBracketed(ref args) = segment.arguments && + let Some(syn::GenericArgument::Type(syn::Type::Path(arg_path))) = args.args.last() && + let (Some(path), 1) = (arg_path.path.segments.first(), arg_path.path.segments.len()) && + ["B256", "Address", "Address", "Bloom", "TxHash", "BlockHash", "CompactPlaceholder"] + .contains(&path.ident.to_string().as_str()) + { + return true } false } diff --git a/crates/storage/codecs/derive/src/lib.rs b/crates/storage/codecs/derive/src/lib.rs index a835e8fab3..84d3d33657 100644 --- a/crates/storage/codecs/derive/src/lib.rs +++ b/crates/storage/codecs/derive/src/lib.rs @@ -69,8 +69,8 @@ pub fn derive_zstd(input: TokenStream) -> TokenStream { let mut decompressor = None; for attr in &input.attrs { - if attr.path().is_ident("reth_zstd") { - if let Err(err) = attr.parse_nested_meta(|meta| { + if attr.path().is_ident("reth_zstd") && + let Err(err) = attr.parse_nested_meta(|meta| { if meta.path.is_ident("compressor") { let value = meta.value()?; let path: syn::Path = value.parse()?; @@ -83,9 +83,9 @@ pub fn derive_zstd(input: TokenStream) -> TokenStream { return Err(meta.error("unsupported attribute")) } Ok(()) - }) { - return err.to_compile_error().into() - } + }) + { + return err.to_compile_error().into() } } diff --git a/crates/storage/db/src/lockfile.rs b/crates/storage/db/src/lockfile.rs index 4f862d1f17..5e25d14ae3 100644 --- a/crates/storage/db/src/lockfile.rs +++ b/crates/storage/db/src/lockfile.rs @@ -44,17 +44,18 @@ impl StorageLock { #[cfg(any(test, not(feature = "disable-lock")))] fn try_acquire_file_lock(path: &Path) -> Result { let file_path = path.join(LOCKFILE_NAME); - if let Some(process_lock) = ProcessUID::parse(&file_path)? { - if process_lock.pid != (process::id() as usize) && process_lock.is_active() { - reth_tracing::tracing::error!( - target: "reth::db::lockfile", - path = ?file_path, - pid = process_lock.pid, - start_time = process_lock.start_time, - "Storage lock already taken." - ); - return Err(StorageLockError::Taken(process_lock.pid)) - } + if let Some(process_lock) = ProcessUID::parse(&file_path)? && + process_lock.pid != (process::id() as usize) && + process_lock.is_active() + { + reth_tracing::tracing::error!( + target: "reth::db::lockfile", + path = ?file_path, + pid = process_lock.pid, + start_time = process_lock.start_time, + "Storage lock already taken." + ); + return Err(StorageLockError::Taken(process_lock.pid)) } Ok(Self(Arc::new(StorageLockInner::new(file_path)?))) @@ -141,15 +142,15 @@ impl ProcessUID { /// Parses [`Self`] from a file. fn parse(path: &Path) -> Result, StorageLockError> { - if path.exists() { - if let Ok(contents) = reth_fs_util::read_to_string(path) { - let mut lines = contents.lines(); - if let (Some(Ok(pid)), Some(Ok(start_time))) = ( - lines.next().map(str::trim).map(str::parse), - lines.next().map(str::trim).map(str::parse), - ) { - return Ok(Some(Self { pid, start_time })); - } + if path.exists() && + let Ok(contents) = reth_fs_util::read_to_string(path) + { + let mut lines = contents.lines(); + if let (Some(Ok(pid)), Some(Ok(start_time))) = ( + lines.next().map(str::trim).map(str::parse), + lines.next().map(str::trim).map(str::parse), + ) { + return Ok(Some(Self { pid, start_time })); } } Ok(None) diff --git a/crates/storage/db/src/static_file/mod.rs b/crates/storage/db/src/static_file/mod.rs index cbcf87d893..f2c9ce45fb 100644 --- a/crates/storage/db/src/static_file/mod.rs +++ b/crates/storage/db/src/static_file/mod.rs @@ -33,25 +33,22 @@ pub fn iter_static_files(path: &Path) -> Result::load(&entry.path())?; + { + let jar = NippyJar::::load(&entry.path())?; - let (block_range, tx_range) = ( - jar.user_header().block_range().copied(), - jar.user_header().tx_range().copied(), - ); + let (block_range, tx_range) = + (jar.user_header().block_range().copied(), jar.user_header().tx_range().copied()); - if let Some(block_range) = block_range { - match static_files.entry(segment) { - Entry::Occupied(mut entry) => { - entry.get_mut().push((block_range, tx_range)); - } - Entry::Vacant(entry) => { - entry.insert(vec![(block_range, tx_range)]); - } + if let Some(block_range) = block_range { + match static_files.entry(segment) { + Entry::Occupied(mut entry) => { + entry.get_mut().push((block_range, tx_range)); + } + Entry::Vacant(entry) => { + entry.insert(vec![(block_range, tx_range)]); } } } diff --git a/crates/storage/libmdbx-rs/src/codec.rs b/crates/storage/libmdbx-rs/src/codec.rs index c78f79db9f..c0b2f0f1cf 100644 --- a/crates/storage/libmdbx-rs/src/codec.rs +++ b/crates/storage/libmdbx-rs/src/codec.rs @@ -17,7 +17,7 @@ pub trait TableObject: Sized { _: *const ffi::MDBX_txn, data_val: ffi::MDBX_val, ) -> Result { - let s = slice::from_raw_parts(data_val.iov_base as *const u8, data_val.iov_len); + let s = unsafe { slice::from_raw_parts(data_val.iov_base as *const u8, data_val.iov_len) }; Self::decode(s) } } @@ -32,7 +32,7 @@ impl TableObject for Cow<'_, [u8]> { _txn: *const ffi::MDBX_txn, data_val: ffi::MDBX_val, ) -> Result { - let s = slice::from_raw_parts(data_val.iov_base as *const u8, data_val.iov_len); + let s = unsafe { slice::from_raw_parts(data_val.iov_base as *const u8, data_val.iov_len) }; #[cfg(feature = "return-borrowed")] { diff --git a/crates/storage/libmdbx-rs/src/transaction.rs b/crates/storage/libmdbx-rs/src/transaction.rs index 9b1896b747..e47e71ac26 100644 --- a/crates/storage/libmdbx-rs/src/transaction.rs +++ b/crates/storage/libmdbx-rs/src/transaction.rs @@ -476,7 +476,7 @@ impl Transaction { /// Caller must close ALL other [Database] and [Cursor] instances pointing to the same dbi /// BEFORE calling this function. pub unsafe fn drop_db(&self, db: Database) -> Result<()> { - mdbx_result(self.txn_execute(|txn| ffi::mdbx_drop(txn, db.dbi(), true))?)?; + mdbx_result(self.txn_execute(|txn| unsafe { ffi::mdbx_drop(txn, db.dbi(), true) })?)?; Ok(()) } @@ -489,7 +489,7 @@ impl Transaction { /// Caller must close ALL other [Database] and [Cursor] instances pointing to the same dbi /// BEFORE calling this function. pub unsafe fn close_db(&self, db: Database) -> Result<()> { - mdbx_result(ffi::mdbx_dbi_close(self.env().env_ptr(), db.dbi()))?; + mdbx_result(unsafe { ffi::mdbx_dbi_close(self.env().env_ptr(), db.dbi()) })?; Ok(()) } diff --git a/crates/storage/nippy-jar/src/lib.rs b/crates/storage/nippy-jar/src/lib.rs index f3d1944d3b..b47042f8b9 100644 --- a/crates/storage/nippy-jar/src/lib.rs +++ b/crates/storage/nippy-jar/src/lib.rs @@ -309,10 +309,10 @@ impl NippyJar { return Err(NippyJarError::ColumnLenMismatch(self.columns, columns.len())) } - if let Some(compression) = &self.compressor { - if !compression.is_ready() { - return Err(NippyJarError::CompressorNotReady) - } + if let Some(compression) = &self.compressor && + !compression.is_ready() + { + return Err(NippyJarError::CompressorNotReady) } Ok(()) diff --git a/crates/storage/nippy-jar/src/writer.rs b/crates/storage/nippy-jar/src/writer.rs index 1069c6e67d..cf899791ee 100644 --- a/crates/storage/nippy-jar/src/writer.rs +++ b/crates/storage/nippy-jar/src/writer.rs @@ -404,10 +404,10 @@ impl NippyJarWriter { // Appends new offsets to disk for offset in self.offsets.drain(..) { - if let Some(last_offset_ondisk) = last_offset_ondisk.take() { - if last_offset_ondisk == offset { - continue - } + if let Some(last_offset_ondisk) = last_offset_ondisk.take() && + last_offset_ondisk == offset + { + continue } self.offsets_file.write_all(&offset.to_le_bytes())?; } diff --git a/crates/storage/provider/src/providers/blockchain_provider.rs b/crates/storage/provider/src/providers/blockchain_provider.rs index 17ee98009e..f6c3d30150 100644 --- a/crates/storage/provider/src/providers/blockchain_provider.rs +++ b/crates/storage/provider/src/providers/blockchain_provider.rs @@ -594,10 +594,10 @@ impl StateProviderFactory for BlockchainProvider { } fn pending_state_by_hash(&self, block_hash: B256) -> ProviderResult> { - if let Some(pending) = self.canonical_in_memory_state.pending_state() { - if pending.hash() == block_hash { - return Ok(Some(Box::new(self.block_state_provider(&pending)?))); - } + if let Some(pending) = self.canonical_in_memory_state.pending_state() && + pending.hash() == block_hash + { + return Ok(Some(Box::new(self.block_state_provider(&pending)?))); } Ok(None) } @@ -965,26 +965,26 @@ mod tests { ) { let hook_provider = provider.clone(); provider.database.db_ref().set_post_transaction_hook(Box::new(move || { - if let Some(state) = hook_provider.canonical_in_memory_state.head_state() { - if state.anchor().number + 1 == block_number { - let mut lowest_memory_block = - state.parent_state_chain().last().expect("qed").block(); - let num_hash = lowest_memory_block.recovered_block().num_hash(); + if let Some(state) = hook_provider.canonical_in_memory_state.head_state() && + state.anchor().number + 1 == block_number + { + let mut lowest_memory_block = + state.parent_state_chain().last().expect("qed").block(); + let num_hash = lowest_memory_block.recovered_block().num_hash(); - let mut execution_output = (*lowest_memory_block.execution_output).clone(); - execution_output.first_block = lowest_memory_block.recovered_block().number; - lowest_memory_block.execution_output = Arc::new(execution_output); + let mut execution_output = (*lowest_memory_block.execution_output).clone(); + execution_output.first_block = lowest_memory_block.recovered_block().number; + lowest_memory_block.execution_output = Arc::new(execution_output); - // Push to disk - let provider_rw = hook_provider.database_provider_rw().unwrap(); - UnifiedStorageWriter::from(&provider_rw, &hook_provider.static_file_provider()) - .save_blocks(vec![lowest_memory_block]) - .unwrap(); - UnifiedStorageWriter::commit(provider_rw).unwrap(); + // Push to disk + let provider_rw = hook_provider.database_provider_rw().unwrap(); + UnifiedStorageWriter::from(&provider_rw, &hook_provider.static_file_provider()) + .save_blocks(vec![lowest_memory_block]) + .unwrap(); + UnifiedStorageWriter::commit(provider_rw).unwrap(); - // Remove from memory - hook_provider.canonical_in_memory_state.remove_persisted_blocks(num_hash); - } + // Remove from memory + hook_provider.canonical_in_memory_state.remove_persisted_blocks(num_hash); } })); } diff --git a/crates/storage/provider/src/providers/consistent.rs b/crates/storage/provider/src/providers/consistent.rs index c9b0723122..4a4a2df277 100644 --- a/crates/storage/provider/src/providers/consistent.rs +++ b/crates/storage/provider/src/providers/consistent.rs @@ -536,10 +536,10 @@ impl ConsistentProvider { // If the transaction number is less than the first in-memory transaction number, make a // database lookup - if let HashOrNumber::Number(id) = id { - if id < in_memory_tx_num { - return fetch_from_db(provider) - } + if let HashOrNumber::Number(id) = id && + id < in_memory_tx_num + { + return fetch_from_db(provider) } // Iterate from the lowest block to the highest @@ -816,14 +816,14 @@ impl BlockReader for ConsistentProvider { hash: B256, source: BlockSource, ) -> ProviderResult> { - if matches!(source, BlockSource::Canonical | BlockSource::Any) { - if let Some(block) = self.get_in_memory_or_storage_by_block( + if matches!(source, BlockSource::Canonical | BlockSource::Any) && + let Some(block) = self.get_in_memory_or_storage_by_block( hash.into(), |db_provider| db_provider.find_block_by_hash(hash, BlockSource::Canonical), |block_state| Ok(Some(block_state.block_ref().recovered_block().clone_block())), - )? { - return Ok(Some(block)) - } + )? + { + return Ok(Some(block)) } if matches!(source, BlockSource::Pending | BlockSource::Any) { @@ -1133,14 +1133,14 @@ impl ReceiptProviderIdExt for ConsistentProvider { match block { BlockId::Hash(rpc_block_hash) => { let mut receipts = self.receipts_by_block(rpc_block_hash.block_hash.into())?; - if receipts.is_none() && !rpc_block_hash.require_canonical.unwrap_or(false) { - if let Some(state) = self + if receipts.is_none() && + !rpc_block_hash.require_canonical.unwrap_or(false) && + let Some(state) = self .head_block .as_ref() .and_then(|b| b.block_on_chain(rpc_block_hash.block_hash.into())) - { - receipts = Some(state.executed_block_receipts()); - } + { + receipts = Some(state.executed_block_receipts()); } Ok(receipts) } diff --git a/crates/storage/provider/src/providers/consistent_view.rs b/crates/storage/provider/src/providers/consistent_view.rs index 2afaacfa5d..8edf062d26 100644 --- a/crates/storage/provider/src/providers/consistent_view.rs +++ b/crates/storage/provider/src/providers/consistent_view.rs @@ -67,10 +67,10 @@ where // // To ensure this doesn't happen, we just have to make sure that we fetch from the same // data source that we used during initialization. In this case, that is static files - if let Some((hash, number)) = self.tip { - if provider_ro.sealed_header(number)?.is_none_or(|header| header.hash() != hash) { - return Err(ConsistentViewError::Reorged { block: hash }.into()) - } + if let Some((hash, number)) = self.tip && + provider_ro.sealed_header(number)?.is_none_or(|header| header.hash() != hash) + { + return Err(ConsistentViewError::Reorged { block: hash }.into()) } Ok(provider_ro) diff --git a/crates/storage/provider/src/providers/database/provider.rs b/crates/storage/provider/src/providers/database/provider.rs index 02b2e112ed..6a16dbcbf5 100644 --- a/crates/storage/provider/src/providers/database/provider.rs +++ b/crates/storage/provider/src/providers/database/provider.rs @@ -1020,12 +1020,12 @@ impl HeaderProvider for DatabasePro } fn header_td_by_number(&self, number: BlockNumber) -> ProviderResult> { - if self.chain_spec.is_paris_active_at_block(number) { - if let Some(td) = self.chain_spec.final_paris_total_difficulty() { - // if this block is higher than the final paris(merge) block, return the final paris - // difficulty - return Ok(Some(td)) - } + if self.chain_spec.is_paris_active_at_block(number) && + let Some(td) = self.chain_spec.final_paris_total_difficulty() + { + // if this block is higher than the final paris(merge) block, return the final paris + // difficulty + return Ok(Some(td)) } self.static_file_provider.get_with_static_file_or_database( @@ -1180,25 +1180,25 @@ impl BlockReader for DatabaseProvid /// If the header is found, but the transactions either do not exist, or are not indexed, this /// will return None. fn block(&self, id: BlockHashOrNumber) -> ProviderResult> { - if let Some(number) = self.convert_hash_or_number(id)? { - if let Some(header) = self.header_by_number(number)? { - // If the body indices are not found, this means that the transactions either do not - // exist in the database yet, or they do exit but are not indexed. - // If they exist but are not indexed, we don't have enough - // information to return the block anyways, so we return `None`. - let Some(transactions) = self.transactions_by_block(number.into())? else { - return Ok(None) - }; + if let Some(number) = self.convert_hash_or_number(id)? && + let Some(header) = self.header_by_number(number)? + { + // If the body indices are not found, this means that the transactions either do not + // exist in the database yet, or they do exit but are not indexed. + // If they exist but are not indexed, we don't have enough + // information to return the block anyways, so we return `None`. + let Some(transactions) = self.transactions_by_block(number.into())? else { + return Ok(None) + }; - let body = self - .storage - .reader() - .read_block_bodies(self, vec![(&header, transactions)])? - .pop() - .ok_or(ProviderError::InvalidStorageOutput)?; + let body = self + .storage + .reader() + .read_block_bodies(self, vec![(&header, transactions)])? + .pop() + .ok_or(ProviderError::InvalidStorageOutput)?; - return Ok(Some(Self::Block::new(header, body))) - } + return Ok(Some(Self::Block::new(header, body))) } Ok(None) @@ -1416,34 +1416,31 @@ impl TransactionsProvider for Datab tx_hash: TxHash, ) -> ProviderResult> { let mut transaction_cursor = self.tx.cursor_read::()?; - if let Some(transaction_id) = self.transaction_id(tx_hash)? { - if let Some(transaction) = self.transaction_by_id_unhashed(transaction_id)? { - if let Some(block_number) = - transaction_cursor.seek(transaction_id).map(|b| b.map(|(_, bn)| bn))? - { - if let Some(sealed_header) = self.sealed_header(block_number)? { - let (header, block_hash) = sealed_header.split(); - if let Some(block_body) = self.block_body_indices(block_number)? { - // the index of the tx in the block is the offset: - // len([start..tx_id]) - // NOTE: `transaction_id` is always `>=` the block's first - // index - let index = transaction_id - block_body.first_tx_num(); + if let Some(transaction_id) = self.transaction_id(tx_hash)? && + let Some(transaction) = self.transaction_by_id_unhashed(transaction_id)? && + let Some(block_number) = + transaction_cursor.seek(transaction_id).map(|b| b.map(|(_, bn)| bn))? && + let Some(sealed_header) = self.sealed_header(block_number)? + { + let (header, block_hash) = sealed_header.split(); + if let Some(block_body) = self.block_body_indices(block_number)? { + // the index of the tx in the block is the offset: + // len([start..tx_id]) + // NOTE: `transaction_id` is always `>=` the block's first + // index + let index = transaction_id - block_body.first_tx_num(); - let meta = TransactionMeta { - tx_hash, - index, - block_hash, - block_number, - base_fee: header.base_fee_per_gas(), - excess_blob_gas: header.excess_blob_gas(), - timestamp: header.timestamp(), - }; + let meta = TransactionMeta { + tx_hash, + index, + block_hash, + block_number, + base_fee: header.base_fee_per_gas(), + excess_blob_gas: header.excess_blob_gas(), + timestamp: header.timestamp(), + }; - return Ok(Some((transaction, meta))) - } - } - } + return Ok(Some((transaction, meta))) } } @@ -1461,14 +1458,14 @@ impl TransactionsProvider for Datab ) -> ProviderResult>> { let mut tx_cursor = self.tx.cursor_read::>()?; - if let Some(block_number) = self.convert_hash_or_number(id)? { - if let Some(body) = self.block_body_indices(block_number)? { - let tx_range = body.tx_num_range(); - return if tx_range.is_empty() { - Ok(Some(Vec::new())) - } else { - Ok(Some(self.transactions_by_tx_range_with_cursor(tx_range, &mut tx_cursor)?)) - } + if let Some(block_number) = self.convert_hash_or_number(id)? && + let Some(body) = self.block_body_indices(block_number)? + { + let tx_range = body.tx_num_range(); + return if tx_range.is_empty() { + Ok(Some(Vec::new())) + } else { + Ok(Some(self.transactions_by_tx_range_with_cursor(tx_range, &mut tx_cursor)?)) } } Ok(None) @@ -1543,14 +1540,14 @@ impl ReceiptProvider for DatabasePr &self, block: BlockHashOrNumber, ) -> ProviderResult>> { - if let Some(number) = self.convert_hash_or_number(block)? { - if let Some(body) = self.block_body_indices(number)? { - let tx_range = body.tx_num_range(); - return if tx_range.is_empty() { - Ok(Some(Vec::new())) - } else { - self.receipts_by_tx_range(tx_range).map(Some) - } + if let Some(number) = self.convert_hash_or_number(block)? && + let Some(body) = self.block_body_indices(number)? + { + let tx_range = body.tx_num_range(); + return if tx_range.is_empty() { + Ok(Some(Vec::new())) + } else { + self.receipts_by_tx_range(tx_range).map(Some) } } Ok(None) @@ -2000,10 +1997,10 @@ impl StateWriter for entry in storage { tracing::trace!(?address, ?entry.key, "Updating plain state storage"); - if let Some(db_entry) = storages_cursor.seek_by_key_subkey(address, entry.key)? { - if db_entry.key == entry.key { - storages_cursor.delete_current()?; - } + if let Some(db_entry) = storages_cursor.seek_by_key_subkey(address, entry.key)? && + db_entry.key == entry.key + { + storages_cursor.delete_current()?; } if !entry.value.is_zero() { @@ -2038,11 +2035,10 @@ impl StateWriter for (hashed_slot, value) in storage.storage_slots_sorted() { let entry = StorageEntry { key: hashed_slot, value }; if let Some(db_entry) = - hashed_storage_cursor.seek_by_key_subkey(*hashed_address, entry.key)? + hashed_storage_cursor.seek_by_key_subkey(*hashed_address, entry.key)? && + db_entry.key == entry.key { - if db_entry.key == entry.key { - hashed_storage_cursor.delete_current()?; - } + hashed_storage_cursor.delete_current()?; } if !entry.value.is_zero() { diff --git a/crates/storage/provider/src/providers/state/latest.rs b/crates/storage/provider/src/providers/state/latest.rs index 5c838b0da3..de8eef2cc9 100644 --- a/crates/storage/provider/src/providers/state/latest.rs +++ b/crates/storage/provider/src/providers/state/latest.rs @@ -158,10 +158,10 @@ impl StateProvider storage_key: StorageKey, ) -> ProviderResult> { let mut cursor = self.tx().cursor_dup_read::()?; - if let Some(entry) = cursor.seek_by_key_subkey(account, storage_key)? { - if entry.key == storage_key { - return Ok(Some(entry.value)) - } + if let Some(entry) = cursor.seek_by_key_subkey(account, storage_key)? && + entry.key == storage_key + { + return Ok(Some(entry.value)) } Ok(None) } diff --git a/crates/storage/provider/src/providers/static_file/jar.rs b/crates/storage/provider/src/providers/static_file/jar.rs index 74ec074dba..ab19fbf732 100644 --- a/crates/storage/provider/src/providers/static_file/jar.rs +++ b/crates/storage/provider/src/providers/static_file/jar.rs @@ -314,10 +314,10 @@ impl ProviderResult> { - if let Some(tx_static_file) = &self.auxiliary_jar { - if let Some(num) = tx_static_file.transaction_id(hash)? { - return self.receipt(num) - } + if let Some(tx_static_file) = &self.auxiliary_jar && + let Some(num) = tx_static_file.transaction_id(hash)? + { + return self.receipt(num) } Ok(None) } diff --git a/crates/storage/provider/src/providers/static_file/manager.rs b/crates/storage/provider/src/providers/static_file/manager.rs index c900710044..fc2c94a1ba 100644 --- a/crates/storage/provider/src/providers/static_file/manager.rs +++ b/crates/storage/provider/src/providers/static_file/manager.rs @@ -950,12 +950,11 @@ impl StaticFileProvider { } } - if let Some((db_last_entry, _)) = db_cursor.last()? { - if highest_static_file_entry + if let Some((db_last_entry, _)) = db_cursor.last()? && + highest_static_file_entry .is_none_or(|highest_entry| db_last_entry > highest_entry) - { - return Ok(None) - } + { + return Ok(None) } } @@ -1281,16 +1280,15 @@ impl StaticFileProvider { self.get_highest_static_file_block(segment) } else { self.get_highest_static_file_tx(segment) - } { - if block_or_tx_range.start <= static_file_upper_bound { - let end = block_or_tx_range.end.min(static_file_upper_bound + 1); - data.extend(fetch_from_static_file( - self, - block_or_tx_range.start..end, - &mut predicate, - )?); - block_or_tx_range.start = end; - } + } && block_or_tx_range.start <= static_file_upper_bound + { + let end = block_or_tx_range.end.min(static_file_upper_bound + 1); + data.extend(fetch_from_static_file( + self, + block_or_tx_range.start..end, + &mut predicate, + )?); + block_or_tx_range.start = end; } if block_or_tx_range.end > block_or_tx_range.start { diff --git a/crates/storage/storage-api/src/chain.rs b/crates/storage/storage-api/src/chain.rs index a878290737..e78a59afef 100644 --- a/crates/storage/storage-api/src/chain.rs +++ b/crates/storage/storage-api/src/chain.rs @@ -120,11 +120,10 @@ where } // Write withdrawals if any - if let Some(withdrawals) = body.withdrawals { - if !withdrawals.is_empty() { - withdrawals_cursor - .append(block_number, &StoredBlockWithdrawals { withdrawals })?; - } + if let Some(withdrawals) = body.withdrawals && + !withdrawals.is_empty() + { + withdrawals_cursor.append(block_number, &StoredBlockWithdrawals { withdrawals })?; } } diff --git a/crates/storage/zstd-compressors/src/lib.rs b/crates/storage/zstd-compressors/src/lib.rs index d7f2b65904..0e9b800b1f 100644 --- a/crates/storage/zstd-compressors/src/lib.rs +++ b/crates/storage/zstd-compressors/src/lib.rs @@ -118,10 +118,10 @@ impl ReusableDecompressor { // source. if !reserved_upper_bound { reserved_upper_bound = true; - if let Some(upper_bound) = Decompressor::upper_bound(src) { - if let Some(additional) = upper_bound.checked_sub(self.buf.capacity()) { - break 'b additional - } + if let Some(upper_bound) = Decompressor::upper_bound(src) && + let Some(additional) = upper_bound.checked_sub(self.buf.capacity()) + { + break 'b additional } } diff --git a/crates/transaction-pool/src/maintain.rs b/crates/transaction-pool/src/maintain.rs index a2f33900b5..732d55d0c3 100644 --- a/crates/transaction-pool/src/maintain.rs +++ b/crates/transaction-pool/src/maintain.rs @@ -229,21 +229,19 @@ pub async fn maintain_transaction_pool( // check if we have a new finalized block if let Some(finalized) = - last_finalized_block.update(client.finalized_block_number().ok().flatten()) - { - if let BlobStoreUpdates::Finalized(blobs) = + last_finalized_block.update(client.finalized_block_number().ok().flatten()) && + let BlobStoreUpdates::Finalized(blobs) = blob_store_tracker.on_finalized_block(finalized) - { - metrics.inc_deleted_tracked_blobs(blobs.len()); - // remove all finalized blobs from the blob store - pool.delete_blobs(blobs); - // and also do periodic cleanup - let pool = pool.clone(); - task_spawner.spawn_blocking(Box::pin(async move { - debug!(target: "txpool", finalized_block = %finalized, "cleaning up blob store"); - pool.cleanup_blobs(); - })); - } + { + metrics.inc_deleted_tracked_blobs(blobs.len()); + // remove all finalized blobs from the blob store + pool.delete_blobs(blobs); + // and also do periodic cleanup + let pool = pool.clone(); + task_spawner.spawn_blocking(Box::pin(async move { + debug!(target: "txpool", finalized_block = %finalized, "cleaning up blob store"); + pool.cleanup_blobs(); + })); } // outcomes of the futures we are waiting on diff --git a/crates/transaction-pool/src/pool/best.rs b/crates/transaction-pool/src/pool/best.rs index c84ba5eed9..faa19ee58e 100644 --- a/crates/transaction-pool/src/pool/best.rs +++ b/crates/transaction-pool/src/pool/best.rs @@ -127,12 +127,12 @@ impl BestTransactions { loop { match self.new_transaction_receiver.as_mut()?.try_recv() { Ok(tx) => { - if let Some(last_priority) = &self.last_priority { - if &tx.priority > last_priority { - // we skip transactions if we already yielded a transaction with lower - // priority - return None - } + if let Some(last_priority) = &self.last_priority && + &tx.priority > last_priority + { + // we skip transactions if we already yielded a transaction with lower + // priority + return None } return Some(tx) } diff --git a/crates/transaction-pool/src/pool/mod.rs b/crates/transaction-pool/src/pool/mod.rs index 10666683ad..04f0e6e0b3 100644 --- a/crates/transaction-pool/src/pool/mod.rs +++ b/crates/transaction-pool/src/pool/mod.rs @@ -612,10 +612,10 @@ where // A newly added transaction may be immediately discarded, so we need to // adjust the result here for res in &mut added { - if let Ok(AddedTransactionOutcome { hash, .. }) = res { - if discarded_hashes.contains(hash) { - *res = Err(PoolError::new(*hash, PoolErrorKind::DiscardedOnInsert)) - } + if let Ok(AddedTransactionOutcome { hash, .. }) = res && + discarded_hashes.contains(hash) + { + *res = Err(PoolError::new(*hash, PoolErrorKind::DiscardedOnInsert)) } } } diff --git a/crates/transaction-pool/src/pool/pending.rs b/crates/transaction-pool/src/pool/pending.rs index 91e2bfc297..c28f66c58e 100644 --- a/crates/transaction-pool/src/pool/pending.rs +++ b/crates/transaction-pool/src/pool/pending.rs @@ -329,13 +329,13 @@ impl PendingPool { &mut self, id: &TransactionId, ) -> Option>> { - if let Some(lowest) = self.independent_transactions.get(&id.sender) { - if lowest.transaction.nonce() == id.nonce { - self.independent_transactions.remove(&id.sender); - // mark the next as independent if it exists - if let Some(unlocked) = self.get(&id.descendant()) { - self.independent_transactions.insert(id.sender, unlocked.clone()); - } + if let Some(lowest) = self.independent_transactions.get(&id.sender) && + lowest.transaction.nonce() == id.nonce + { + self.independent_transactions.remove(&id.sender); + // mark the next as independent if it exists + if let Some(unlocked) = self.get(&id.descendant()) { + self.independent_transactions.insert(id.sender, unlocked.clone()); } } diff --git a/crates/transaction-pool/src/pool/txpool.rs b/crates/transaction-pool/src/pool/txpool.rs index 525ed8d31f..48e33d9ce6 100644 --- a/crates/transaction-pool/src/pool/txpool.rs +++ b/crates/transaction-pool/src/pool/txpool.rs @@ -954,11 +954,11 @@ impl TxPool { Destination::Pool(move_to) => { debug_assert_ne!(&move_to, ¤t, "destination must be different"); let moved = self.move_transaction(current, move_to, &id); - if matches!(move_to, SubPool::Pending) { - if let Some(tx) = moved { - trace!(target: "txpool", hash=%tx.transaction.hash(), "Promoted transaction to pending"); - outcome.promoted.push(tx); - } + if matches!(move_to, SubPool::Pending) && + let Some(tx) = moved + { + trace!(target: "txpool", hash=%tx.transaction.hash(), "Promoted transaction to pending"); + outcome.promoted.push(tx); } } } @@ -1856,18 +1856,18 @@ impl AllTransactions { // overdraft let id = new_blob_tx.transaction_id; let mut descendants = self.descendant_txs_inclusive(&id).peekable(); - if let Some((maybe_replacement, _)) = descendants.peek() { - if **maybe_replacement == new_blob_tx.transaction_id { - // replacement transaction - descendants.next(); + if let Some((maybe_replacement, _)) = descendants.peek() && + **maybe_replacement == new_blob_tx.transaction_id + { + // replacement transaction + descendants.next(); - // check if any of descendant blob transactions should be shifted into overdraft - for (_, tx) in descendants { - cumulative_cost += tx.transaction.cost(); - if tx.transaction.is_eip4844() && cumulative_cost > on_chain_balance { - // the transaction would shift - return Err(InsertErr::Overdraft { transaction: Arc::new(new_blob_tx) }) - } + // check if any of descendant blob transactions should be shifted into overdraft + for (_, tx) in descendants { + cumulative_cost += tx.transaction.cost(); + if tx.transaction.is_eip4844() && cumulative_cost > on_chain_balance { + // the transaction would shift + return Err(InsertErr::Overdraft { transaction: Arc::new(new_blob_tx) }) } } } diff --git a/crates/transaction-pool/src/test_utils/mock.rs b/crates/transaction-pool/src/test_utils/mock.rs index 4c0c590983..2983c6ea34 100644 --- a/crates/transaction-pool/src/test_utils/mock.rs +++ b/crates/transaction-pool/src/test_utils/mock.rs @@ -54,7 +54,31 @@ pub fn mock_tx_pool() -> MockTxPool { /// Sets the value for the field macro_rules! set_value { - ($this:ident => $field:ident) => { + // For mutable references + (&mut $this:expr => $field:ident) => {{ + let new_value = $field; + match $this { + MockTransaction::Legacy { $field, .. } => { + *$field = new_value; + } + MockTransaction::Eip1559 { $field, .. } => { + *$field = new_value; + } + MockTransaction::Eip4844 { $field, .. } => { + *$field = new_value; + } + MockTransaction::Eip2930 { $field, .. } => { + *$field = new_value; + } + MockTransaction::Eip7702 { $field, .. } => { + *$field = new_value; + } + } + // Ensure the tx cost is always correct after each mutation. + $this.update_cost(); + }}; + // For owned values + ($this:expr => $field:ident) => {{ let new_value = $field; match $this { MockTransaction::Legacy { ref mut $field, .. } | @@ -67,7 +91,7 @@ macro_rules! set_value { } // Ensure the tx cost is always correct after each mutation. $this.update_cost(); - }; + }}; } /// Gets the value for the field @@ -89,7 +113,7 @@ macro_rules! make_setters_getters { paste! {$( /// Sets the value of the specified field. pub fn [](&mut self, $name: $t) -> &mut Self { - set_value!(self => $name); + set_value!(&mut self => $name); self } diff --git a/crates/transaction-pool/src/validate/eth.rs b/crates/transaction-pool/src/validate/eth.rs index fa9c32e329..e010f81a64 100644 --- a/crates/transaction-pool/src/validate/eth.rs +++ b/crates/transaction-pool/src/validate/eth.rs @@ -339,10 +339,10 @@ where } // Check whether the init code size has been exceeded. - if self.fork_tracker.is_shanghai_activated() { - if let Err(err) = transaction.ensure_max_init_code_size(MAX_INIT_CODE_BYTE_SIZE) { - return Err(TransactionValidationOutcome::Invalid(transaction, err)) - } + if self.fork_tracker.is_shanghai_activated() && + let Err(err) = transaction.ensure_max_init_code_size(MAX_INIT_CODE_BYTE_SIZE) + { + return Err(TransactionValidationOutcome::Invalid(transaction, err)) } // Checks for gas limit @@ -359,16 +359,16 @@ where } // Check individual transaction gas limit if configured - if let Some(max_tx_gas_limit) = self.max_tx_gas_limit { - if transaction_gas_limit > max_tx_gas_limit { - return Err(TransactionValidationOutcome::Invalid( - transaction, - InvalidPoolTransactionError::MaxTxGasLimitExceeded( - transaction_gas_limit, - max_tx_gas_limit, - ), - )) - } + if let Some(max_tx_gas_limit) = self.max_tx_gas_limit && + transaction_gas_limit > max_tx_gas_limit + { + return Err(TransactionValidationOutcome::Invalid( + transaction, + InvalidPoolTransactionError::MaxTxGasLimitExceeded( + transaction_gas_limit, + max_tx_gas_limit, + ), + )) } // Ensure max_priority_fee_per_gas (if EIP1559) is less than max_fee_per_gas if any. @@ -422,13 +422,13 @@ where } // Checks for chainid - if let Some(chain_id) = transaction.chain_id() { - if chain_id != self.chain_id() { - return Err(TransactionValidationOutcome::Invalid( - transaction, - InvalidTransactionError::ChainIdMismatch.into(), - )) - } + if let Some(chain_id) = transaction.chain_id() && + chain_id != self.chain_id() + { + return Err(TransactionValidationOutcome::Invalid( + transaction, + InvalidTransactionError::ChainIdMismatch.into(), + )) } if transaction.is_eip7702() { diff --git a/crates/trie/common/src/proofs.rs b/crates/trie/common/src/proofs.rs index 621dcf04a3..b7961f047a 100644 --- a/crates/trie/common/src/proofs.rs +++ b/crates/trie/common/src/proofs.rs @@ -229,18 +229,16 @@ impl MultiProof { // Inspect the last node in the proof. If it's a leaf node with matching suffix, // then the node contains the encoded trie account. let info = 'info: { - if let Some(last) = proof.last() { - if let TrieNode::Leaf(leaf) = TrieNode::decode(&mut &last[..])? { - if nibbles.ends_with(&leaf.key) { - let account = TrieAccount::decode(&mut &leaf.value[..])?; - break 'info Some(Account { - balance: account.balance, - nonce: account.nonce, - bytecode_hash: (account.code_hash != KECCAK_EMPTY) - .then_some(account.code_hash), - }) - } - } + if let Some(last) = proof.last() && + let TrieNode::Leaf(leaf) = TrieNode::decode(&mut &last[..])? && + nibbles.ends_with(&leaf.key) + { + let account = TrieAccount::decode(&mut &leaf.value[..])?; + break 'info Some(Account { + balance: account.balance, + nonce: account.nonce, + bytecode_hash: (account.code_hash != KECCAK_EMPTY).then_some(account.code_hash), + }) } None }; @@ -360,16 +358,15 @@ impl DecodedMultiProof { // Inspect the last node in the proof. If it's a leaf node with matching suffix, // then the node contains the encoded trie account. let info = 'info: { - if let Some(TrieNode::Leaf(leaf)) = proof.last() { - if nibbles.ends_with(&leaf.key) { - let account = TrieAccount::decode(&mut &leaf.value[..])?; - break 'info Some(Account { - balance: account.balance, - nonce: account.nonce, - bytecode_hash: (account.code_hash != KECCAK_EMPTY) - .then_some(account.code_hash), - }) - } + if let Some(TrieNode::Leaf(leaf)) = proof.last() && + nibbles.ends_with(&leaf.key) + { + let account = TrieAccount::decode(&mut &leaf.value[..])?; + break 'info Some(Account { + balance: account.balance, + nonce: account.nonce, + bytecode_hash: (account.code_hash != KECCAK_EMPTY).then_some(account.code_hash), + }) } None }; @@ -486,12 +483,11 @@ impl StorageMultiProof { // Inspect the last node in the proof. If it's a leaf node with matching suffix, // then the node contains the encoded slot value. let value = 'value: { - if let Some(last) = proof.last() { - if let TrieNode::Leaf(leaf) = TrieNode::decode(&mut &last[..])? { - if nibbles.ends_with(&leaf.key) { - break 'value U256::decode(&mut &leaf.value[..])? - } - } + if let Some(last) = proof.last() && + let TrieNode::Leaf(leaf) = TrieNode::decode(&mut &last[..])? && + nibbles.ends_with(&leaf.key) + { + break 'value U256::decode(&mut &leaf.value[..])? } U256::ZERO }; @@ -539,10 +535,10 @@ impl DecodedStorageMultiProof { // Inspect the last node in the proof. If it's a leaf node with matching suffix, // then the node contains the encoded slot value. let value = 'value: { - if let Some(TrieNode::Leaf(leaf)) = proof.last() { - if nibbles.ends_with(&leaf.key) { - break 'value U256::decode(&mut &leaf.value[..])? - } + if let Some(TrieNode::Leaf(leaf)) = proof.last() && + nibbles.ends_with(&leaf.key) + { + break 'value U256::decode(&mut &leaf.value[..])? } U256::ZERO }; diff --git a/crates/trie/sparse-parallel/src/trie.rs b/crates/trie/sparse-parallel/src/trie.rs index 908253c7a3..d973d705de 100644 --- a/crates/trie/sparse-parallel/src/trie.rs +++ b/crates/trie/sparse-parallel/src/trie.rs @@ -550,15 +550,14 @@ impl SparseTrieInterface for ParallelSparseTrie { // If we were previously looking at the upper trie, and the new path is in the // lower trie, we need to pull out a ref to the lower trie. - if curr_subtrie_is_upper { - if let SparseSubtrieType::Lower(idx) = + if curr_subtrie_is_upper && + let SparseSubtrieType::Lower(idx) = SparseSubtrieType::from_path(&curr_path) - { - curr_subtrie = self.lower_subtries[idx] - .as_revealed_mut() - .expect("lower subtrie is revealed"); - curr_subtrie_is_upper = false; - } + { + curr_subtrie = self.lower_subtries[idx] + .as_revealed_mut() + .expect("lower subtrie is revealed"); + curr_subtrie_is_upper = false; } } }; @@ -599,7 +598,7 @@ impl SparseTrieInterface for ParallelSparseTrie { // If there is a parent branch node (very likely, unless the leaf is at the root) execute // any required changes for that node, relative to the removed leaf. - if let (Some(branch_path), Some(SparseNode::Branch { mut state_mask, .. })) = + if let (Some(branch_path), &Some(SparseNode::Branch { mut state_mask, .. })) = (&branch_parent_path, &branch_parent_node) { let child_nibble = leaf_path.get_unchecked(branch_path.len()); @@ -885,11 +884,11 @@ impl SparseTrieInterface for ParallelSparseTrie { curr_path = next_path; // If we were previously looking at the upper trie, and the new path is in the // lower trie, we need to pull out a ref to the lower trie. - if curr_subtrie_is_upper { - if let Some(lower_subtrie) = self.lower_subtrie_for_path(&curr_path) { - curr_subtrie = lower_subtrie; - curr_subtrie_is_upper = false; - } + if curr_subtrie_is_upper && + let Some(lower_subtrie) = self.lower_subtrie_for_path(&curr_path) + { + curr_subtrie = lower_subtrie; + curr_subtrie_is_upper = false; } } } @@ -1591,37 +1590,37 @@ impl SparseSubtrie { current = Some(next_node); } LeafUpdateStep::Complete { reveal_path, .. } => { - if let Some(reveal_path) = reveal_path { - if self.nodes.get(&reveal_path).expect("node must exist").is_hash() { - debug!( + if let Some(reveal_path) = reveal_path && + self.nodes.get(&reveal_path).expect("node must exist").is_hash() + { + debug!( + target: "trie::parallel_sparse", + child_path = ?reveal_path, + leaf_full_path = ?full_path, + "Extension node child not revealed in update_leaf, falling back to db", + ); + if let Some(RevealedNode { node, tree_mask, hash_mask }) = + provider.trie_node(&reveal_path)? + { + let decoded = TrieNode::decode(&mut &node[..])?; + trace!( target: "trie::parallel_sparse", - child_path = ?reveal_path, - leaf_full_path = ?full_path, - "Extension node child not revealed in update_leaf, falling back to db", + ?reveal_path, + ?decoded, + ?tree_mask, + ?hash_mask, + "Revealing child (from lower)", ); - if let Some(RevealedNode { node, tree_mask, hash_mask }) = - provider.trie_node(&reveal_path)? - { - let decoded = TrieNode::decode(&mut &node[..])?; - trace!( - target: "trie::parallel_sparse", - ?reveal_path, - ?decoded, - ?tree_mask, - ?hash_mask, - "Revealing child (from lower)", - ); - self.reveal_node( - reveal_path, - &decoded, - TrieMasks { hash_mask, tree_mask }, - )?; - } else { - return Err(SparseTrieErrorKind::NodeNotFoundInProvider { - path: reveal_path, - } - .into()) + self.reveal_node( + reveal_path, + &decoded, + TrieMasks { hash_mask, tree_mask }, + )?; + } else { + return Err(SparseTrieErrorKind::NodeNotFoundInProvider { + path: reveal_path, } + .into()) } } diff --git a/crates/trie/sparse/src/trie.rs b/crates/trie/sparse/src/trie.rs index d0bd94b28d..76dadc8fc9 100644 --- a/crates/trie/sparse/src/trie.rs +++ b/crates/trie/sparse/src/trie.rs @@ -975,14 +975,14 @@ impl SparseTrieInterface for SerialSparseTrie { expected_value: Option<&Vec>, path: &Nibbles, ) -> Result<(), LeafLookupError> { - if let Some(expected) = expected_value { - if actual_value != expected { - return Err(LeafLookupError::ValueMismatch { - path: *path, - expected: Some(expected.clone()), - actual: actual_value.clone(), - }); - } + if let Some(expected) = expected_value && + actual_value != expected + { + return Err(LeafLookupError::ValueMismatch { + path: *path, + expected: Some(expected.clone()), + actual: actual_value.clone(), + }); } Ok(()) } diff --git a/crates/trie/trie/src/node_iter.rs b/crates/trie/trie/src/node_iter.rs index c2ae162ccd..5d0b7b496f 100644 --- a/crates/trie/trie/src/node_iter.rs +++ b/crates/trie/trie/src/node_iter.rs @@ -122,16 +122,16 @@ where /// /// If `metrics` feature is enabled, also updates the metrics. fn seek_hashed_entry(&mut self, key: B256) -> Result, DatabaseError> { - if let Some((last_key, last_value)) = self.last_next_result { - if last_key == key { - trace!(target: "trie::node_iter", seek_key = ?key, "reusing result from last next() call instead of seeking"); - self.last_next_result = None; // Consume the cached value + if let Some((last_key, last_value)) = self.last_next_result && + last_key == key + { + trace!(target: "trie::node_iter", seek_key = ?key, "reusing result from last next() call instead of seeking"); + self.last_next_result = None; // Consume the cached value - let result = Some((last_key, last_value)); - self.last_seeked_hashed_entry = Some(SeekedHashedEntry { seeked_key: key, result }); + let result = Some((last_key, last_value)); + self.last_seeked_hashed_entry = Some(SeekedHashedEntry { seeked_key: key, result }); - return Ok(result); - } + return Ok(result); } if let Some(entry) = self diff --git a/crates/trie/trie/src/trie_cursor/in_memory.rs b/crates/trie/trie/src/trie_cursor/in_memory.rs index 5a0223e180..7f6e1f1052 100644 --- a/crates/trie/trie/src/trie_cursor/in_memory.rs +++ b/crates/trie/trie/src/trie_cursor/in_memory.rs @@ -200,10 +200,10 @@ mod tests { let mut results = Vec::new(); - if let Some(first_expected) = test_case.expected_results.first() { - if let Ok(Some(entry)) = cursor.seek(first_expected.0) { - results.push(entry); - } + if let Some(first_expected) = test_case.expected_results.first() && + let Ok(Some(entry)) = cursor.seek(first_expected.0) + { + results.push(entry); } while let Ok(Some(entry)) = cursor.next() { diff --git a/crates/trie/trie/src/verify.rs b/crates/trie/trie/src/verify.rs index e5cb94cade..391852fda6 100644 --- a/crates/trie/trie/src/verify.rs +++ b/crates/trie/trie/src/verify.rs @@ -73,11 +73,11 @@ impl Iterator for StateRootBranchNodesIter { loop { // If we already started iterating through a storage trie's updates, continue doing // so. - if let Some((account, storage_updates)) = self.curr_storage.as_mut() { - if let Some((path, node)) = storage_updates.pop() { - let node = BranchNode::Storage(*account, path, node); - return Some(Ok(node)) - } + if let Some((account, storage_updates)) = self.curr_storage.as_mut() && + let Some((path, node)) = storage_updates.pop() + { + let node = BranchNode::Storage(*account, path, node); + return Some(Ok(node)) } // If there's not a storage trie already being iterated over than check if there's a diff --git a/crates/trie/trie/src/walker.rs b/crates/trie/trie/src/walker.rs index 9a335412d5..5be5f4f6fd 100644 --- a/crates/trie/trie/src/walker.rs +++ b/crates/trie/trie/src/walker.rs @@ -316,13 +316,13 @@ impl> TrieWalker { // Sanity check that the newly retrieved trie node key is the child of the last item // on the stack. If not, advance to the next sibling instead of adding the node to the // stack. - if let Some(subnode) = self.stack.last() { - if !key.starts_with(subnode.full_key()) { - #[cfg(feature = "metrics")] - self.metrics.inc_out_of_order_subnode(1); - self.move_to_next_sibling(false)?; - return Ok(()) - } + if let Some(subnode) = self.stack.last() && + !key.starts_with(subnode.full_key()) + { + #[cfg(feature = "metrics")] + self.metrics.inc_out_of_order_subnode(1); + self.move_to_next_sibling(false)?; + return Ok(()) } // Create a new CursorSubNode and push it to the stack. @@ -333,10 +333,10 @@ impl> TrieWalker { // Delete the current node if it's included in the prefix set or it doesn't contain the root // hash. - if !self.can_skip_current_node || position.is_child() { - if let Some((keys, key)) = self.removed_keys.as_mut().zip(self.cursor.current()?) { - keys.insert(key); - } + if (!self.can_skip_current_node || position.is_child()) && + let Some((keys, key)) = self.removed_keys.as_mut().zip(self.cursor.current()?) + { + keys.insert(key); } Ok(()) diff --git a/docs/vocs/docs/snippets/sources/exex/hello-world/Cargo.toml b/docs/vocs/docs/snippets/sources/exex/hello-world/Cargo.toml index e5d32a1405..d3438032ec 100644 --- a/docs/vocs/docs/snippets/sources/exex/hello-world/Cargo.toml +++ b/docs/vocs/docs/snippets/sources/exex/hello-world/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "my-exex" version = "0.1.0" -edition = "2021" +edition = "2024" [dependencies] reth = { git = "https://github.com/paradigmxyz/reth.git" } # Reth diff --git a/docs/vocs/docs/snippets/sources/exex/remote/Cargo.toml b/docs/vocs/docs/snippets/sources/exex/remote/Cargo.toml index bbc4fe595c..4d170be57c 100644 --- a/docs/vocs/docs/snippets/sources/exex/remote/Cargo.toml +++ b/docs/vocs/docs/snippets/sources/exex/remote/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "remote-exex" version = "0.1.0" -edition = "2021" +edition = "2024" [dependencies] # reth diff --git a/docs/vocs/docs/snippets/sources/exex/tracking-state/Cargo.toml b/docs/vocs/docs/snippets/sources/exex/tracking-state/Cargo.toml index 1fc940214c..658608cac2 100644 --- a/docs/vocs/docs/snippets/sources/exex/tracking-state/Cargo.toml +++ b/docs/vocs/docs/snippets/sources/exex/tracking-state/Cargo.toml @@ -1,7 +1,7 @@ [package] name = "tracking-state" version = "0.1.0" -edition = "2021" +edition = "2024" [dependencies] reth = { git = "https://github.com/paradigmxyz/reth.git" } diff --git a/examples/custom-inspector/src/main.rs b/examples/custom-inspector/src/main.rs index 2a182ed871..f7accf0e8c 100644 --- a/examples/custom-inspector/src/main.rs +++ b/examples/custom-inspector/src/main.rs @@ -56,43 +56,43 @@ fn main() { let tx = event.transaction; println!("Transaction received: {tx:?}"); - if let Some(recipient) = tx.to() { - if args.is_match(&recipient) { - // convert the pool transaction - let call_request = - TransactionRequest::from_recovered_transaction(tx.to_consensus()); + if let Some(recipient) = tx.to() && + args.is_match(&recipient) + { + // convert the pool transaction + let call_request = + TransactionRequest::from_recovered_transaction(tx.to_consensus()); - let evm_config = node.evm_config.clone(); + let evm_config = node.evm_config.clone(); - let result = eth_api - .spawn_with_call_at( - call_request, - BlockNumberOrTag::Latest.into(), - EvmOverrides::default(), - move |db, evm_env, tx_env| { - let mut dummy_inspector = DummyInspector::default(); - let mut evm = evm_config.evm_with_env_and_inspector( - db, - evm_env, - &mut dummy_inspector, - ); - // execute the transaction on a blocking task and await - // the - // inspector result - let _ = evm.transact(tx_env)?; - Ok(dummy_inspector) - }, - ) - .await; + let result = eth_api + .spawn_with_call_at( + call_request, + BlockNumberOrTag::Latest.into(), + EvmOverrides::default(), + move |db, evm_env, tx_env| { + let mut dummy_inspector = DummyInspector::default(); + let mut evm = evm_config.evm_with_env_and_inspector( + db, + evm_env, + &mut dummy_inspector, + ); + // execute the transaction on a blocking task and await + // the + // inspector result + let _ = evm.transact(tx_env)?; + Ok(dummy_inspector) + }, + ) + .await; - if let Ok(ret_val) = result { - let hash = tx.hash(); - println!( - "Inspector result for transaction {}: \n {}", - hash, - ret_val.ret_val.join("\n") - ); - } + if let Ok(ret_val) = result { + let hash = tx.hash(); + println!( + "Inspector result for transaction {}: \n {}", + hash, + ret_val.ret_val.join("\n") + ); } } } diff --git a/examples/txpool-tracing/src/main.rs b/examples/txpool-tracing/src/main.rs index 15d8a9ae08..f510a3f68b 100644 --- a/examples/txpool-tracing/src/main.rs +++ b/examples/txpool-tracing/src/main.rs @@ -44,17 +44,17 @@ fn main() { let tx = event.transaction; println!("Transaction received: {tx:?}"); - if let Some(recipient) = tx.to() { - if args.is_match(&recipient) { - // trace the transaction with `trace_call` - let callrequest = - TransactionRequest::from_recovered_transaction(tx.to_consensus()); - let tracerequest = TraceCallRequest::new(callrequest) - .with_trace_type(TraceType::Trace); - if let Ok(trace_result) = traceapi.trace_call(tracerequest).await { - let hash = tx.hash(); - println!("trace result for transaction {hash}: {trace_result:?}"); - } + if let Some(recipient) = tx.to() && + args.is_match(&recipient) + { + // trace the transaction with `trace_call` + let callrequest = + TransactionRequest::from_recovered_transaction(tx.to_consensus()); + let tracerequest = + TraceCallRequest::new(callrequest).with_trace_type(TraceType::Trace); + if let Ok(trace_result) = traceapi.trace_call(tracerequest).await { + let hash = tx.hash(); + println!("trace result for transaction {hash}: {trace_result:?}"); } } } diff --git a/rustfmt.toml b/rustfmt.toml index 68c3c93033..bf86a53508 100644 --- a/rustfmt.toml +++ b/rustfmt.toml @@ -1,3 +1,4 @@ +style_edition = "2021" reorder_imports = true imports_granularity = "Crate" use_small_heuristics = "Max"