Merge branch 'main' into storage_request_chunking

Author: rodrigo-o

.tool-versions

@@ -1,2 +1,2 @@
-rust 1.87.0
+rust 1.90.0
 # golang 1.23.2

Dockerfile

@@ -1,4 +1,4 @@
-FROM rust:1.87 AS chef
+FROM rust:1.90 AS chef
 
 RUN apt-get update && apt-get install -y \
     build-essential \
@@ -58,7 +58,7 @@ RUN cargo build --release $BUILD_FLAGS
 # --- Final Image ---
 # Copy the ethrex binary into a minimalist image to reduce bloat size.
 # This image must have glibc and libssl
-FROM debian:12-slim
+FROM ubuntu:24.04
 WORKDIR /usr/local/bin
 
 RUN apt-get update && apt-get install -y --no-install-recommends libssl3

crates/blockchain/blockchain.rs

@@ -275,23 +275,21 @@ impl Blockchain {
                     ChainError::WitnessGeneration("Failed to access account from trie".to_string())
                 })?;
                 // Get storage trie at before updates
-                if !acc_keys.is_empty() {
-                    if let Ok(Some(storage_trie)) = self.storage.storage_trie(parent_hash, *account)
-                    {
-                        let (storage_trie_witness, storage_trie) =
-                            TrieLogger::open_trie(storage_trie);
-                        // Access all the keys
-                        for storage_key in acc_keys {
-                            let hashed_key = hash_key(storage_key);
-                            storage_trie.get(&hashed_key).map_err(|_e| {
-                                ChainError::WitnessGeneration(
-                                    "Failed to access storage key".to_string(),
-                                )
-                            })?;
-                        }
-                        // Store the tries to reuse when applying account updates
-                        used_storage_tries.insert(*account, (storage_trie_witness, storage_trie));
+                if !acc_keys.is_empty()
+                    && let Ok(Some(storage_trie)) = self.storage.storage_trie(parent_hash, *account)
+                {
+                    let (storage_trie_witness, storage_trie) = TrieLogger::open_trie(storage_trie);
+                    // Access all the keys
+                    for storage_key in acc_keys {
+                        let hashed_key = hash_key(storage_key);
+                        storage_trie.get(&hashed_key).map_err(|_e| {
+                            ChainError::WitnessGeneration(
+                                "Failed to access storage key".to_string(),
+                            )
+                        })?;
                     }
+                    // Store the tries to reuse when applying account updates
+                    used_storage_tries.insert(*account, (storage_trie_witness, storage_trie));
                 }
             }
             // Store all the accessed evm bytecodes
@@ -343,10 +341,10 @@ impl Blockchain {
         let state_trie_witness = std::mem::take(&mut *state_trie_witness);
         used_trie_nodes.extend_from_slice(&Vec::from_iter(state_trie_witness.into_iter()));
         // If the witness is empty at least try to store the root
-        if used_trie_nodes.is_empty() {
-            if let Some(root) = root_node {
-                used_trie_nodes.push(root.encode_raw());
-            }
+        if used_trie_nodes.is_empty()
+            && let Some(root) = root_node
+        {
+            used_trie_nodes.push(root.encode_raw());
         }
 
         let mut needed_block_numbers = block_hashes.keys().collect::<Vec<_>>();
@@ -361,10 +359,10 @@ impl Blockchain {
             .saturating_sub(1);
         // The first block number we need is either the parent of the first block number or the earliest block number used by BLOCKHASH
         let mut first_needed_block_number = first_block_header.number.saturating_sub(1);
-        if let Some(block_number_from_logger) = needed_block_numbers.first() {
-            if **block_number_from_logger < first_needed_block_number {
-                first_needed_block_number = **block_number_from_logger;
-            }
+        if let Some(block_number_from_logger) = needed_block_numbers.first()
+            && **block_number_from_logger < first_needed_block_number
+        {
+            first_needed_block_number = **block_number_from_logger;
         }
         let mut block_headers_bytes = Vec::new();
         for block_number in first_needed_block_number..=last_needed_block_number {
@@ -851,10 +849,11 @@ impl Blockchain {
         // If it exists check if the new tx has higher fees
         let tx_to_replace_hash = self.mempool.find_tx_to_replace(sender, nonce, tx)?;
 
-        if let Some(chain_id) = tx.chain_id() {
-            if chain_id != config.chain_id {
-                return Err(MempoolError::InvalidChainId(config.chain_id));
-            }
+        if tx
+            .chain_id()
+            .is_some_and(|chain_id| chain_id != config.chain_id)
+        {
+            return Err(MempoolError::InvalidChainId(config.chain_id));
         }
 
         Ok(tx_to_replace_hash)
@@ -1072,12 +1071,12 @@ pub fn validate_gas_used(
     receipts: &[Receipt],
     block_header: &BlockHeader,
 ) -> Result<(), ChainError> {
-    if let Some(last) = receipts.last() {
-        if last.cumulative_gas_used != block_header.gas_used {
-            return Err(ChainError::InvalidBlock(
-                InvalidBlockError::GasUsedMismatch(last.cumulative_gas_used, block_header.gas_used),
-            ));
-        }
+    if let Some(last) = receipts.last()
+        && last.cumulative_gas_used != block_header.gas_used
+    {
+        return Err(ChainError::InvalidBlock(
+            InvalidBlockError::GasUsedMismatch(last.cumulative_gas_used, block_header.gas_used),
+        ));
     }
     Ok(())
 }

crates/blockchain/fork_choice.rs

@@ -72,30 +72,28 @@ pub async fn apply_fork_choice(
     };
 
     // Check that finalized and safe blocks are part of the new canonical chain.
-    if let Some(ref finalized) = finalized_res {
-        if !((is_canonical(store, finalized.number, finalized_hash).await?
+    if let Some(ref finalized) = finalized_res
+        && !((is_canonical(store, finalized.number, finalized_hash).await?
             && finalized.number <= link_block_number)
             || (finalized.number == head.number && finalized_hash == head_hash)
             || new_canonical_blocks.contains(&(finalized.number, finalized_hash)))
-        {
-            return Err(InvalidForkChoice::Disconnected(
-                error::ForkChoiceElement::Head,
-                error::ForkChoiceElement::Finalized,
-            ));
-        };
+    {
+        return Err(InvalidForkChoice::Disconnected(
+            error::ForkChoiceElement::Head,
+            error::ForkChoiceElement::Finalized,
+        ));
     }
 
-    if let Some(ref safe) = safe_res {
-        if !((is_canonical(store, safe.number, safe_hash).await?
+    if let Some(ref safe) = safe_res
+        && !((is_canonical(store, safe.number, safe_hash).await?
             && safe.number <= link_block_number)
             || (safe.number == head.number && safe_hash == head_hash)
             || new_canonical_blocks.contains(&(safe.number, safe_hash)))
-        {
-            return Err(InvalidForkChoice::Disconnected(
-                error::ForkChoiceElement::Head,
-                error::ForkChoiceElement::Safe,
-            ));
-        };
+    {
+        return Err(InvalidForkChoice::Disconnected(
+            error::ForkChoiceElement::Head,
+            error::ForkChoiceElement::Safe,
+        ));
     }
 
     // Finished all validations.

crates/blockchain/mempool.rs

@@ -200,10 +200,11 @@ impl Mempool {
             }
 
             // Filter by blob gas fee
-            if let (true, Some(blob_fee)) = (is_blob_tx, filter.blob_fee) {
-                if tx.max_fee_per_blob_gas().is_none_or(|fee| fee < blob_fee) {
-                    return false;
-                }
+            if is_blob_tx
+                && let Some(blob_fee) = filter.blob_fee
+                && tx.max_fee_per_blob_gas().is_none_or(|fee| fee < blob_fee)
+            {
+                return false;
             }
             true
         };

crates/blockchain/metrics/metrics_process.rs

@@ -42,18 +42,18 @@ impl MetricsProcess {
                 })?;
         }
 
-        if let Some(path) = DATADIR_PATH.get() {
-            if let Ok(size) = directory_size(path) {
-                let gauge = IntGauge::new(
-                    "datadir_size_bytes",
-                    "Total size in bytes consumed by the configured datadir.",
-                )
+        if let Some(path) = DATADIR_PATH.get()
+            && let Ok(size) = directory_size(path)
+        {
+            let gauge = IntGauge::new(
+                "datadir_size_bytes",
+                "Total size in bytes consumed by the configured datadir.",
+            )
+            .map_err(|e| MetricsError::PrometheusErr(e.to_string()))?;
+            let clamped = size.min(i64::MAX as u64);
+            gauge.set(clamped as i64);
+            r.register(Box::new(gauge))
                 .map_err(|e| MetricsError::PrometheusErr(e.to_string()))?;
-                let clamped = size.min(i64::MAX as u64);
-                gauge.set(clamped as i64);
-                r.register(Box::new(gauge))
-                    .map_err(|e| MetricsError::PrometheusErr(e.to_string()))?;
-            }
         }
 
         let encoder = TextEncoder::new();

crates/blockchain/metrics/profiling.rs

@@ -32,16 +32,16 @@ where
     S: Subscriber + for<'a> LookupSpan<'a>,
 {
     fn on_enter(&self, id: &Id, ctx: Context<'_, S>) {
-        if let Some(span) = ctx.span(id) {
-            if span.metadata().target().starts_with("ethrex") {
-                let name = span.metadata().name();
+        if let Some(span) = ctx.span(id)
+            && span.metadata().target().starts_with("ethrex")
+        {
+            let name = span.metadata().name();
 
-                let timer = METRICS_BLOCK_PROCESSING_PROFILE
-                    .with_label_values(&[name])
-                    .start_timer();
-                let mut timers = self.function_timers.lock().unwrap();
-                timers.insert(id.clone(), timer);
-            }
+            let timer = METRICS_BLOCK_PROCESSING_PROFILE
+                .with_label_values(&[name])
+                .start_timer();
+            let mut timers = self.function_timers.lock().unwrap();
+            timers.insert(id.clone(), timer);
         }
     }
 

crates/common/trie/logger.rs

@@ -35,11 +35,11 @@ impl TrieLogger {
 impl TrieDB for TrieLogger {
     fn get(&self, key: NodeHash) -> Result<Option<Vec<u8>>, TrieError> {
         let result = self.inner_db.get(key)?;
-        if let Some(result) = result.as_ref() {
-            if let Ok(decoded) = Node::decode(result) {
-                let mut lock = self.witness.lock().map_err(|_| TrieError::LockError)?;
-                lock.insert(decoded.encode_raw());
-            };
+        if let Some(result) = result.as_ref()
+            && let Ok(decoded) = Node::decode(result)
+        {
+            let mut lock = self.witness.lock().map_err(|_| TrieError::LockError)?;
+            lock.insert(decoded.encode_raw());
         }
         Ok(result)
     }

crates/common/types/genesis.rs

@@ -631,11 +631,11 @@ impl Genesis {
         let mut blob_gas_used: Option<u64> = None;
         let mut excess_blob_gas: Option<u64> = None;
 
-        if let Some(cancun_time) = self.config.cancun_time {
-            if cancun_time <= self.timestamp {
-                blob_gas_used = Some(self.blob_gas_used.unwrap_or(0));
-                excess_blob_gas = Some(self.excess_blob_gas.unwrap_or(0));
-            }
+        if let Some(cancun_time) = self.config.cancun_time
+            && cancun_time <= self.timestamp
+        {
+            blob_gas_used = Some(self.blob_gas_used.unwrap_or(0));
+            excess_blob_gas = Some(self.excess_blob_gas.unwrap_or(0));
         }
         let base_fee_per_gas = self.base_fee_per_gas.or_else(|| {
             self.config

crates/l2/sdk/src/calldata.rs

@@ -248,7 +248,7 @@ impl DataType {
                     .consume_u256()?
                     .try_into()
                     .map_err(|_| CalldataDecodeError::OutOfBounds)?;
-                let size = if n % 32 == 0 {
+                let size = if n.is_multiple_of(32) {
                     n
                 } else {
                     n.next_multiple_of(32)