linter fixes

Author: niran

crates/flashblocks-rpc/src/pending_blocks.rs

@@ -10,7 +10,10 @@ use alloy_rpc_types_eth::{Filter, Header as RPCHeader, Log};
 use eyre::eyre;
 use op_alloy_network::Optimism;
 use op_alloy_rpc_types::{OpTransactionReceipt, Transaction};
-use reth::revm::{db::{BundleState, Cache}, state::EvmState};
+use reth::revm::{
+    db::{BundleState, Cache},
+    state::EvmState,
+};
 use reth_rpc_eth_api::RpcBlock;
 
 use crate::subscription::Flashblock;

crates/flashblocks-rpc/src/state.rs

@@ -21,7 +21,6 @@ use reth::providers::{BlockReaderIdExt, StateProviderFactory};
 use reth::revm::context::result::ResultAndState;
 use reth::revm::database::StateProviderDatabase;
 use reth::revm::db::CacheDB;
-use revm_database::states::bundle_state::BundleRetention;
 use reth::revm::{DatabaseCommit, State};
 use reth_evm::{ConfigureEvm, Evm};
 use reth_optimism_chainspec::OpHardforks;
@@ -31,6 +30,7 @@ use reth_optimism_rpc::OpReceiptBuilder;
 use reth_primitives::RecoveredBlock;
 use reth_rpc_convert::{transaction::ConvertReceiptInput, RpcTransaction};
 use reth_rpc_eth_api::{RpcBlock, RpcReceipt};
+use revm_database::states::bundle_state::BundleRetention;
 use std::collections::{BTreeMap, HashSet};
 use std::sync::Arc;
 use std::time::Instant;

crates/metering/src/flashblock_trie_cache.rs

@@ -92,10 +92,12 @@ impl FlashblockTrieCache {
         // Need to compute the flashblock trie (this will replace any existing cache entry)
 
         // Compute hashed post state from the bundle
-        let hashed_state = canonical_state_provider.hashed_post_state(&flashblocks_state.bundle_state);
+        let hashed_state =
+            canonical_state_provider.hashed_post_state(&flashblocks_state.bundle_state);
 
         // Calculate state root with updates to get the trie nodes
-        let (_state_root, trie_updates) = canonical_state_provider.state_root_with_updates(hashed_state.clone())?;
+        let (_state_root, trie_updates) =
+            canonical_state_provider.state_root_with_updates(hashed_state.clone())?;
 
         // Create the trie data
         let trie_data = FlashblockTrieData {

crates/metering/src/meter.rs

@@ -65,11 +65,15 @@ where
 
     // If we have flashblocks but no cached trie, compute the flashblock trie first
     // (before starting any timers, since we only want to time the bundle's execution and state root)
-    let flashblock_trie = if cached_flashblock_trie.is_none() && flashblocks_state.is_some() {
-        let fb_state = flashblocks_state.as_ref().unwrap();
-        let fb_hashed_state = state_provider.hashed_post_state(&fb_state.bundle_state);
-        let (_fb_state_root, fb_trie_updates) = state_provider.state_root_with_updates(fb_hashed_state.clone())?;
-        Some((fb_trie_updates, fb_hashed_state))
+    let flashblock_trie = if cached_flashblock_trie.is_none() {
+        if let Some(ref fb_state) = flashblocks_state {
+            let fb_hashed_state = state_provider.hashed_post_state(&fb_state.bundle_state);
+            let (_fb_state_root, fb_trie_updates) =
+                state_provider.state_root_with_updates(fb_hashed_state.clone())?;
+            Some((fb_trie_updates, fb_hashed_state))
+        } else {
+            None
+        }
     } else {
         None
     };

crates/metering/src/rpc.rs

@@ -74,49 +74,51 @@ where
 
         // Get header and flashblock index from pending blocks
         // If no pending blocks exist, fall back to latest canonical block
-        let (header, flashblock_index, canonical_block_number) = if let Some(pb) = pending_blocks.as_ref() {
-            let latest_header: Sealed<Header> = pb.latest_header();
-            let flashblock_index = pb.latest_flashblock_index();
-            let canonical_block_number = pb.canonical_block_number();
-
-            info!(
-                latest_block = latest_header.number,
-                canonical_block = %canonical_block_number,
-                flashblock_index = flashblock_index,
-                "Using latest flashblock state for metering"
-            );
-
-            // Convert Sealed<Header> to SealedHeader
-            let sealed_header = SealedHeader::new(latest_header.inner().clone(), latest_header.hash());
-            (sealed_header, flashblock_index, canonical_block_number)
-        } else {
-            // No pending blocks, use latest canonical block
-            let canonical_block_number = pending_blocks.get_canonical_block_number();
-            let header = self
-                .provider
-                .sealed_header_by_number_or_tag(canonical_block_number)
-                .map_err(|e| {
-                    jsonrpsee::types::ErrorObjectOwned::owned(
-                        jsonrpsee::types::ErrorCode::InternalError.code(),
-                        format!("Failed to get canonical block header: {}", e),
-                        None::<()>,
-                    )
-                })?
-                .ok_or_else(|| {
-                    jsonrpsee::types::ErrorObjectOwned::owned(
-                        jsonrpsee::types::ErrorCode::InternalError.code(),
-                        "Canonical block not found".to_string(),
-                        None::<()>,
-                    )
-                })?;
-
-            info!(
-                canonical_block = header.number,
-                "No flashblocks available, using canonical block state for metering"
-            );
-
-            (header, 0, canonical_block_number)
-        };
+        let (header, flashblock_index, canonical_block_number) =
+            if let Some(pb) = pending_blocks.as_ref() {
+                let latest_header: Sealed<Header> = pb.latest_header();
+                let flashblock_index = pb.latest_flashblock_index();
+                let canonical_block_number = pb.canonical_block_number();
+
+                info!(
+                    latest_block = latest_header.number,
+                    canonical_block = %canonical_block_number,
+                    flashblock_index = flashblock_index,
+                    "Using latest flashblock state for metering"
+                );
+
+                // Convert Sealed<Header> to SealedHeader
+                let sealed_header =
+                    SealedHeader::new(latest_header.inner().clone(), latest_header.hash());
+                (sealed_header, flashblock_index, canonical_block_number)
+            } else {
+                // No pending blocks, use latest canonical block
+                let canonical_block_number = pending_blocks.get_canonical_block_number();
+                let header = self
+                    .provider
+                    .sealed_header_by_number_or_tag(canonical_block_number)
+                    .map_err(|e| {
+                        jsonrpsee::types::ErrorObjectOwned::owned(
+                            jsonrpsee::types::ErrorCode::InternalError.code(),
+                            format!("Failed to get canonical block header: {}", e),
+                            None::<()>,
+                        )
+                    })?
+                    .ok_or_else(|| {
+                        jsonrpsee::types::ErrorObjectOwned::owned(
+                            jsonrpsee::types::ErrorCode::InternalError.code(),
+                            "Canonical block not found".to_string(),
+                            None::<()>,
+                        )
+                    })?;
+
+                info!(
+                    canonical_block = header.number,
+                    "No flashblocks available, using canonical block state for metering"
+                );
+
+                (header, 0, canonical_block_number)
+            };
 
         // Manually decode transactions to OpTxEnvelope (op-alloy 0.20) instead of using
         // BundleWithMetadata.transactions() which returns op-alloy 0.21 types incompatible with reth.
@@ -162,7 +164,9 @@ where
         });
 
         // Get the flashblock index if we have pending flashblocks
-        let state_flashblock_index = pending_blocks.as_ref().map(|pb| pb.latest_flashblock_index());
+        let state_flashblock_index = pending_blocks
+            .as_ref()
+            .map(|pb| pb.latest_flashblock_index());
 
         // If we have flashblocks, ensure the trie is cached and get it
         let cached_trie = if let Some(ref fb_state) = flashblocks_state {
@@ -171,12 +175,7 @@ where
             // Ensure the flashblock trie is cached and return it
             Some(
                 self.trie_cache
-                    .ensure_cached(
-                        header.hash(),
-                        fb_index,
-                        fb_state,
-                        &*state_provider,
-                    )
+                    .ensure_cached(header.hash(), fb_index, fb_state, &*state_provider)
                     .map_err(|e| {
                         error!(error = %e, "Failed to cache flashblock trie");
                         jsonrpsee::types::ErrorObjectOwned::owned(

crates/metering/src/tests/rpc.rs

@@ -174,7 +174,10 @@ mod tests {
         assert!(response.total_execution_time_us > 0);
 
         // Verify state root time is present and non-zero
-        assert!(response.state_root_time_us > 0, "state_root_time_us should be greater than zero");
+        assert!(
+            response.state_root_time_us > 0,
+            "state_root_time_us should be greater than zero"
+        );
 
         // Verify invariant: total execution time includes state root time
         assert!(