feat: pre-warming cache to build Keyset for all the transactions

.gitignore

@@ -75,3 +75,55 @@ __pycache__/
 # direnv
 .envrc
 .direnv/
+
+# Pre-warming benchmark and test artifacts
+.devnet-sim-v2-*/
+.devnet-simulation-*/
+.benchmark-*/
+.high-load-benchmark-*/
+.realistic-benchmark-*/
+.reliable-bench-*/
+.prod-bench-*/
+.tps-test-*/
+.quick-test-*/
+.max-workers-test*/
+.worker-test/
+.chain-id-test/
+.eoa-debug/
+.final-test/
+.test-*/
+.load_test_results
+.multi_sender_benchmark_results
+.prod_benchmark_results
+.reliable_benchmark_results
+.sustained_benchmark_results
+.tps_results
+
+# Benchmark/test log files
+*.log
+benchmark_*.txt
+benchmark_report*.txt
+benchmark_summary.txt
+build_final.log
+build_output.txt
+debug_output.txt
+prod_bench_output.txt
+test_output.txt
+test_final_result.txt
+validation_results.txt
+op-reth.pid
+
+# Test capture files
+test_capture*.json
+
+# Misc test scripts not meant for repo
+diagnose-prewarming.sh
+test-prewarming-*.sh
+test-prewarming-*.py
+.devnet-test/
+JIRA_FULL_EVM_SIMULATION.md
+benchmark_report.md
+continuous_benchmark_report.md
+docs/profiling-prewarming/
+my-docs/
+run-docs/

Cargo.toml

@@ -702,6 +702,7 @@ snmalloc-rs = { version = "0.3.7", features = ["build_cc"] }
 aes = "0.8.1"
 ahash = "0.8"
 anyhow = "1.0"
+nohash-hasher = "0.2"
 bindgen = { version = "0.71", default-features = false }
 block-padding = "0.3.2"
 cc = "1.2.15"

bin/reth/Cargo.toml

@@ -100,6 +100,13 @@ js-tracer = [
 
 dev = ["reth-ethereum-cli/dev"]
 
+# Pre-warming cache for transaction simulation
+# Extracts state keys via simulation before execution, batch-fetches to reduce I/O
+pre-warming = [
+    "reth-transaction-pool/pre-warming",
+    "reth-node-core/pre-warming",
+]
+
 asm-keccak = [
     "reth-node-core/asm-keccak",
     "reth-primitives/asm-keccak",

crates/engine/local/Cargo.toml

@@ -34,15 +34,13 @@ eyre.workspace = true
 tracing.workspace = true
 
 op-alloy-rpc-types-engine = { workspace = true, optional = true }
-reth-optimism-chainspec = { workspace = true, optional = true }
 
 [lints]
 workspace = true
 
 [features]
 op = [
     "dep:op-alloy-rpc-types-engine",
-    "dep:reth-optimism-chainspec",
     "reth-payload-primitives/op",
     "reth-primitives-traits/op",
 ]

crates/engine/local/src/payload.rs

@@ -72,17 +72,44 @@ where
         &self,
         parent: &SealedHeader<ChainSpec::Header>,
     ) -> op_alloy_rpc_types_engine::OpPayloadAttributes {
+        use alloy_primitives::B64;
+        use reth_chainspec::BaseFeeParams;
+        use std::env;
+        /// Dummy system transaction for dev mode.
+        /// OP Mainnet transaction at index 0 in block 124665056.
+        ///
+        /// <https://optimistic.etherscan.io/tx/0x312e290cf36df704a2217b015d6455396830b0ce678b860ebfcc30f41403d7b1>
+        const TX_SET_L1_BLOCK_OP_MAINNET_BLOCK_124665056: [u8; 251] = alloy_primitives::hex!(
+            "7ef8f8a0683079df94aa5b9cf86687d739a60a9b4f0835e520ec4d664e2e415dca17a6df94deaddeaddeaddeaddeaddeaddeaddeaddead00019442000000000000000000000000000000000000158080830f424080b8a4440a5e200000146b000f79c500000000000000040000000066d052e700000000013ad8a3000000000000000000000000000000000000000000000000000000003ef1278700000000000000000000000000000000000000000000000000000000000000012fdf87b89884a61e74b322bbcf60386f543bfae7827725efaaf0ab1de2294a590000000000000000000000006887246668a3b87f54deb3b94ba47a6f63f32985"
+        );
+
+        // Configure EIP-1559 parameters for dev mode. These can be overridden via environment
+        // variables (OP_DEV_EIP1559_DENOMINATOR, OP_DEV_EIP1559_ELASTICITY, OP_DEV_GAS_LIMIT),
+        // otherwise defaults from Optimism's BaseFeeParams are used. The parameters are encoded
+        // as an 8-byte value (denominator + elasticity) required by Optimism's Jovian fork.
+        let default_eip_1559_params = BaseFeeParams::optimism();
+        let denominator = env::var("OP_DEV_EIP1559_DENOMINATOR")
+            .ok()
+            .and_then(|v| v.parse::<u32>().ok())
+            .unwrap_or(default_eip_1559_params.max_change_denominator as u32);
+        let elasticity = env::var("OP_DEV_EIP1559_ELASTICITY")
+            .ok()
+            .and_then(|v| v.parse::<u32>().ok())
+            .unwrap_or(default_eip_1559_params.elasticity_multiplier as u32);
+        let gas_limit = env::var("OP_DEV_GAS_LIMIT").ok().and_then(|v| v.parse::<u64>().ok());
+
+        let mut eip1559_bytes = [0u8; 8];
+        eip1559_bytes[0..4].copy_from_slice(&denominator.to_be_bytes());
+        eip1559_bytes[4..8].copy_from_slice(&elasticity.to_be_bytes());
+        let eip_1559_params = Some(B64::from(eip1559_bytes));
+
         op_alloy_rpc_types_engine::OpPayloadAttributes {
             payload_attributes: self.build(parent),
-            // Add dummy system transaction
-            transactions: Some(vec![
-                reth_optimism_chainspec::constants::TX_SET_L1_BLOCK_OP_MAINNET_BLOCK_124665056
-                    .into(),
-            ]),
+            transactions: Some(vec![TX_SET_L1_BLOCK_OP_MAINNET_BLOCK_124665056.into()]),
             no_tx_pool: None,
-            gas_limit: None,
-            eip_1559_params: None,
-            min_base_fee: None,
+            gas_limit,
+            eip_1559_params,
+            min_base_fee: Some(0),
         }
     }
 }

crates/engine/tree/src/tree/mod.rs

@@ -1448,7 +1448,6 @@ where
                             self.canonical_in_memory_state.set_pending_block(block.clone());
                         }
 
-                        let insert_tree_start = Instant::now();
                         self.state.tree_state.insert_executed(block.clone());
                         self.payload_validator.on_inserted_executed_block(block.clone());
                         self.metrics.engine.inserted_already_executed_blocks.increment(1);

crates/engine/tree/src/tree/payload_processor/multiproof.rs

@@ -48,13 +48,13 @@ impl From<StateChangeSource> for Source {
     }
 }
 
-/// Maximum number of targets to batch together for prefetch batching.
+/// Maximum number of targets to batch together for prefetch pre-warming.
 /// Prefetches are just proof requests (no state merging), so we allow a higher cap than state
 /// updates
 const PREFETCH_MAX_BATCH_TARGETS: usize = 512;
 
 /// Maximum number of prefetch messages to batch together.
-/// Prevents excessive batching even with small messages.
+/// Prevents excessive pre-warming even with small messages.
 const PREFETCH_MAX_BATCH_MESSAGES: usize = 16;
 
 /// The default max targets, for limiting the number of account and storage proof targets to be
@@ -815,11 +815,11 @@ impl MultiProofTask {
             .filter(|proof| !proof.is_empty())
     }
 
-    /// Processes a multiproof message, batching consecutive prefetch messages.
+    /// Processes a multiproof message, pre-warming consecutive prefetch messages.
     ///
     /// For prefetch messages, drains queued prefetch messages and merges them into one batch before
     /// processing, storing one pending message (different type or over-cap) to handle on the next
-    /// iteration. State updates are processed directly without batching.
+    /// iteration. State updates are processed directly without pre-warming.
     ///
     /// Returns `true` if done, `false` to continue.
     fn process_multiproof_message<P>(
@@ -851,7 +851,7 @@ impl MultiProofTask {
 
                 // Batch consecutive prefetch messages up to limits.
                 // EmptyProof messages are handled inline since they're very fast (~100ns)
-                // and shouldn't interrupt batching.
+                // and shouldn't interrupt pre-warming.
                 while accumulated_count < PREFETCH_MAX_BATCH_TARGETS &&
                     ctx.accumulated_prefetch_targets.len() < PREFETCH_MAX_BATCH_MESSAGES
                 {
@@ -867,7 +867,7 @@ impl MultiProofTask {
                             ctx.accumulated_prefetch_targets.push(next_targets);
                         }
                         Ok(MultiProofMessage::EmptyProof { sequence_number, state }) => {
-                            // Handle inline - very fast, don't break batching
+                            // Handle inline - very fast, don't break pre-warming
                             batch_metrics.proofs_processed += 1;
                             if let Some(combined_update) = self.on_proof(
                                 sequence_number,
@@ -1177,14 +1177,14 @@ impl MultiProofTask {
     }
 }
 
-/// Context for multiproof message batching loop.
+/// Context for multiproof message pre-warming loop.
 ///
 /// Contains processing state that persists across loop iterations.
 ///
 /// Used by `process_multiproof_message` to batch consecutive prefetch messages received via
 /// `try_recv` for efficient processing.
 struct MultiproofBatchCtx {
-    /// Buffers a non-matching message type encountered during batching.
+    /// Buffers a non-matching message type encountered during pre-warming.
     /// Processed first in next iteration to preserve ordering while allowing same-type
     /// messages to batch.
     pending_msg: Option<MultiProofMessage>,
@@ -1195,7 +1195,7 @@ struct MultiproofBatchCtx {
     /// Timestamp when state updates finished. `Some` indicates all state updates have been
     /// received.
     updates_finished_time: Option<Instant>,
-    /// Reusable buffer for accumulating prefetch targets during batching.
+    /// Reusable buffer for accumulating prefetch targets during pre-warming.
     accumulated_prefetch_targets: Vec<MultiProofTargets>,
 }
 
@@ -1759,7 +1759,7 @@ mod tests {
 
         let proofs_requested =
             if let Ok(MultiProofMessage::PrefetchProofs(targets)) = task.rx.recv() {
-                // simulate the batching logic
+                // simulate the pre-warming logic
                 let mut merged_targets = targets;
                 let mut num_batched = 1;
                 while let Ok(MultiProofMessage::PrefetchProofs(next_targets)) = task.rx.try_recv() {
@@ -1971,7 +1971,7 @@ mod tests {
         assert!(matches!(pending, MultiProofMessage::StateUpdate(_, _)));
 
         // Pending message should be handled before the next select loop.
-        // StateUpdate is processed directly without batching.
+        // StateUpdate is processed directly without pre-warming.
         assert!(!task.process_multiproof_message(
             pending,
             &mut ctx,

crates/engine/tree/src/tree/payload_processor/prewarm.rs

@@ -743,7 +743,8 @@ where
         let saved_cache = saved_cache.expect("BAL prewarm should only run with cache");
         let caches = saved_cache.cache().clone();
         let cache_metrics = saved_cache.metrics().clone();
-        let state_provider = CachedStateProvider::new(state_provider, caches, cache_metrics);
+        let state_provider =
+            CachedStateProvider::new(state_provider, caches, cache_metrics).prewarm();
 
         let start = Instant::now();
 

crates/ethereum/evm/Cargo.toml

@@ -20,7 +20,6 @@ reth-ethereum-primitives.workspace = true
 revm.workspace = true
 reth-evm.workspace = true
 reth-storage-errors.workspace = true
-reth-node-metrics.workspace = true
 
 # Alloy
 alloy-primitives.workspace = true