fix: update gas_used/gas_refunded to ResultGas API

# Conflicts:
#	Cargo.lock
#	crates/optimism/evm/src/lib.rs

.changelog/fast-waves-smile.md

@@ -1,4 +0,0 @@
----
----
-
-Improved nightly Docker build failure Slack notification with more detailed formatting and context.

.changelog/lively-clouds-bake.md

@@ -1,4 +0,0 @@
----
----
-
-Improved documentation overview page with better structure and clarity.

.changelog/lively-foxes-play.md

@@ -1,5 +0,0 @@
----
-reth-node-events: patch
----
-
-Updated consensus engine log message to be more accurate about received updates.

.changelog/nice-trees-drink.md

@@ -1,9 +0,0 @@
----
-reth-network-api: minor
-reth-network-types: minor
-reth-network: minor
-reth-node-core: minor
-reth: minor
----
-
-Added optional ENR fork ID enforcement to filter out peers from incompatible networks during peer discovery, controlled by the `--enforce-enr-fork-id` CLI flag.

.changelog/tidy-stars-cry.md

@@ -1,5 +0,0 @@
----
-reth-trie-sparse: patch
----
-
-Fixed a bug where trie nodes could appear in both `updated_nodes` and `removed_nodes` simultaneously by removing entries from `removed_nodes` when a node is inserted as updated.

.changelog/zesty-clouds-wave.md

@@ -1,5 +0,0 @@
----
-reth-trie: patch
----
-
-Fixed a potential panic in `ProofCalculator` by clearing internal computation state (`branch_stack`, `child_stack`, `branch_path`, etc.) after errors, preventing stale state from causing `usize` underflow panics when the calculator is reused. Added a test verifying correct behavior after simulated mid-computation errors.

.github/CODEOWNERS

@@ -38,7 +38,7 @@ crates/storage/libmdbx-rs/  @shekhirin
 crates/storage/nippy-jar/   @joshieDo @shekhirin
 crates/storage/provider/    @joshieDo @shekhirin @yongkangc
 crates/storage/storage-api/ @joshieDo
-crates/tasks/               @mattsse @DaniPopes
+crates/tasks/               @mattsse
 crates/tokio-util/          @mattsse 
 crates/tracing/             @mattsse @shekhirin
 crates/tracing-otlp/        @mattsse @Rjected 

.github/workflows/docker.yml

@@ -70,27 +70,18 @@ jobs:
             # Add 'latest' tag for non-RC releases
             if [[ ! "$VERSION" =~ -rc ]]; then
               echo "ethereum_tags=${REGISTRY}/reth:${VERSION},${REGISTRY}/reth:latest" >> "$GITHUB_OUTPUT"
-              {
-                echo "ethereum_set<<EOF"
-                echo "ethereum.tags=${REGISTRY}/reth:${VERSION}"
-                echo "ethereum.tags=${REGISTRY}/reth:latest"
-                echo "EOF"
-              } >> "$GITHUB_OUTPUT"
             else
               echo "ethereum_tags=${REGISTRY}/reth:${VERSION}" >> "$GITHUB_OUTPUT"
-              echo "ethereum_set=ethereum.tags=${REGISTRY}/reth:${VERSION}" >> "$GITHUB_OUTPUT"
             fi
 
           elif [[ "${{ github.event_name }}" == "schedule" ]] || [[ "${{ inputs.build_type }}" == "nightly" ]]; then
             echo "targets=nightly" >> "$GITHUB_OUTPUT"
             echo "ethereum_tags=${REGISTRY}/reth:nightly" >> "$GITHUB_OUTPUT"
-            echo "ethereum_set=ethereum.tags=${REGISTRY}/reth:nightly" >> "$GITHUB_OUTPUT"
 
           else
             # git-sha build
             echo "targets=ethereum" >> "$GITHUB_OUTPUT"
             echo "ethereum_tags=${REGISTRY}/reth:${{ github.sha }}" >> "$GITHUB_OUTPUT"
-            echo "ethereum_set=ethereum.tags=${REGISTRY}/reth:${{ github.sha }}" >> "$GITHUB_OUTPUT"
           fi
 
       - name: Build and push images
@@ -106,7 +97,7 @@ jobs:
           targets: ${{ steps.params.outputs.targets }}
           push: ${{ !(github.event_name == 'workflow_dispatch' && inputs.dry_run) }}
           set: |
-            ${{ steps.params.outputs.ethereum_set }}
+            ethereum.tags=${{ steps.params.outputs.ethereum_tags }}
 
       - name: Verify image architectures
         env:
@@ -126,18 +117,6 @@ jobs:
       - name: Slack Webhook Action
         uses: rtCamp/action-slack-notify@v2
         env:
-          SLACK_COLOR: danger
-          SLACK_ICON_EMOJI: ":rotating_light:"
-          SLACK_USERNAME: "GitHub Actions"
-          SLACK_TITLE: ":rotating_light: Nightly Docker Build Failed"
-          SLACK_MESSAGE: |
-            The scheduled nightly Docker build failed.
-
-            *Commit:* `${{ github.sha }}`
-            *Branch:* `${{ github.ref_name }}`
-            *Run:* <https://github.com/paradigmxyz/reth/actions/runs/${{ github.run_id }}|View logs>
-
-            *Action required:* Re-run the workflow or investigate the build failure.
-          SLACK_FOOTER: "paradigmxyz/reth · docker.yml"
-          MSG_MINIMAL: true
+          SLACK_COLOR: ${{ job.status }}
+          SLACK_MESSAGE: "Failed run: https://github.com/paradigmxyz/reth/actions/runs/${{ github.run_id }}"
           SLACK_WEBHOOK: ${{ secrets.SLACK_WEBHOOK_URL }}

Cargo.toml

@@ -1,5 +1,5 @@
 [workspace.package]
-version = "1.11.3"
+version = "1.10.2"
 edition = "2024"
 rust-version = "1.88"
 license = "MIT OR Apache-2.0"
@@ -449,18 +449,14 @@ revm-inspectors = "0.34.2"
 
 # eth
 alloy-dyn-abi = "1.5.6"
-alloy-primitives = { version = "1.5.6", default-features = false, features = [
-    "map-foldhash",
-] }
+alloy-primitives = { version = "1.5.6", default-features = false, features = ["map-foldhash"] }
 alloy-sol-types = { version = "1.5.6", default-features = false }
 
 alloy-chains = { version = "0.2.5", default-features = false }
 alloy-eip2124 = { version = "0.2.0", default-features = false }
 alloy-eip7928 = { version = "0.3.0", default-features = false }
 alloy-evm = { version = "0.27.2", default-features = false }
-alloy-rlp = { version = "0.3.13", default-features = false, features = [
-    "core-net",
-] }
+alloy-rlp = { version = "0.3.13", default-features = false, features = ["core-net"] }
 alloy-trie = { version = "0.9.4", default-features = false }
 
 alloy-hardforks = "0.4.5"
@@ -472,15 +468,10 @@ alloy-genesis = { version = "1.6.3", default-features = false }
 alloy-json-rpc = { version = "1.6.3", default-features = false }
 alloy-network = { version = "1.6.3", default-features = false }
 alloy-network-primitives = { version = "1.6.3", default-features = false }
-alloy-provider = { version = "1.6.3", features = [
-    "reqwest",
-    "debug-api",
-], default-features = false }
+alloy-provider = { version = "1.6.3", features = ["reqwest", "debug-api"], default-features = false }
 alloy-pubsub = { version = "1.6.3", default-features = false }
 alloy-rpc-client = { version = "1.6.3", default-features = false }
-alloy-rpc-types = { version = "1.6.3", features = [
-    "eth",
-], default-features = false }
+alloy-rpc-types = { version = "1.6.3", features = ["eth"], default-features = false }
 alloy-rpc-types-admin = { version = "1.6.3", default-features = false }
 alloy-rpc-types-anvil = { version = "1.6.3", default-features = false }
 alloy-rpc-types-beacon = { version = "1.6.3", default-features = false }
@@ -494,9 +485,7 @@ alloy-serde = { version = "1.6.3", default-features = false }
 alloy-signer = { version = "1.6.3", default-features = false }
 alloy-signer-local = { version = "1.6.3", default-features = false }
 alloy-transport = { version = "1.6.3" }
-alloy-transport-http = { version = "1.6.3", features = [
-    "reqwest-rustls-tls",
-], default-features = false }
+alloy-transport-http = { version = "1.6.3", features = ["reqwest-rustls-tls"], default-features = false }
 alloy-transport-ipc = { version = "1.6.3", default-features = false }
 alloy-transport-ws = { version = "1.6.3", default-features = false }
 
@@ -515,10 +504,7 @@ either = { version = "1.15.0", default-features = false }
 arrayvec = { version = "0.7.6", default-features = false }
 aquamarine = "0.6"
 auto_impl = "1"
-backon = { version = "1.2", default-features = false, features = [
-    "std-blocking-sleep",
-    "tokio-sleep",
-] }
+backon = { version = "1.2", default-features = false, features = ["std-blocking-sleep", "tokio-sleep"] }
 bincode = "1.3"
 bitflags = "2.4"
 boyer-moore-magiclen = "0.2.16"
@@ -540,13 +526,9 @@ itertools = { version = "0.14", default-features = false }
 linked_hash_set = "0.1"
 lz4 = "1.28.1"
 modular-bitfield = "0.13.1"
-notify = { version = "8.0.0", default-features = false, features = [
-    "macos_fsevent",
-] }
+notify = { version = "8.0.0", default-features = false, features = ["macos_fsevent"] }
 nybbles = { version = "0.4.8", default-features = false }
-once_cell = { version = "1.19", default-features = false, features = [
-    "critical-section",
-] }
+once_cell = { version = "1.19", default-features = false, features = ["critical-section"] }
 parking_lot = "0.12"
 paste = "1.0"
 rand = "0.9"
@@ -565,9 +547,7 @@ strum_macros = "0.27"
 syn = "2.0"
 thiserror = { version = "2.0.0", default-features = false }
 tar = "0.4.44"
-tracing = { version = "0.1.0", default-features = false, features = [
-    "attributes",
-] }
+tracing = { version = "0.1.0", default-features = false, features = ["attributes"] }
 tracing-appender = "0.2"
 url = { version = "2.3", default-features = false }
 zstd = "0.13"
@@ -605,11 +585,7 @@ futures-util = { version = "0.3", default-features = false }
 hyper = "1.3"
 hyper-util = "0.1.5"
 pin-project = "1.0.12"
-reqwest = { version = "0.12", default-features = false, features = [
-    "rustls-tls",
-    "rustls-tls-native-roots",
-    "stream",
-] }
+reqwest = { version = "0.12", default-features = false, features = ["rustls-tls", "rustls-tls-native-roots", "stream"] }
 tracing-futures = "0.2"
 tower = "0.5"
 tower-http = "0.6"
@@ -634,10 +610,7 @@ proptest-arbitrary-interop = "0.1.0"
 # crypto
 enr = { version = "0.13", default-features = false }
 k256 = { version = "0.13", default-features = false, features = ["ecdsa"] }
-secp256k1 = { version = "0.30", default-features = false, features = [
-    "global-context",
-    "recovery",
-] }
+secp256k1 = { version = "0.30", default-features = false, features = ["global-context", "recovery"] }
 # rand 8 for secp256k1
 rand_08 = { package = "rand", version = "0.8" }
 
@@ -738,6 +711,28 @@ vergen-git2 = "9.1.0"
 ipnet = "2.11"
 
 [patch.crates-io]
+# revm staging patches
+revm = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+op-revm = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+revm-bytecode = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+revm-context = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+revm-context-interface = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+revm-database = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+revm-database-interface = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+revm-handler = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+revm-inspector = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+revm-interpreter = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+revm-precompile = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+revm-primitives = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+revm-state = { git = "https://github.com/bluealloy/revm", rev = "33330a285e621b9170c30a21cfea9ab32e2a2169" }
+
+# revm-inspectors staging patch
+revm-inspectors = { git = "https://github.com/paradigmxyz/revm-inspectors", rev = "e80e2eab72dfa18011e6a99abd37027290a46e83" }
+
+# alloy-evm staging patches
+alloy-evm = { git = "https://github.com/alloy-rs/evm", rev = "742dc14749ea0279c03ca27b1c26f26ac19fbefb" }
+alloy-op-evm = { git = "https://github.com/alloy-rs/evm", rev = "742dc14749ea0279c03ca27b1c26f26ac19fbefb" }
+
 # alloy-consensus = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
 # alloy-contract = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
 # alloy-eips = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }

bin/reth-bench/src/bench/gas_limit_ramp.rs

@@ -192,15 +192,6 @@ impl Command {
             parent_header = block.header;
             parent_hash = block_hash;
             blocks_processed += 1;
-
-            let progress = match mode {
-                RampMode::Blocks(total) => format!("{blocks_processed}/{total}"),
-                RampMode::TargetGasLimit(target) => {
-                    let pct = (parent_header.gas_limit as f64 / target as f64 * 100.0).min(100.0);
-                    format!("{pct:.1}%")
-                }
-            };
-            info!(target: "reth-bench", progress, block_number = parent_header.number, gas_limit = parent_header.gas_limit, "Block processed");
         }
 
         let final_gas_limit = parent_header.gas_limit;

bin/reth-bench/src/bench/new_payload_fcu.rs

@@ -153,7 +153,6 @@ impl Command {
             ..
         } = BenchContext::new(&self.benchmark, self.rpc_url).await?;
 
-        let total_blocks = benchmark_mode.total_blocks();
         let buffer_size = self.rpc_block_buffer_size;
 
         // Use a oneshot channel to propagate errors from the spawned task
@@ -207,7 +206,6 @@ impl Command {
         });
 
         let mut results = Vec::new();
-        let mut blocks_processed = 0u64;
         let total_benchmark_duration = Instant::now();
         let mut total_wait_time = Duration::ZERO;
 
@@ -251,13 +249,8 @@ impl Command {
 
             // Exclude time spent waiting on the block prefetch channel from the benchmark duration.
             // We want to measure engine throughput, not RPC fetch latency.
-            blocks_processed += 1;
             let current_duration = total_benchmark_duration.elapsed() - total_wait_time;
-            let progress = match total_blocks {
-                Some(total) => format!("{blocks_processed}/{total}"),
-                None => format!("{blocks_processed}"),
-            };
-            info!(target: "reth-bench", progress, %combined_result);
+            info!(target: "reth-bench", %combined_result);
 
             if let Some(w) = &mut waiter {
                 w.on_block(block_number).await?;

bin/reth-bench/src/bench/new_payload_only.rs

@@ -52,7 +52,6 @@ impl Command {
             ..
         } = BenchContext::new(&self.benchmark, self.rpc_url).await?;
 
-        let total_blocks = benchmark_mode.total_blocks();
         let buffer_size = self.rpc_block_buffer_size;
 
         // Use a oneshot channel to propagate errors from the spawned task
@@ -83,8 +82,8 @@ impl Command {
             }
         });
 
+        // put results in a summary vec so they can be printed at the end
         let mut results = Vec::new();
-        let mut blocks_processed = 0u64;
         let total_benchmark_duration = Instant::now();
         let mut total_wait_time = Duration::ZERO;
 
@@ -106,12 +105,7 @@ impl Command {
             call_new_payload(&auth_provider, version, params).await?;
 
             let new_payload_result = NewPayloadResult { gas_used, latency: start.elapsed() };
-            blocks_processed += 1;
-            let progress = match total_blocks {
-                Some(total) => format!("{blocks_processed}/{total}"),
-                None => format!("{blocks_processed}"),
-            };
-            info!(target: "reth-bench", progress, %new_payload_result);
+            info!(target: "reth-bench", %new_payload_result);
 
             // current duration since the start of the benchmark minus the time
             // waiting for blocks

bin/reth-bench/src/bench/replay_payloads.rs

@@ -341,8 +341,7 @@ impl Command {
             };
 
             let current_duration = total_benchmark_duration.elapsed();
-            let progress = format!("{}/{}", i + 1, payloads.len());
-            info!(target: "reth-bench", progress, %combined_result);
+            info!(target: "reth-bench", %combined_result);
 
             if let Some(w) = &mut waiter {
                 w.on_block(block_number).await?;

bin/reth-bench/src/bench_mode.rs

@@ -20,19 +20,6 @@ impl BenchMode {
         }
     }
 
-    /// Returns the total number of blocks in the benchmark, if known.
-    ///
-    /// For [`BenchMode::Range`] this is the length of the range.
-    /// For [`BenchMode::Continuous`] the total is unbounded, so `None` is returned.
-    pub const fn total_blocks(&self) -> Option<u64> {
-        match self {
-            Self::Continuous(_) => None,
-            Self::Range(range) => {
-                Some(range.end().saturating_sub(*range.start()).saturating_add(1))
-            }
-        }
-    }
-
     /// Create a [`BenchMode`] from optional `from` and `to` fields.
     pub fn new(from: Option<u64>, to: Option<u64>, latest_block: u64) -> Result<Self, eyre::Error> {
         // If neither `--from` nor `--to` are provided, we will run the benchmark continuously,

crates/chain-state/src/deferred_trie.rs

@@ -312,11 +312,6 @@ impl DeferredTrieData {
     /// Given that invariant, circular wait dependencies are impossible.
     #[instrument(level = "debug", target = "engine::tree::deferred_trie", skip_all)]
     pub fn wait_cloned(&self) -> ComputedTrieData {
-        #[cfg(feature = "rayon")]
-        debug_assert!(
-            rayon::current_thread_index().is_none(),
-            "wait_cloned must not be called from a rayon worker thread"
-        );
         let mut state = self.state.lock();
         match &mut *state {
             // If the deferred trie data is ready, return the cached result.

crates/chain-state/src/in_memory.rs

@@ -1061,14 +1061,6 @@ mod tests {
         ) -> ProviderResult<Option<StorageValue>> {
             Ok(None)
         }
-
-        fn storage_by_hashed_key(
-            &self,
-            _address: Address,
-            _hashed_storage_key: StorageKey,
-        ) -> ProviderResult<Option<StorageValue>> {
-            Ok(None)
-        }
     }
 
     impl BytecodeReader for MockStateProvider {

crates/chain-state/src/memory_overlay.rs

@@ -223,26 +223,6 @@ impl<N: NodePrimitives> StateProvider for MemoryOverlayStateProviderRef<'_, N> {
 
         self.historical.storage(address, storage_key)
     }
-
-    fn storage_by_hashed_key(
-        &self,
-        address: Address,
-        hashed_storage_key: StorageKey,
-    ) -> ProviderResult<Option<StorageValue>> {
-        let hashed_address = keccak256(address);
-        let state = &self.trie_input().state;
-
-        if let Some(hs) = state.storages.get(&hashed_address) {
-            if let Some(value) = hs.storage.get(&hashed_storage_key) {
-                return Ok(Some(*value));
-            }
-            if hs.wiped {
-                return Ok(Some(StorageValue::ZERO));
-            }
-        }
-
-        self.historical.storage_by_hashed_key(address, hashed_storage_key)
-    }
 }
 
 impl<N: NodePrimitives> BytecodeReader for MemoryOverlayStateProviderRef<'_, N> {

crates/cli/commands/src/common.rs

@@ -19,7 +19,7 @@ use reth_node_builder::{
     Node, NodeComponents, NodeComponentsBuilder, NodeTypes, NodeTypesWithDBAdapter,
 };
 use reth_node_core::{
-    args::{DatabaseArgs, DatadirArgs, StaticFilesArgs, StorageArgs},
+    args::{DatabaseArgs, DatadirArgs, RocksDbArgs, StaticFilesArgs, StorageArgs},
     dirs::{ChainPath, DataDirPath},
 };
 use reth_provider::{
@@ -67,23 +67,62 @@ pub struct EnvironmentArgs<C: ChainSpecParser> {
     #[command(flatten)]
     pub static_files: StaticFilesArgs,
 
+    /// All `RocksDB` related arguments
+    #[command(flatten)]
+    pub rocksdb: RocksDbArgs,
+
     /// Storage mode configuration (v2 vs v1/legacy)
     #[command(flatten)]
     pub storage: StorageArgs,
 }
 
 impl<C: ChainSpecParser> EnvironmentArgs<C> {
-    /// Returns the effective storage settings derived from `--storage.v2`.
+    /// Returns the effective storage settings derived from `--storage.v2`, static-file, and
+    /// `RocksDB` CLI args.
     ///
     /// The base storage mode is determined by `--storage.v2`:
     /// - When `--storage.v2` is set: uses [`StorageSettings::v2()`] defaults
-    /// - Otherwise: uses [`StorageSettings::base()`] defaults
+    /// - Otherwise: uses [`StorageSettings::v1()`] defaults
+    ///
+    /// Individual `--static-files.*` and `--rocksdb.*` flags override the base when explicitly set.
     pub fn storage_settings(&self) -> StorageSettings {
-        if self.storage.v2 {
-            StorageSettings::v2()
-        } else {
-            StorageSettings::base()
+        let mut s = if self.storage.v2 { StorageSettings::v2() } else { StorageSettings::base() };
+
+        // Apply static files overrides (only when explicitly set)
+        if let Some(v) = self.static_files.receipts {
+            s = s.with_receipts_in_static_files(v);
         }
+        if let Some(v) = self.static_files.transaction_senders {
+            s = s.with_transaction_senders_in_static_files(v);
+        }
+        if let Some(v) = self.static_files.account_changesets {
+            s = s.with_account_changesets_in_static_files(v);
+        }
+        if let Some(v) = self.static_files.storage_changesets {
+            s = s.with_storage_changesets_in_static_files(v);
+        }
+
+        // Apply rocksdb overrides
+        // --rocksdb.all sets all rocksdb flags to true
+        if self.rocksdb.all {
+            s = s
+                .with_transaction_hash_numbers_in_rocksdb(true)
+                .with_storages_history_in_rocksdb(true)
+                .with_account_history_in_rocksdb(true);
+        }
+
+        // Individual rocksdb flags override --rocksdb.all when explicitly set
+        if let Some(v) = self.rocksdb.tx_hash {
+            s = s.with_transaction_hash_numbers_in_rocksdb(v);
+        }
+        if let Some(v) = self.rocksdb.storages_history {
+            s = s.with_storages_history_in_rocksdb(v);
+        }
+        if let Some(v) = self.rocksdb.account_history {
+            s = s.with_account_history_in_rocksdb(v);
+        }
+
+        s
     }
 
     /// Initializes environment according to [`AccessRights`] and returns an instance of

crates/cli/commands/src/db/account_storage.rs

@@ -5,7 +5,6 @@ use reth_codecs::Compact;
 use reth_db_api::{cursor::DbDupCursorRO, database::Database, tables, transaction::DbTx};
 use reth_db_common::DbTool;
 use reth_node_builder::NodeTypesWithDB;
-use reth_storage_api::StorageSettingsCache;
 use std::time::{Duration, Instant};
 use tracing::info;
 
@@ -23,94 +22,52 @@ impl Command {
     /// Execute `db account-storage` command
     pub fn execute<N: NodeTypesWithDB>(self, tool: &DbTool<N>) -> eyre::Result<()> {
         let address = self.address;
-        let use_hashed_state = tool.provider_factory.cached_storage_settings().use_hashed_state();
+        let (slot_count, plain_size) = tool.provider_factory.db_ref().view(|tx| {
+            let mut cursor = tx.cursor_dup_read::<tables::PlainStorageState>()?;
+            let mut count = 0usize;
+            let mut total_value_bytes = 0usize;
+            let mut last_log = Instant::now();
 
-        let (slot_count, storage_size) = if use_hashed_state {
-            let hashed_address = keccak256(address);
-            tool.provider_factory.db_ref().view(|tx| {
-                let mut cursor = tx.cursor_dup_read::<tables::HashedStorages>()?;
-                let mut count = 0usize;
-                let mut total_value_bytes = 0usize;
-                let mut last_log = Instant::now();
+            // Walk all storage entries for this address
+            let walker = cursor.walk_dup(Some(address), None)?;
+            for entry in walker {
+                let (_, storage_entry) = entry?;
+                count += 1;
+                // StorageEntry encodes as: 32 bytes (key/subkey uncompressed) + compressed U256
+                let mut buf = Vec::new();
+                let entry_len = storage_entry.to_compact(&mut buf);
+                total_value_bytes += entry_len;
 
-                let walker = cursor.walk_dup(Some(hashed_address), None)?;
-                for entry in walker {
-                    let (_, storage_entry) = entry?;
-                    count += 1;
-                    let mut buf = Vec::new();
-                    let entry_len = storage_entry.to_compact(&mut buf);
-                    total_value_bytes += entry_len;
-
-                    if last_log.elapsed() >= LOG_INTERVAL {
-                        info!(
-                            target: "reth::cli",
-                            address = %address,
-                            slots = count,
-                            key = %storage_entry.key,
-                            "Processing hashed storage slots"
-                        );
-                        last_log = Instant::now();
-                    }
+                if last_log.elapsed() >= LOG_INTERVAL {
+                    info!(
+                        target: "reth::cli",
+                        address = %address,
+                        slots = count,
+                        key = %storage_entry.key,
+                        "Processing storage slots"
+                    );
+                    last_log = Instant::now();
                 }
+            }
 
-                let total_size = if count > 0 { 32 + total_value_bytes } else { 0 };
+            // Add 20 bytes for the Address key (stored once per account in dupsort)
+            let total_size = if count > 0 { 20 + total_value_bytes } else { 0 };
 
-                Ok::<_, eyre::Report>((count, total_size))
-            })??
-        } else {
-            tool.provider_factory.db_ref().view(|tx| {
-                let mut cursor = tx.cursor_dup_read::<tables::PlainStorageState>()?;
-                let mut count = 0usize;
-                let mut total_value_bytes = 0usize;
-                let mut last_log = Instant::now();
+            Ok::<_, eyre::Report>((count, total_size))
+        })??;
 
-                // Walk all storage entries for this address
-                let walker = cursor.walk_dup(Some(address), None)?;
-                for entry in walker {
-                    let (_, storage_entry) = entry?;
-                    count += 1;
-                    let mut buf = Vec::new();
-                    // StorageEntry encodes as: 32 bytes (key/subkey uncompressed) + compressed U256
-                    let entry_len = storage_entry.to_compact(&mut buf);
-                    total_value_bytes += entry_len;
-
-                    if last_log.elapsed() >= LOG_INTERVAL {
-                        info!(
-                            target: "reth::cli",
-                            address = %address,
-                            slots = count,
-                            key = %storage_entry.key,
-                            "Processing storage slots"
-                        );
-                        last_log = Instant::now();
-                    }
-                }
-
-                // Add 20 bytes for the Address key (stored once per account in dupsort)
-                let total_size = if count > 0 { 20 + total_value_bytes } else { 0 };
-
-                Ok::<_, eyre::Report>((count, total_size))
-            })??
-        };
+        // Estimate hashed storage size: 32-byte B256 key instead of 20-byte Address
+        let hashed_size_estimate = if slot_count > 0 { plain_size + 12 } else { 0 };
+        let total_estimate = plain_size + hashed_size_estimate;
 
         let hashed_address = keccak256(address);
 
         println!("Account: {address}");
         println!("Hashed address: {hashed_address}");
         println!("Storage slots: {slot_count}");
-        if use_hashed_state {
-            println!("Hashed storage size: {} (estimated)", human_bytes(storage_size as f64));
-        } else {
-            // Estimate hashed storage size: 32-byte B256 key instead of 20-byte Address
-            let hashed_size_estimate = if slot_count > 0 { storage_size + 12 } else { 0 };
-            let total_estimate = storage_size + hashed_size_estimate;
-            println!("Plain storage size: {} (estimated)", human_bytes(storage_size as f64));
-            println!(
-                "Hashed storage size: {} (estimated)",
-                human_bytes(hashed_size_estimate as f64)
-            );
-            println!("Total estimated size: {}", human_bytes(total_estimate as f64));
-        }
+        println!("Plain storage size: {} (estimated)", human_bytes(plain_size as f64));
+        println!("Hashed storage size: {} (estimated)", human_bytes(hashed_size_estimate as f64));
+        println!("Total estimated size: {}", human_bytes(total_estimate as f64));
 
         Ok(())
     }

crates/cli/commands/src/db/copy.rs

@@ -1,61 +0,0 @@
-use clap::Parser;
-use reth_db::mdbx::{self, ffi};
-use std::path::PathBuf;
-
-/// Copies the MDBX database to a new location.
-///
-/// Equivalent to the standalone `mdbx_copy` tool but bundled into reth.
-#[derive(Parser, Debug)]
-pub struct Command {
-    /// Destination path for the database copy.
-    dest: PathBuf,
-
-    /// Compact the database while copying (reclaims free space).
-    #[arg(short, long)]
-    compact: bool,
-
-    /// Force dynamic size for the destination database.
-    #[arg(short = 'd', long)]
-    force_dynamic_size: bool,
-
-    /// Throttle to avoid MVCC pressure on writers.
-    #[arg(short = 'p', long)]
-    throttle_mvcc: bool,
-}
-
-impl Command {
-    /// Execute `db copy` command
-    pub fn execute(self, db: &mdbx::DatabaseEnv) -> eyre::Result<()> {
-        let mut flags: ffi::MDBX_copy_flags_t = ffi::MDBX_CP_DEFAULTS;
-        if self.compact {
-            flags |= ffi::MDBX_CP_COMPACT;
-        }
-        if self.force_dynamic_size {
-            flags |= ffi::MDBX_CP_FORCE_DYNAMIC_SIZE;
-        }
-        if self.throttle_mvcc {
-            flags |= ffi::MDBX_CP_THROTTLE_MVCC;
-        }
-
-        let dest = self
-            .dest
-            .to_str()
-            .ok_or_else(|| eyre::eyre!("destination path must be valid UTF-8"))?;
-        let dest_cstr = std::ffi::CString::new(dest)?;
-
-        println!("Copying database to {} ...", self.dest.display());
-
-        let rc = db.with_raw_env_ptr(|env_ptr| unsafe {
-            ffi::mdbx_env_copy(env_ptr, dest_cstr.as_ptr(), flags)
-        });
-
-        if rc != 0 {
-            eyre::bail!("mdbx_env_copy failed with error code {rc}: {}", unsafe {
-                std::ffi::CStr::from_ptr(ffi::mdbx_strerror(rc)).to_string_lossy()
-            });
-        }
-
-        println!("Done.");
-        Ok(())
-    }
-}

crates/cli/commands/src/db/get.rs

@@ -98,8 +98,7 @@ impl Command {
                         )?;
 
                         if let Some(entry) = entry {
-                            let se: reth_primitives_traits::StorageEntry = entry.into();
-                            println!("{}", serde_json::to_string_pretty(&se)?);
+                            println!("{}", serde_json::to_string_pretty(&entry)?);
                         } else {
                             error!(target: "reth::cli", "No content for the given table key.");
                         }
@@ -107,14 +106,7 @@ impl Command {
                     }
 
                     let changesets = provider.storage_changeset(key.block_number())?;
-                    let serializable: Vec<_> = changesets
-                        .into_iter()
-                        .map(|(addr, entry)| {
-                            let se: reth_primitives_traits::StorageEntry = entry.into();
-                            (addr, se)
-                        })
-                        .collect();
-                    println!("{}", serde_json::to_string_pretty(&serializable)?);
+                    println!("{}", serde_json::to_string_pretty(&changesets)?);
                     return Ok(());
                 }
 

crates/cli/commands/src/db/mod.rs

@@ -12,7 +12,6 @@ use std::{
 mod account_storage;
 mod checksum;
 mod clear;
-mod copy;
 mod diff;
 mod get;
 mod list;
@@ -43,8 +42,6 @@ pub enum Subcommands {
     List(list::Command),
     /// Calculates the content checksum of a table or static file segment
     Checksum(checksum::Command),
-    /// Copies the MDBX database to a new location (bundled mdbx_copy)
-    Copy(copy::Command),
     /// Create a diff between two database tables or two entire databases.
     Diff(diff::Command),
     /// Gets the content of a table for the given key
@@ -127,11 +124,6 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> Command<C>
                     command.execute(&tool)?;
                 });
             }
-            Subcommands::Copy(command) => {
-                db_exec!(self.env, tool, N, AccessRights::RO, {
-                    command.execute(tool.provider_factory.db_ref())?;
-                });
-            }
             Subcommands::Diff(command) => {
                 db_exec!(self.env, tool, N, AccessRights::RO, {
                     command.execute(&tool)?;

crates/cli/commands/src/db/settings.rs

@@ -39,12 +39,50 @@ enum Subcommands {
 #[derive(Debug, Clone, Copy, Subcommand)]
 #[clap(rename_all = "snake_case")]
 pub enum SetCommand {
-    /// Enable or disable v2 storage layout
+    /// Store receipts in static files instead of the database
+    Receipts {
+        #[clap(action(ArgAction::Set))]
+        value: bool,
+    },
+    /// Store transaction senders in static files instead of the database
+    TransactionSenders {
+        #[clap(action(ArgAction::Set))]
+        value: bool,
+    },
+    /// Store account changesets in static files instead of the database
+    AccountChangesets {
+        #[clap(action(ArgAction::Set))]
+        value: bool,
+    },
+    /// Store storage history in rocksdb instead of MDBX
+    StoragesHistory {
+        #[clap(action(ArgAction::Set))]
+        value: bool,
+    },
+    /// Store transaction hash to number mapping in rocksdb instead of MDBX
+    TransactionHashNumbers {
+        #[clap(action(ArgAction::Set))]
+        value: bool,
+    },
+    /// Store account history in rocksdb instead of MDBX
+    AccountHistory {
+        #[clap(action(ArgAction::Set))]
+        value: bool,
+    },
+    /// Store storage changesets in static files instead of the database
+    StorageChangesets {
+        #[clap(action(ArgAction::Set))]
+        value: bool,
+    },
+    /// Use hashed state tables (HashedAccounts/HashedStorages) as canonical state
     ///
-    /// When enabled, uses static files for receipts/senders/changesets and RocksDB for
-    /// history indices and transaction hashes. When disabled, uses v1/legacy layout (everything in
-    /// MDBX).
-    V2 {
+    /// When enabled, execution writes directly to hashed tables, eliminating need for
+    /// separate hashing stages. State reads come from hashed tables.
+    ///
+    /// WARNING: Changing this setting in either direction requires re-syncing the database.
+    /// Enabling on an existing plain-state database leaves hashed tables empty.
+    /// Disabling on an existing hashed-state database leaves plain tables empty.
+    UseHashedState {
         #[clap(action(ArgAction::Set))]
         value: bool,
     },
@@ -87,18 +125,87 @@ impl Command {
             println!("No storage settings found, creating new settings.");
         }
 
-        let mut settings @ StorageSettings { storage_v2: _ } =
-            settings.unwrap_or_else(StorageSettings::v1);
+        let mut settings @ StorageSettings {
+            receipts_in_static_files: _,
+            transaction_senders_in_static_files: _,
+            storages_history_in_rocksdb: _,
+            transaction_hash_numbers_in_rocksdb: _,
+            account_history_in_rocksdb: _,
+            account_changesets_in_static_files: _,
+            storage_changesets_in_static_files: _,
+            use_hashed_state: _,
+        } = settings.unwrap_or_else(StorageSettings::v1);
 
         // Update the setting based on the key
         match cmd {
-            SetCommand::V2 { value } => {
-                if settings.storage_v2 == value {
-                    println!("storage_v2 is already set to {}", value);
+            SetCommand::Receipts { value } => {
+                if settings.receipts_in_static_files == value {
+                    println!("receipts_in_static_files is already set to {}", value);
                     return Ok(());
                 }
-                settings.storage_v2 = value;
-                println!("Set storage_v2 = {}", value);
+                settings.receipts_in_static_files = value;
+                println!("Set receipts_in_static_files = {}", value);
+            }
+            SetCommand::TransactionSenders { value } => {
+                if settings.transaction_senders_in_static_files == value {
+                    println!("transaction_senders_in_static_files is already set to {}", value);
+                    return Ok(());
+                }
+                settings.transaction_senders_in_static_files = value;
+                println!("Set transaction_senders_in_static_files = {}", value);
+            }
+            SetCommand::AccountChangesets { value } => {
+                if settings.account_changesets_in_static_files == value {
+                    println!("account_changesets_in_static_files is already set to {}", value);
+                    return Ok(());
+                }
+                settings.account_changesets_in_static_files = value;
+                println!("Set account_changesets_in_static_files = {}", value);
+            }
+            SetCommand::StoragesHistory { value } => {
+                if settings.storages_history_in_rocksdb == value {
+                    println!("storages_history_in_rocksdb is already set to {}", value);
+                    return Ok(());
+                }
+                settings.storages_history_in_rocksdb = value;
+                println!("Set storages_history_in_rocksdb = {}", value);
+            }
+            SetCommand::TransactionHashNumbers { value } => {
+                if settings.transaction_hash_numbers_in_rocksdb == value {
+                    println!("transaction_hash_numbers_in_rocksdb is already set to {}", value);
+                    return Ok(());
+                }
+                settings.transaction_hash_numbers_in_rocksdb = value;
+                println!("Set transaction_hash_numbers_in_rocksdb = {}", value);
+            }
+            SetCommand::AccountHistory { value } => {
+                if settings.account_history_in_rocksdb == value {
+                    println!("account_history_in_rocksdb is already set to {}", value);
+                    return Ok(());
+                }
+                settings.account_history_in_rocksdb = value;
+                println!("Set account_history_in_rocksdb = {}", value);
+            }
+            SetCommand::StorageChangesets { value } => {
+                if settings.storage_changesets_in_static_files == value {
+                    println!("storage_changesets_in_static_files is already set to {}", value);
+                    return Ok(());
+                }
+                settings.storage_changesets_in_static_files = value;
+                println!("Set storage_changesets_in_static_files = {}", value);
+            }
+            SetCommand::UseHashedState { value } => {
+                if settings.use_hashed_state == value {
+                    println!("use_hashed_state is already set to {}", value);
+                    return Ok(());
+                }
+                if settings.use_hashed_state && !value {
+                    println!("WARNING: Disabling use_hashed_state on an existing hashed-state database requires a full resync.");
+                } else {
+                    println!("WARNING: Enabling use_hashed_state on an existing plain-state database requires a full resync.");
+                }
+                settings.use_hashed_state = value;
+                println!("Set use_hashed_state = {}", value);
             }
         }
 

crates/cli/commands/src/db/state.rs

@@ -1,4 +1,4 @@
-use alloy_primitives::{keccak256, Address, BlockNumber, B256, U256};
+use alloy_primitives::{Address, BlockNumber, B256, U256};
 use clap::Parser;
 use parking_lot::Mutex;
 use reth_db_api::{
@@ -63,65 +63,39 @@ impl Command {
         address: Address,
         limit: usize,
     ) -> eyre::Result<()> {
-        let use_hashed_state = tool.provider_factory.cached_storage_settings().use_hashed_state();
-
         let entries = tool.provider_factory.db_ref().view(|tx| {
-            let (account, walker_entries) = if use_hashed_state {
-                let hashed_address = keccak256(address);
-                let account = tx.get::<tables::HashedAccounts>(hashed_address)?;
-                let mut cursor = tx.cursor_dup_read::<tables::HashedStorages>()?;
-                let walker = cursor.walk_dup(Some(hashed_address), None)?;
-                let mut entries = Vec::new();
-                let mut last_log = Instant::now();
-                for (idx, entry) in walker.enumerate() {
-                    let (_, storage_entry) = entry?;
-                    if storage_entry.value != U256::ZERO {
-                        entries.push((storage_entry.key, storage_entry.value));
-                    }
-                    if entries.len() >= limit {
-                        break;
-                    }
-                    if last_log.elapsed() >= LOG_INTERVAL {
-                        info!(
-                            target: "reth::cli",
-                            address = %address,
-                            slots_scanned = idx,
-                            "Scanning storage slots"
-                        );
-                        last_log = Instant::now();
-                    }
-                }
-                (account, entries)
-            } else {
-                // Get account info
-                let account = tx.get::<tables::PlainAccountState>(address)?;
-                // Get storage entries
-                let mut cursor = tx.cursor_dup_read::<tables::PlainStorageState>()?;
-                let walker = cursor.walk_dup(Some(address), None)?;
-                let mut entries = Vec::new();
-                let mut last_log = Instant::now();
-                for (idx, entry) in walker.enumerate() {
-                    let (_, storage_entry) = entry?;
-                    if storage_entry.value != U256::ZERO {
-                        entries.push((storage_entry.key, storage_entry.value));
-                    }
-                    if entries.len() >= limit {
-                        break;
-                    }
-                    if last_log.elapsed() >= LOG_INTERVAL {
-                        info!(
-                            target: "reth::cli",
-                            address = %address,
-                            slots_scanned = idx,
-                            "Scanning storage slots"
-                        );
-                        last_log = Instant::now();
-                    }
-                }
-                (account, entries)
-            };
+            // Get account info
+            let account = tx.get::<tables::PlainAccountState>(address)?;
 
-            Ok::<_, eyre::Report>((account, walker_entries))
+            // Get storage entries
+            let mut cursor = tx.cursor_dup_read::<tables::PlainStorageState>()?;
+            let mut entries = Vec::new();
+            let mut last_log = Instant::now();
+
+            let walker = cursor.walk_dup(Some(address), None)?;
+            for (idx, entry) in walker.enumerate() {
+                let (_, storage_entry) = entry?;
+
+                if storage_entry.value != U256::ZERO {
+                    entries.push((storage_entry.key, storage_entry.value));
+                }
+
+                if entries.len() >= limit {
+                    break;
+                }
+
+                if last_log.elapsed() >= LOG_INTERVAL {
+                    info!(
+                        target: "reth::cli",
+                        address = %address,
+                        slots_scanned = idx,
+                        "Scanning storage slots"
+                    );
+                    last_log = Instant::now();
+                }
+            }
+
+            Ok::<_, eyre::Report>((account, entries))
         })??;
 
         let (account, storage_entries) = entries;
@@ -145,7 +119,7 @@ impl Command {
 
         // Check storage settings to determine where history is stored
         let storage_settings = tool.provider_factory.cached_storage_settings();
-        let history_in_rocksdb = storage_settings.storage_v2;
+        let history_in_rocksdb = storage_settings.storages_history_in_rocksdb;
 
         // For historical queries, enumerate keys from history indices only
         // (not PlainStorageState, which reflects current state)

crates/cli/commands/src/download.rs

@@ -37,14 +37,6 @@ pub struct DownloadDefaults {
     pub available_snapshots: Vec<Cow<'static, str>>,
     /// Default base URL for snapshots
     pub default_base_url: Cow<'static, str>,
-    /// Default base URL for chain-aware snapshots.
-    ///
-    /// When set, the chain ID is appended to form the full URL: `{base_url}/{chain_id}`.
-    /// For example, given a base URL of `https://snapshots.example.com` and chain ID `1`,
-    /// the resulting URL would be `https://snapshots.example.com/1`.
-    ///
-    /// Falls back to [`default_base_url`](Self::default_base_url) when `None`.
-    pub default_chain_aware_base_url: Option<Cow<'static, str>>,
     /// Optional custom long help text that overrides the generated help
     pub long_help: Option<String>,
 }
@@ -68,7 +60,6 @@ impl DownloadDefaults {
                 Cow::Borrowed("https://publicnode.com/snapshots (full nodes & testnets)"),
             ],
             default_base_url: Cow::Borrowed(MERKLE_BASE_URL),
-            default_chain_aware_base_url: None,
             long_help: None,
         }
     }
@@ -93,11 +84,9 @@ impl DownloadDefaults {
         }
 
         help.push_str(
-            "\nIf no URL is provided, the latest archive snapshot for the selected chain\nwill be proposed for download from ",
-        );
-        help.push_str(
-            self.default_chain_aware_base_url.as_deref().unwrap_or(&self.default_base_url),
+            "\nIf no URL is provided, the latest mainnet archive snapshot\nwill be proposed for download from ",
         );
+        help.push_str(self.default_base_url.as_ref());
         help.push_str(
             ".\n\nLocal file:// URLs are also supported for extracting snapshots from disk.",
         );
@@ -122,12 +111,6 @@ impl DownloadDefaults {
         self
     }
 
-    /// Set the default chain-aware base URL.
-    pub fn with_chain_aware_base_url(mut self, url: impl Into<Cow<'static, str>>) -> Self {
-        self.default_chain_aware_base_url = Some(url.into());
-        self
-    }
-
     /// Builder: Set custom long help text, overriding the generated help
     pub fn with_long_help(mut self, help: impl Into<String>) -> Self {
         self.long_help = Some(help.into());
@@ -159,7 +142,7 @@ impl<C: ChainSpecParser<ChainSpec: EthChainSpec + EthereumHardforks>> DownloadCo
         let url = match self.url {
             Some(url) => url,
             None => {
-                let url = get_latest_snapshot_url(self.env.chain.chain().id()).await?;
+                let url = get_latest_snapshot_url().await?;
                 info!(target: "reth::cli", "Using default snapshot URL: {}", url);
                 url
             }
@@ -526,12 +509,8 @@ async fn stream_and_extract(url: &str, target_dir: &Path) -> Result<()> {
 }
 
 // Builds default URL for latest mainnet archive snapshot using configured defaults
-async fn get_latest_snapshot_url(chain_id: u64) -> Result<String> {
-    let defaults = DownloadDefaults::get_global();
-    let base_url = match &defaults.default_chain_aware_base_url {
-        Some(url) => format!("{url}/{chain_id}"),
-        None => defaults.default_base_url.to_string(),
-    };
+async fn get_latest_snapshot_url() -> Result<String> {
+    let base_url = &DownloadDefaults::get_global().default_base_url;
     let latest_url = format!("{base_url}/latest.txt");
     let filename = Client::new()
         .get(latest_url)

crates/cli/commands/src/node.rs

@@ -10,8 +10,8 @@ use reth_node_builder::NodeBuilder;
 use reth_node_core::{
     args::{
         DatabaseArgs, DatadirArgs, DebugArgs, DevArgs, EngineArgs, EraArgs, MetricArgs,
-        NetworkArgs, PayloadBuilderArgs, PruningArgs, RpcServerArgs, StaticFilesArgs, StorageArgs,
-        TxPoolArgs,
+        NetworkArgs, PayloadBuilderArgs, PruningArgs, RocksDbArgs, RpcServerArgs, StaticFilesArgs,
+        StorageArgs, TxPoolArgs,
     },
     node_config::NodeConfig,
     version,
@@ -103,6 +103,10 @@ pub struct NodeCommand<C: ChainSpecParser, Ext: clap::Args + fmt::Debug = NoArgs
     #[command(flatten)]
     pub pruning: PruningArgs,
 
+    /// All `RocksDB` table routing arguments
+    #[command(flatten)]
+    pub rocksdb: RocksDbArgs,
+
     /// Engine cli arguments
     #[command(flatten, next_help_heading = "Engine")]
     pub engine: EngineArgs,
@@ -115,8 +119,8 @@ pub struct NodeCommand<C: ChainSpecParser, Ext: clap::Args + fmt::Debug = NoArgs
     #[command(flatten, next_help_heading = "Static Files")]
     pub static_files: StaticFilesArgs,
 
-    /// All storage related arguments with --storage prefix
-    #[command(flatten, next_help_heading = "Storage")]
+    /// Storage mode configuration (v2 vs v1/legacy)
+    #[command(flatten)]
     pub storage: StorageArgs,
 
     /// Additional cli arguments
@@ -171,6 +175,7 @@ where
             db,
             dev,
             pruning,
+            rocksdb,
             engine,
             era,
             static_files,
@@ -178,6 +183,9 @@ where
             ext,
         } = self;
 
+        // Validate RocksDB arguments
+        rocksdb.validate()?;
+
         // set up node config
         let mut node_config = NodeConfig {
             datadir,
@@ -193,6 +201,7 @@ where
             db,
             dev,
             pruning,
+            rocksdb,
             engine,
             era,
             static_files,

crates/cli/commands/src/stage/drop.rs

@@ -45,16 +45,12 @@ impl<C: ChainSpecParser> Command<C> {
 
         let tool = DbTool::new(provider_factory)?;
 
-        let static_file_segments = match self.stage {
-            StageEnum::Headers => vec![StaticFileSegment::Headers],
-            StageEnum::Bodies => vec![StaticFileSegment::Transactions],
-            StageEnum::Execution => vec![
-                StaticFileSegment::Receipts,
-                StaticFileSegment::AccountChangeSets,
-                StaticFileSegment::StorageChangeSets,
-            ],
-            StageEnum::Senders => vec![StaticFileSegment::TransactionSenders],
-            _ => vec![],
+        let static_file_segment = match self.stage {
+            StageEnum::Headers => Some(StaticFileSegment::Headers),
+            StageEnum::Bodies => Some(StaticFileSegment::Transactions),
+            StageEnum::Execution => Some(StaticFileSegment::Receipts),
+            StageEnum::Senders => Some(StaticFileSegment::TransactionSenders),
+            _ => None,
         };
 
         // Calling `StaticFileProviderRW::prune_*` will instruct the writer to prune rows only
@@ -62,33 +58,35 @@ impl<C: ChainSpecParser> Command<C> {
         // deleting the jar files, otherwise if the task were to be interrupted after we
         // have deleted them, BUT before we have committed the checkpoints to the database, we'd
         // lose essential data.
-        let static_file_provider = tool.provider_factory.static_file_provider();
-        for segment in static_file_segments {
-            if let Some(highest_block) = static_file_provider.get_highest_static_file_block(segment)
+        if let Some(static_file_segment) = static_file_segment {
+            let static_file_provider = tool.provider_factory.static_file_provider();
+            if let Some(highest_block) =
+                static_file_provider.get_highest_static_file_block(static_file_segment)
             {
-                let mut writer = static_file_provider.latest_writer(segment)?;
+                let mut writer = static_file_provider.latest_writer(static_file_segment)?;
 
-                match segment {
+                match static_file_segment {
                     StaticFileSegment::Headers => {
+                        // Prune all headers leaving genesis intact.
                         writer.prune_headers(highest_block)?;
                     }
                     StaticFileSegment::Transactions => {
                         let to_delete = static_file_provider
-                            .get_highest_static_file_tx(segment)
+                            .get_highest_static_file_tx(static_file_segment)
                             .map(|tx_num| tx_num + 1)
                             .unwrap_or_default();
                         writer.prune_transactions(to_delete, 0)?;
                     }
                     StaticFileSegment::Receipts => {
                         let to_delete = static_file_provider
-                            .get_highest_static_file_tx(segment)
+                            .get_highest_static_file_tx(static_file_segment)
                             .map(|tx_num| tx_num + 1)
                             .unwrap_or_default();
                         writer.prune_receipts(to_delete, 0)?;
                     }
                     StaticFileSegment::TransactionSenders => {
                         let to_delete = static_file_provider
-                            .get_highest_static_file_tx(segment)
+                            .get_highest_static_file_tx(static_file_segment)
                             .map(|tx_num| tx_num + 1)
                             .unwrap_or_default();
                         writer.prune_transaction_senders(to_delete, 0)?;
@@ -133,15 +131,8 @@ impl<C: ChainSpecParser> Command<C> {
                 reset_stage_checkpoint(tx, StageId::SenderRecovery)?;
             }
             StageEnum::Execution => {
-                if provider_rw.cached_storage_settings().use_hashed_state() {
-                    tx.clear::<tables::HashedAccounts>()?;
-                    tx.clear::<tables::HashedStorages>()?;
-                    reset_stage_checkpoint(tx, StageId::AccountHashing)?;
-                    reset_stage_checkpoint(tx, StageId::StorageHashing)?;
-                } else {
-                    tx.clear::<tables::PlainAccountState>()?;
-                    tx.clear::<tables::PlainStorageState>()?;
-                }
+                tx.clear::<tables::PlainAccountState>()?;
+                tx.clear::<tables::PlainStorageState>()?;
                 tx.clear::<tables::AccountChangeSets>()?;
                 tx.clear::<tables::StorageChangeSets>()?;
                 tx.clear::<tables::Bytecodes>()?;
@@ -187,7 +178,7 @@ impl<C: ChainSpecParser> Command<C> {
                 let settings = provider_rw.cached_storage_settings();
                 let rocksdb = tool.provider_factory.rocksdb_provider();
 
-                if settings.storage_v2 {
+                if settings.account_history_in_rocksdb {
                     rocksdb.clear::<tables::AccountsHistory>()?;
                 } else {
                     tx.clear::<tables::AccountsHistory>()?;
@@ -204,7 +195,7 @@ impl<C: ChainSpecParser> Command<C> {
                 let settings = provider_rw.cached_storage_settings();
                 let rocksdb = tool.provider_factory.rocksdb_provider();
 
-                if settings.storage_v2 {
+                if settings.storages_history_in_rocksdb {
                     rocksdb.clear::<tables::StoragesHistory>()?;
                 } else {
                     tx.clear::<tables::StoragesHistory>()?;
@@ -218,7 +209,7 @@ impl<C: ChainSpecParser> Command<C> {
                 )?;
             }
             StageEnum::TxLookup => {
-                if provider_rw.cached_storage_settings().storage_v2 {
+                if provider_rw.cached_storage_settings().transaction_hash_numbers_in_rocksdb {
                     tool.provider_factory
                         .rocksdb_provider()
                         .clear::<tables::TransactionHashNumbers>()?;

crates/e2e-test-utils/src/testsuite/setup.rs

@@ -1,6 +1,6 @@
 //! Test setup utilities for configuring the initial state.
 
-use crate::{testsuite::Environment, E2ETestSetupBuilder, NodeBuilderHelper};
+use crate::{setup_engine_with_connection, testsuite::Environment, NodeBuilderHelper};
 use alloy_eips::BlockNumberOrTag;
 use alloy_primitives::B256;
 use alloy_rpc_types_engine::{ForkchoiceState, PayloadAttributes};
@@ -38,8 +38,6 @@ pub struct Setup<I> {
     shutdown_tx: Option<mpsc::Sender<()>>,
     /// Is this setup in dev mode
     pub is_dev: bool,
-    /// Whether to use v2 storage mode (hashed keys, static file changesets, rocksdb history)
-    pub storage_v2: bool,
     /// Tracks instance generic.
     _phantom: PhantomData<I>,
     /// Holds the import result to keep nodes alive when using imported chain
@@ -60,7 +58,6 @@ impl<I> Default for Setup<I> {
             tree_config: TreeConfig::default(),
             shutdown_tx: None,
             is_dev: true,
-            storage_v2: false,
             _phantom: Default::default(),
             import_result_holder: None,
             import_rlp_path: None,
@@ -129,12 +126,6 @@ where
         self
     }
 
-    /// Enable v2 storage mode (hashed keys, static file changesets, rocksdb history)
-    pub const fn with_storage_v2(mut self) -> Self {
-        self.storage_v2 = true;
-        self
-    }
-
     /// Apply setup using pre-imported chain data from RLP file
     pub async fn apply_with_import<N>(
         &mut self,
@@ -203,28 +194,19 @@ where
         self.shutdown_tx = Some(shutdown_tx);
 
         let is_dev = self.is_dev;
-        let storage_v2 = self.storage_v2;
         let node_count = self.network.node_count;
-        let tree_config = self.tree_config.clone();
 
         let attributes_generator = Self::create_static_attributes_generator::<N>();
 
-        let mut builder = E2ETestSetupBuilder::<N, _>::new(
+        let result = setup_engine_with_connection::<N>(
             node_count,
             Arc::<N::ChainSpec>::new((*chain_spec).clone().into()),
+            is_dev,
+            self.tree_config.clone(),
             attributes_generator,
+            self.network.connect_nodes,
         )
-        .with_tree_config_modifier(move |base| {
-            tree_config.clone().with_cross_block_cache_size(base.cross_block_cache_size())
-        })
-        .with_node_config_modifier(move |config| config.set_dev(is_dev))
-        .with_connect_nodes(self.network.connect_nodes);
-
-        if storage_v2 {
-            builder = builder.with_storage_v2();
-        }
-
-        let result = builder.build().await;
+        .await;
 
         let mut node_clients = Vec::new();
         match result {

crates/e2e-test-utils/tests/rocksdb/main.rs

@@ -10,6 +10,7 @@ use jsonrpsee::core::client::ClientT;
 use reth_chainspec::{ChainSpec, ChainSpecBuilder, MAINNET};
 use reth_db::tables;
 use reth_e2e_test_utils::{transaction::TransactionTestContext, wallet, E2ETestSetupBuilder};
+use reth_node_core::args::RocksDbArgs;
 use reth_node_ethereum::EthereumNode;
 use reth_payload_builder::EthPayloadBuilderAttributes;
 use reth_provider::RocksDBProviderFactory;
@@ -95,6 +96,22 @@ fn test_attributes_generator(timestamp: u64) -> EthPayloadBuilderAttributes {
     EthPayloadBuilderAttributes::new(B256::ZERO, attributes)
 }
 
+/// Verifies that `RocksDB` CLI defaults are `None` (deferred to storage mode).
+#[test]
+fn test_rocksdb_defaults_are_none() {
+    let args = RocksDbArgs::default();
+
+    assert!(args.tx_hash.is_none(), "tx_hash default should be None (deferred to --storage.v2)");
+    assert!(
+        args.storages_history.is_none(),
+        "storages_history default should be None (deferred to --storage.v2)"
+    );
+    assert!(
+        args.account_history.is_none(),
+        "account_history default should be None (deferred to --storage.v2)"
+    );
+}
+
 /// Smoke test: node boots with `RocksDB` routing enabled.
 #[tokio::test]
 async fn test_rocksdb_node_startup() -> Result<()> {
@@ -460,7 +477,7 @@ async fn test_rocksdb_pending_tx_not_in_storage() -> Result<()> {
 ///
 /// This test exercises `unwind_trie_state_from` which previously failed with
 /// `UnsortedInput` errors because it read changesets directly from MDBX tables
-/// instead of using storage-aware methods that check `is_v2()`.
+/// instead of using storage-aware methods that check `storage_changesets_in_static_files`.
 #[tokio::test]
 async fn test_rocksdb_reorg_unwind() -> Result<()> {
     reth_tracing::init_test_tracing();

crates/engine/primitives/src/config.rs

@@ -179,8 +179,6 @@ pub struct TreeConfig {
     sparse_trie_prune_depth: usize,
     /// Maximum number of storage tries to retain after pruning.
     sparse_trie_max_storage_tries: usize,
-    /// Whether to fully disable sparse trie cache pruning between blocks.
-    disable_sparse_trie_cache_pruning: bool,
     /// Timeout for the state root task before spawning a sequential fallback computation.
     /// If `Some`, after waiting this duration for the state root task, a sequential state root
     /// computation is spawned in parallel and whichever finishes first is used.
@@ -218,7 +216,6 @@ impl Default for TreeConfig {
             disable_trie_cache: false,
             sparse_trie_prune_depth: DEFAULT_SPARSE_TRIE_PRUNE_DEPTH,
             sparse_trie_max_storage_tries: DEFAULT_SPARSE_TRIE_MAX_STORAGE_TRIES,
-            disable_sparse_trie_cache_pruning: false,
             state_root_task_timeout: Some(DEFAULT_STATE_ROOT_TASK_TIMEOUT),
         }
     }
@@ -284,7 +281,6 @@ impl TreeConfig {
             disable_trie_cache: false,
             sparse_trie_prune_depth,
             sparse_trie_max_storage_tries,
-            disable_sparse_trie_cache_pruning: false,
             state_root_task_timeout,
         }
     }
@@ -635,17 +631,6 @@ impl TreeConfig {
         self
     }
 
-    /// Returns whether sparse trie cache pruning is disabled.
-    pub const fn disable_sparse_trie_cache_pruning(&self) -> bool {
-        self.disable_sparse_trie_cache_pruning
-    }
-
-    /// Setter for whether to disable sparse trie cache pruning.
-    pub const fn with_disable_sparse_trie_cache_pruning(mut self, value: bool) -> Self {
-        self.disable_sparse_trie_cache_pruning = value;
-        self
-    }
-
     /// Returns the state root task timeout.
     pub const fn state_root_task_timeout(&self) -> Option<Duration> {
         self.state_root_task_timeout

crates/engine/service/src/service.rs

@@ -20,7 +20,7 @@ use reth_node_types::{BlockTy, NodeTypes};
 use reth_payload_builder::PayloadBuilderHandle;
 use reth_provider::{
     providers::{BlockchainProvider, ProviderNodeTypes},
-    ProviderFactory, StorageSettingsCache,
+    ProviderFactory,
 };
 use reth_prune::PrunerWithFactory;
 use reth_stages_api::{MetricEventsSender, Pipeline};
@@ -94,7 +94,6 @@ where
             if chain_spec.is_optimism() { EngineApiKind::OpStack } else { EngineApiKind::Ethereum };
 
         let downloader = BasicBlockDownloader::new(client, consensus.clone());
-        let use_hashed_state = provider.cached_storage_settings().use_hashed_state();
 
         let persistence_handle =
             PersistenceHandle::<N::Primitives>::spawn_service(provider, pruner, sync_metrics_tx);
@@ -112,7 +111,6 @@ where
             engine_kind,
             evm_config,
             changeset_cache,
-            use_hashed_state,
         );
 
         let engine_handler = EngineApiRequestHandler::new(to_tree_tx, from_tree);

crates/engine/tree/Cargo.toml

@@ -143,13 +143,6 @@ test-utils = [
     "reth-evm-ethereum/test-utils",
     "reth-tasks/test-utils",
 ]
-rocksdb = [
-    "reth-provider/rocksdb",
-    "reth-prune/rocksdb",
-    "reth-stages?/rocksdb",
-    "reth-e2e-test-utils/rocksdb",
-]
-edge = ["rocksdb"]
 
 [[test]]
 name = "e2e_testsuite"

crates/engine/tree/src/tree/cached_state.rs

@@ -351,14 +351,6 @@ impl<S: StateProvider, const PREWARM: bool> StateProvider for CachedStateProvide
             self.state_provider.storage(account, storage_key)
         }
     }
-
-    fn storage_by_hashed_key(
-        &self,
-        address: Address,
-        hashed_storage_key: StorageKey,
-    ) -> ProviderResult<Option<StorageValue>> {
-        self.state_provider.storage_by_hashed_key(address, hashed_storage_key)
-    }
 }
 
 impl<S: BytecodeReader, const PREWARM: bool> BytecodeReader for CachedStateProvider<S, PREWARM> {
@@ -845,10 +837,8 @@ impl SavedCache {
         self.caches.update_metrics(&self.metrics);
     }
 
-    /// Clears all caches, resetting them to empty state,
-    /// and updates the hash of the block this cache belongs to.
-    pub(crate) fn clear_with_hash(&mut self, hash: B256) {
-        self.hash = hash;
+    /// Clears all caches, resetting them to empty state.
+    pub(crate) fn clear(&self) {
         self.caches.clear();
     }
 }

crates/engine/tree/src/tree/instrumented_state.rs

@@ -199,17 +199,6 @@ impl<S: StateProvider> StateProvider for InstrumentedStateProvider<S> {
         self.record_storage_fetch(start.elapsed());
         res
     }
-
-    fn storage_by_hashed_key(
-        &self,
-        address: Address,
-        hashed_storage_key: StorageKey,
-    ) -> ProviderResult<Option<StorageValue>> {
-        let start = Instant::now();
-        let res = self.state_provider.storage_by_hashed_key(address, hashed_storage_key);
-        self.record_storage_fetch(start.elapsed());
-        res
-    }
 }
 
 impl<S: BytecodeReader> BytecodeReader for InstrumentedStateProvider<S> {

crates/engine/tree/src/tree/metrics.rs

@@ -12,13 +12,12 @@ use reth_primitives_traits::constants::gas_units::MEGAGAS;
 use reth_trie::updates::TrieUpdates;
 use std::time::{Duration, Instant};
 
-/// Upper bounds for each gas bucket. The last bucket is a catch-all for
-/// everything above the final threshold: <5M, 5-10M, 10-20M, 20-30M, 30-40M, >40M.
-const GAS_BUCKET_THRESHOLDS: [u64; 5] =
-    [5 * MEGAGAS, 10 * MEGAGAS, 20 * MEGAGAS, 30 * MEGAGAS, 40 * MEGAGAS];
+/// Width of each gas bucket in gas units (10 Mgas).
+const GAS_BUCKET_SIZE: u64 = 10 * MEGAGAS;
 
-/// Total number of gas buckets (thresholds + 1 catch-all).
-const NUM_GAS_BUCKETS: usize = GAS_BUCKET_THRESHOLDS.len() + 1;
+/// Number of gas buckets. The last bucket is a catch-all for everything above
+/// `(NUM_GAS_BUCKETS - 1) * GAS_BUCKET_SIZE`.
+const NUM_GAS_BUCKETS: usize = 5;
 
 /// Metrics for the `EngineApi`.
 #[derive(Debug, Default)]
@@ -281,23 +280,21 @@ impl GasBucketMetrics {
     }
 
     fn bucket_index(gas_used: u64) -> usize {
-        GAS_BUCKET_THRESHOLDS
-            .iter()
-            .position(|&threshold| gas_used < threshold)
-            .unwrap_or(GAS_BUCKET_THRESHOLDS.len())
+        let idx = gas_used / GAS_BUCKET_SIZE;
+        (idx as usize).min(NUM_GAS_BUCKETS - 1)
     }
 
-    /// Returns a human-readable label like `<5M`, `5-10M`, … `>40M`.
+    /// Returns a human-readable label like `<10M`, `10-20M`, … `>40M`.
     fn bucket_label(index: usize) -> String {
+        let m = GAS_BUCKET_SIZE / 1_000_000;
         if index == 0 {
-            let hi = GAS_BUCKET_THRESHOLDS[0] / MEGAGAS;
-            format!("<{hi}M")
-        } else if index < GAS_BUCKET_THRESHOLDS.len() {
-            let lo = GAS_BUCKET_THRESHOLDS[index - 1] / MEGAGAS;
-            let hi = GAS_BUCKET_THRESHOLDS[index] / MEGAGAS;
+            format!("<{m}M")
+        } else if index < NUM_GAS_BUCKETS - 1 {
+            let lo = m * index as u64;
+            let hi = lo + m;
             format!("{lo}-{hi}M")
         } else {
-            let lo = GAS_BUCKET_THRESHOLDS[GAS_BUCKET_THRESHOLDS.len() - 1] / MEGAGAS;
+            let lo = m * index as u64;
             format!(">{lo}M")
         }
     }

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

@@ -32,7 +32,7 @@ use reth_provider::{
     BlockExecutionOutput, BlockExecutionResult, BlockReader, ChangeSetReader,
     DatabaseProviderFactory, HashedPostStateProvider, ProviderError, StageCheckpointReader,
     StateProviderBox, StateProviderFactory, StateReader, StorageChangeSetReader,
-    StorageSettingsCache, TransactionVariant,
+    TransactionVariant,
 };
 use reth_revm::database::StateProviderDatabase;
 use reth_stages_api::ControlFlow;
@@ -271,9 +271,6 @@ where
     evm_config: C,
     /// Changeset cache for in-memory trie changesets
     changeset_cache: ChangesetCache,
-    /// Whether the node uses hashed state as canonical storage (v2 mode).
-    /// Cached at construction to avoid threading `StorageSettingsCache` bounds everywhere.
-    use_hashed_state: bool,
 }
 
 impl<N, P: Debug, T: PayloadTypes + Debug, V: Debug, C> std::fmt::Debug
@@ -299,7 +296,6 @@ where
             .field("engine_kind", &self.engine_kind)
             .field("evm_config", &self.evm_config)
             .field("changeset_cache", &self.changeset_cache)
-            .field("use_hashed_state", &self.use_hashed_state)
             .finish()
     }
 }
@@ -317,8 +313,7 @@ where
     P::Provider: BlockReader<Block = N::Block, Header = N::BlockHeader>
         + StageCheckpointReader
         + ChangeSetReader
-        + StorageChangeSetReader
-        + StorageSettingsCache,
+        + StorageChangeSetReader,
     C: ConfigureEvm<Primitives = N> + 'static,
     T: PayloadTypes<BuiltPayload: BuiltPayload<Primitives = N>>,
     V: EngineValidator<T>,
@@ -339,7 +334,6 @@ where
         engine_kind: EngineApiKind,
         evm_config: C,
         changeset_cache: ChangesetCache,
-        use_hashed_state: bool,
     ) -> Self {
         let (incoming_tx, incoming) = crossbeam_channel::unbounded();
 
@@ -361,7 +355,6 @@ where
             engine_kind,
             evm_config,
             changeset_cache,
-            use_hashed_state,
         }
     }
 
@@ -382,7 +375,6 @@ where
         kind: EngineApiKind,
         evm_config: C,
         changeset_cache: ChangesetCache,
-        use_hashed_state: bool,
     ) -> (Sender<FromEngine<EngineApiRequest<T, N>, N::Block>>, UnboundedReceiver<EngineApiEvent<N>>)
     {
         let best_block_number = provider.best_block_number().unwrap_or(0);
@@ -415,7 +407,6 @@ where
             kind,
             evm_config,
             changeset_cache,
-            use_hashed_state,
         );
         let incoming = task.incoming_tx.clone();
         spawn_os_thread("engine", || task.run());
@@ -1411,7 +1402,7 @@ where
         // Spawn a background task to trigger computation so it's ready when the next payload
         // arrives.
         if let Some(overlay) = self.state.tree_state.prepare_canonical_overlay() {
-            tokio::task::spawn_blocking(move || {
+            rayon::spawn(move || {
                 let _ = overlay.get();
             });
         }
@@ -2388,12 +2379,7 @@ where
 
             self.update_reorg_metrics(old.len(), old_first);
             self.reinsert_reorged_blocks(new.clone());
-
-            // When use_hashed_state is enabled, skip reinserting the old chain — the
-            // bundle state references plain state reverts which don't exist.
-            if !self.use_hashed_state {
-                self.reinsert_reorged_blocks(old.clone());
-            }
+            self.reinsert_reorged_blocks(old.clone());
         }
 
         // update the tracked in-memory state with the new chain

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

@@ -50,7 +50,7 @@ use std::{
         mpsc::{self, channel},
         Arc,
     },
-    time::{Duration, Instant},
+    time::Instant,
 };
 use tracing::{debug, debug_span, instrument, warn, Span};
 
@@ -94,9 +94,6 @@ pub const SPARSE_TRIE_MAX_NODES_SHRINK_CAPACITY: usize = 1_000_000;
 /// 144MB.
 pub const SPARSE_TRIE_MAX_VALUES_SHRINK_CAPACITY: usize = 1_000_000;
 
-/// Blocks with fewer transactions than this skip prewarming, since the fixed overhead of spawning
-/// prewarm workers exceeds the execution time saved.
-pub const SMALL_BLOCK_TX_THRESHOLD: usize = 5;
 /// Type alias for [`PayloadHandle`] returned by payload processor spawn methods.
 type IteratorPayloadHandle<Evm, I, N> = PayloadHandle<
     WithTxEnv<TxEnvFor<Evm>, <I as ExecutableTxIterator<Evm>>::Recovered>,
@@ -138,8 +135,6 @@ where
     sparse_trie_prune_depth: usize,
     /// Maximum storage tries to retain after pruning.
     sparse_trie_max_storage_tries: usize,
-    /// Whether sparse trie cache pruning is fully disabled.
-    disable_sparse_trie_cache_pruning: bool,
     /// Whether to disable cache metrics recording.
     disable_cache_metrics: bool,
 }
@@ -175,7 +170,6 @@ where
             prewarm_max_concurrency: config.prewarm_max_concurrency(),
             sparse_trie_prune_depth: config.sparse_trie_prune_depth(),
             sparse_trie_max_storage_tries: config.sparse_trie_max_storage_tries(),
-            disable_sparse_trie_cache_pruning: config.disable_sparse_trie_cache_pruning(),
             disable_cache_metrics: config.disable_cache_metrics(),
         }
     }
@@ -472,8 +466,7 @@ where
     where
         P: BlockReader + StateProviderFactory + StateReader + Clone + 'static,
     {
-        let skip_prewarm =
-            self.disable_transaction_prewarming || env.transaction_count < SMALL_BLOCK_TX_THRESHOLD;
+        let skip_prewarm = self.disable_transaction_prewarming;
 
         let saved_cache = self.disable_state_cache.not().then(|| self.cache_for(env.parent_hash));
 
@@ -553,7 +546,6 @@ where
         let disable_trie_cache = config.disable_trie_cache();
         let prune_depth = self.sparse_trie_prune_depth;
         let max_storage_tries = self.sparse_trie_max_storage_tries;
-        let disable_cache_pruning = self.disable_sparse_trie_cache_pruning;
         let chunk_size =
             config.multiproof_chunking_enabled().then_some(config.multiproof_chunk_size());
         let executor = self.executor.clone();
@@ -650,7 +642,6 @@ where
                     max_storage_tries,
                     SPARSE_TRIE_MAX_NODES_SHRINK_CAPACITY,
                     SPARSE_TRIE_MAX_VALUES_SHRINK_CAPACITY,
-                    disable_cache_pruning,
                 );
                 trie_metrics
                     .into_trie_for_reuse_duration_histogram
@@ -926,7 +917,7 @@ impl PayloadExecutionCache {
     #[instrument(level = "debug", target = "engine::tree::payload_processor", skip(self))]
     pub(crate) fn get_cache_for(&self, parent_hash: B256) -> Option<SavedCache> {
         let start = Instant::now();
-        let mut cache = self.inner.write();
+        let cache = self.inner.read();
 
         let elapsed = start.elapsed();
         self.metrics.execution_cache_wait_duration.record(elapsed.as_secs_f64());
@@ -934,7 +925,7 @@ impl PayloadExecutionCache {
             warn!(blocked_for=?elapsed, "Blocked waiting for execution cache mutex");
         }
 
-        if let Some(c) = cache.as_mut() {
+        if let Some(c) = cache.as_ref() {
             let cached_hash = c.executed_block_hash();
             // Check that the cache hash matches the parent hash of the current block. It won't
             // match in case it's a fork block.
@@ -955,13 +946,13 @@ impl PayloadExecutionCache {
             );
 
             if available {
+                // If the has is available (no other threads are using it), but has a mismatching
+                // parent hash, we can just clear it and keep using without re-creating from
+                // scratch.
                 if !hash_matches {
-                    // Fork block: clear and update the hash on the ORIGINAL before cloning.
-                    // This prevents the canonical chain from matching on the stale hash
-                    // and picking up polluted data if the fork block fails.
-                    c.clear_with_hash(parent_hash);
+                    c.clear();
                 }
-                return Some(c.clone());
+                return Some(c.clone())
             } else if hash_matches {
                 self.metrics.execution_cache_in_use.increment(1);
             }
@@ -972,25 +963,10 @@ impl PayloadExecutionCache {
         None
     }
 
-    /// Waits until the execution cache becomes available for use.
-    ///
-    /// This acquires a write lock to ensure exclusive access, then immediately releases it.
-    /// This is useful for synchronization before starting payload processing.
-    ///
-    /// Returns the time spent waiting for the lock.
-    pub fn wait_for_availability(&self) -> Duration {
-        let start = Instant::now();
-        // Acquire write lock to wait for any current holders to finish
-        let _guard = self.inner.write();
-        let elapsed = start.elapsed();
-        if elapsed.as_millis() > 5 {
-            debug!(
-                target: "engine::tree::payload_processor",
-                blocked_for=?elapsed,
-                "Waited for execution cache to become available"
-            );
-        }
-        elapsed
+    /// Clears the tracked cache
+    #[expect(unused)]
+    pub(crate) fn clear(&self) {
+        self.inner.write().take();
     }
 
     /// Updates the cache with a closure that has exclusive access to the guard.
@@ -1143,18 +1119,10 @@ mod tests {
 
         execution_cache.update_with_guard(|slot| *slot = Some(make_saved_cache(hash)));
 
-        // When the parent hash doesn't match (fork block), the cache is cleared,
-        // hash updated on the original, and clone returned for reuse
+        // When the parent hash doesn't match, the cache is cleared and returned for reuse
         let different_hash = B256::from([4u8; 32]);
         let cache = execution_cache.get_cache_for(different_hash);
-        assert!(cache.is_some(), "cache should be returned for reuse after clearing");
-
-        drop(cache);
-
-        // The stored cache now has the fork block's parent hash.
-        // Canonical chain looking for original hash sees a mismatch → clears and reuses.
-        let original = execution_cache.get_cache_for(hash);
-        assert!(original.is_some(), "canonical chain gets cache back via mismatch+clear");
+        assert!(cache.is_some(), "cache should be returned for reuse after clearing")
     }
 
     #[test]
@@ -1378,61 +1346,4 @@ mod tests {
             "State root mismatch: task={root_from_task}, base={root_from_regular}"
         );
     }
-
-    /// Tests the full prewarm lifecycle for a fork block:
-    ///
-    /// 1. Cache is at canonical block 4.
-    /// 2. Fork block (parent = block 2) checks out the cache via `get_cache_for`, simulating what
-    ///    `PrewarmCacheTask` does when it receives a `SavedCache`.
-    /// 3. Prewarm populates the shared cache with fork-specific state.
-    /// 4. While the prewarm clone is alive, the cache is unavailable (`usage_guard` > 1).
-    /// 5. Prewarm drops without calling `save_cache` (fork block was invalid).
-    /// 6. Canonical block 5 (parent = block 4) must get a cache with correct hash and no stale fork
-    ///    data.
-    #[test]
-    fn fork_prewarm_dropped_without_save_does_not_corrupt_cache() {
-        let execution_cache = PayloadExecutionCache::default();
-
-        // Canonical chain at block 4.
-        let block4_hash = B256::from([4u8; 32]);
-        execution_cache.update_with_guard(|slot| *slot = Some(make_saved_cache(block4_hash)));
-
-        // Fork block arrives with parent = block 2. Prewarm task checks out the cache.
-        // This simulates PrewarmCacheTask receiving a SavedCache clone from get_cache_for.
-        let fork_parent = B256::from([2u8; 32]);
-        let prewarm_cache = execution_cache.get_cache_for(fork_parent);
-        assert!(prewarm_cache.is_some(), "prewarm should obtain cache for fork block");
-        let prewarm_cache = prewarm_cache.unwrap();
-        assert_eq!(prewarm_cache.executed_block_hash(), fork_parent);
-
-        // Prewarm populates cache with fork-specific state (ancestor data for block 2).
-        // Since ExecutionCache uses Arc<Inner>, this data is shared with the stored original.
-        let fork_addr = Address::from([0xBB; 20]);
-        let fork_key = B256::from([0xCC; 32]);
-        prewarm_cache.cache().insert_storage(fork_addr, fork_key, Some(U256::from(999)));
-
-        // While prewarm holds the clone, the usage_guard count > 1 → cache is in use.
-        let during_prewarm = execution_cache.get_cache_for(block4_hash);
-        assert!(
-            during_prewarm.is_none(),
-            "cache must be unavailable while prewarm holds a reference"
-        );
-
-        // Fork block fails — prewarm task drops without calling save_cache/update_with_guard.
-        drop(prewarm_cache);
-
-        // Canonical block 5 arrives (parent = block 4).
-        // Stored hash = fork_parent (our fix), so get_cache_for sees a mismatch,
-        // clears the stale fork data, and returns a cache with hash = block4_hash.
-        let block5_cache = execution_cache.get_cache_for(block4_hash);
-        assert!(
-            block5_cache.is_some(),
-            "canonical chain must get cache after fork prewarm is dropped"
-        );
-        assert_eq!(
-            block5_cache.as_ref().unwrap().executed_block_hash(),
-            block4_hash,
-            "cache must carry the canonical parent hash, not the fork parent"
-        );
-    }
 }

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

@@ -1541,7 +1541,6 @@ mod tests {
         providers::OverlayStateProviderFactory, test_utils::create_test_provider_factory,
         BlockNumReader, BlockReader, ChangeSetReader, DatabaseProviderFactory, LatestStateProvider,
         PruneCheckpointReader, StageCheckpointReader, StateProviderBox, StorageChangeSetReader,
-        StorageSettingsCache,
     };
     use reth_trie::MultiProof;
     use reth_trie_db::ChangesetCache;
@@ -1563,7 +1562,6 @@ mod tests {
                               + PruneCheckpointReader
                               + ChangeSetReader
                               + StorageChangeSetReader
-                              + StorageSettingsCache
                               + BlockNumReader,
             > + Clone
             + Send
@@ -1583,10 +1581,7 @@ mod tests {
     fn create_cached_provider<F>(factory: F) -> CachedStateProvider<StateProviderBox>
     where
         F: DatabaseProviderFactory<
-                Provider: BlockReader
-                              + StageCheckpointReader
-                              + PruneCheckpointReader
-                              + reth_provider::StorageSettingsCache,
+                Provider: BlockReader + StageCheckpointReader + PruneCheckpointReader,
             > + Clone
             + Send
             + 'static,

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

@@ -72,7 +72,6 @@ where
         max_storage_tries: usize,
         max_nodes_capacity: usize,
         max_values_capacity: usize,
-        disable_pruning: bool,
     ) -> (SparseStateTrie<A, S>, DeferredDrops) {
         match self {
             Self::Cleared(task) => task.into_cleared_trie(max_nodes_capacity, max_values_capacity),
@@ -81,7 +80,6 @@ where
                 max_storage_tries,
                 max_nodes_capacity,
                 max_values_capacity,
-                disable_pruning,
             ),
         }
     }
@@ -358,23 +356,16 @@ where
     /// Prunes and shrinks the trie for reuse in the next payload built on top of this one.
     ///
     /// Should be called after the state root result has been sent.
-    ///
-    /// When `disable_pruning` is true, the trie is preserved without any node pruning,
-    /// storage trie eviction, or capacity shrinking, keeping the full cache intact for
-    /// benchmarking purposes.
     pub(super) fn into_trie_for_reuse(
         self,
         prune_depth: usize,
         max_storage_tries: usize,
         max_nodes_capacity: usize,
         max_values_capacity: usize,
-        disable_pruning: bool,
     ) -> (SparseStateTrie<A, S>, DeferredDrops) {
         let Self { mut trie, .. } = self;
-        if !disable_pruning {
-            trie.prune(prune_depth, max_storage_tries);
-            trie.shrink_to(max_nodes_capacity, max_values_capacity);
-        }
+        trie.prune(prune_depth, max_storage_tries);
+        trie.shrink_to(max_nodes_capacity, max_values_capacity);
         let deferred = trie.take_deferred_drops();
         (trie, deferred)
     }
@@ -416,9 +407,7 @@ where
                     let update = match message {
                         Ok(m) => m,
                         Err(_) => {
-                            return Err(ParallelStateRootError::Other(
-                                "updates channel disconnected before state root calculation".to_string(),
-                            ))
+                            break
                         }
                     };
 

crates/engine/tree/src/tree/payload_validator.rs

@@ -38,7 +38,7 @@ use reth_provider::{
     providers::OverlayStateProviderFactory, BlockExecutionOutput, BlockNumReader, BlockReader,
     ChangeSetReader, DatabaseProviderFactory, DatabaseProviderROFactory, HashedPostStateProvider,
     ProviderError, PruneCheckpointReader, StageCheckpointReader, StateProvider,
-    StateProviderFactory, StateReader, StorageChangeSetReader, StorageSettingsCache,
+    StateProviderFactory, StateReader, StorageChangeSetReader,
 };
 use reth_revm::db::{states::bundle_state::BundleRetention, State};
 use reth_trie::{updates::TrieUpdates, HashedPostState, StateRoot};
@@ -146,8 +146,7 @@ where
                           + PruneCheckpointReader
                           + ChangeSetReader
                           + StorageChangeSetReader
-                          + BlockNumReader
-                          + StorageSettingsCache,
+                          + BlockNumReader,
         > + BlockReader<Header = N::BlockHeader>
         + ChangeSetReader
         + BlockNumReader
@@ -1527,8 +1526,7 @@ where
                           + PruneCheckpointReader
                           + ChangeSetReader
                           + StorageChangeSetReader
-                          + BlockNumReader
-                          + StorageSettingsCache,
+                          + BlockNumReader,
         > + BlockReader<Header = N::BlockHeader>
         + StateProviderFactory
         + StateReader

crates/engine/tree/src/tree/tests.rs

@@ -221,7 +221,6 @@ impl TestHarness {
             EngineApiKind::Ethereum,
             evm_config,
             changeset_cache,
-            provider.cached_storage_settings().use_hashed_state(),
         );
 
         let block_builder = TestBlockBuilder::default().with_chain_spec((*chain_spec).clone());

crates/engine/tree/tests/e2e-testsuite/main.rs

@@ -2,15 +2,13 @@
 
 mod fcu_finalized_blocks;
 
-use alloy_rpc_types_engine::PayloadStatusEnum;
 use eyre::Result;
 use reth_chainspec::{ChainSpecBuilder, MAINNET};
 use reth_e2e_test_utils::testsuite::{
     actions::{
-        BlockReference, CaptureBlock, CompareNodeChainTips, CreateFork, ExpectFcuStatus,
-        MakeCanonical, ProduceBlocks, ProduceBlocksLocally, ProduceInvalidBlocks, ReorgTo,
-        SelectActiveNode, SendForkchoiceUpdate, SendNewPayloads, SetForkBase, UpdateBlockInfo,
-        ValidateCanonicalTag, WaitForSync,
+        CaptureBlock, CompareNodeChainTips, CreateFork, ExpectFcuStatus, MakeCanonical,
+        ProduceBlocks, ProduceBlocksLocally, ProduceInvalidBlocks, ReorgTo, SelectActiveNode,
+        SendNewPayloads, UpdateBlockInfo, ValidateCanonicalTag, WaitForSync,
     },
     setup::{NetworkSetup, Setup},
     TestBuilder,
@@ -41,14 +39,6 @@ fn default_engine_tree_setup() -> Setup<EthEngineTypes> {
         )
 }
 
-/// Creates a v2 storage mode setup for engine tree e2e tests.
-///
-/// v2 mode uses keccak256-hashed slot keys in static file changesets and rocksdb history
-/// instead of plain keys in MDBX.
-fn v2_engine_tree_setup() -> Setup<EthEngineTypes> {
-    default_engine_tree_setup().with_storage_v2()
-}
-
 /// Test that verifies forkchoice update and canonical chain insertion functionality.
 #[tokio::test]
 async fn test_engine_tree_fcu_canon_chain_insertion_e2e() -> Result<()> {
@@ -344,152 +334,3 @@ async fn test_engine_tree_live_sync_transition_eventually_canonical_e2e() -> Res
 
     Ok(())
 }
-
-// ==================== v2 storage mode variants ====================
-
-/// v2 variant: Verifies forkchoice update and canonical chain insertion in v2 storage mode.
-///
-/// Exercises the full `save_blocks` → `write_state` → static file changeset path with hashed keys.
-#[tokio::test]
-async fn test_engine_tree_fcu_canon_chain_insertion_v2_e2e() -> Result<()> {
-    reth_tracing::init_test_tracing();
-
-    let test = TestBuilder::new()
-        .with_setup(v2_engine_tree_setup())
-        .with_action(ProduceBlocks::<EthEngineTypes>::new(1))
-        .with_action(MakeCanonical::new())
-        .with_action(ProduceBlocks::<EthEngineTypes>::new(3))
-        .with_action(MakeCanonical::new());
-
-    test.run::<EthereumNode>().await?;
-
-    Ok(())
-}
-
-/// v2 variant: Verifies forkchoice update with a reorg where all blocks are already available.
-///
-/// Exercises `write_state_reverts` path with hashed changeset keys during CL-driven reorgs.
-#[tokio::test]
-async fn test_engine_tree_fcu_reorg_with_all_blocks_v2_e2e() -> Result<()> {
-    reth_tracing::init_test_tracing();
-
-    let test = TestBuilder::new()
-        .with_setup(v2_engine_tree_setup())
-        .with_action(ProduceBlocks::<EthEngineTypes>::new(5))
-        .with_action(MakeCanonical::new())
-        .with_action(CreateFork::<EthEngineTypes>::new(2, 3))
-        .with_action(CaptureBlock::new("fork_tip"))
-        .with_action(ReorgTo::<EthEngineTypes>::new_from_tag("fork_tip"));
-
-    test.run::<EthereumNode>().await?;
-
-    Ok(())
-}
-
-/// v2 variant: Verifies progressive canonical chain extension in v2 storage mode.
-#[tokio::test]
-async fn test_engine_tree_fcu_extends_canon_chain_v2_e2e() -> Result<()> {
-    reth_tracing::init_test_tracing();
-
-    let test = TestBuilder::new()
-        .with_setup(v2_engine_tree_setup())
-        .with_action(ProduceBlocks::<EthEngineTypes>::new(1))
-        .with_action(MakeCanonical::new())
-        .with_action(ProduceBlocks::<EthEngineTypes>::new(10))
-        .with_action(CaptureBlock::new("target_block"))
-        .with_action(ReorgTo::<EthEngineTypes>::new_from_tag("target_block"))
-        .with_action(MakeCanonical::new());
-
-    test.run::<EthereumNode>().await?;
-
-    Ok(())
-}
-
-/// Creates a 2-node setup for disk-level reorg testing.
-///
-/// Uses unconnected nodes so fork blocks can be produced independently on Node 1 and then
-/// sent to Node 0 via newPayload only (no FCU), keeping Node 0's persisted chain intact
-/// until the final `ReorgTo` triggers `find_disk_reorg`.
-fn disk_reorg_setup(storage_v2: bool) -> Setup<EthEngineTypes> {
-    let mut setup = Setup::default()
-        .with_chain_spec(Arc::new(
-            ChainSpecBuilder::default()
-                .chain(MAINNET.chain)
-                .genesis(
-                    serde_json::from_str(include_str!(
-                        "../../../../e2e-test-utils/src/testsuite/assets/genesis.json"
-                    ))
-                    .unwrap(),
-                )
-                .cancun_activated()
-                .build(),
-        ))
-        .with_network(NetworkSetup::multi_node_unconnected(2))
-        .with_tree_config(
-            TreeConfig::default().with_legacy_state_root(false).with_has_enough_parallelism(true),
-        );
-    if storage_v2 {
-        setup = setup.with_storage_v2();
-    }
-    setup
-}
-
-/// Builds a disk-level reorg test scenario.
-///
-/// 1. Both nodes receive 3 shared blocks
-/// 2. Node 0 extends to 10 blocks locally (persisted to disk)
-/// 3. Node 1 builds an 8-block fork from block 3 (its canonical head)
-/// 4. Fork blocks are sent to Node 0 via newPayload (no FCU, old chain stays on disk)
-/// 5. FCU to fork tip on Node 0 triggers `find_disk_reorg` → `RemoveBlocksAbove(3)`
-fn disk_reorg_test(storage_v2: bool) -> TestBuilder<EthEngineTypes> {
-    TestBuilder::new()
-        .with_setup(disk_reorg_setup(storage_v2))
-        .with_action(SelectActiveNode::new(0))
-        .with_action(ProduceBlocks::<EthEngineTypes>::new(3))
-        .with_action(MakeCanonical::new())
-        .with_action(ProduceBlocksLocally::<EthEngineTypes>::new(7))
-        .with_action(MakeCanonical::with_active_node())
-        .with_action(SelectActiveNode::new(1))
-        .with_action(SetForkBase::new(3))
-        .with_action(ProduceBlocksLocally::<EthEngineTypes>::new(8))
-        .with_action(MakeCanonical::with_active_node())
-        .with_action(CaptureBlock::new("fork_tip"))
-        .with_action(
-            SendNewPayloads::<EthEngineTypes>::new()
-                .with_source_node(1)
-                .with_target_node(0)
-                .with_start_block(4)
-                .with_total_blocks(8),
-        )
-        .with_action(
-            SendForkchoiceUpdate::<EthEngineTypes>::new(
-                BlockReference::Tag("fork_tip".into()),
-                BlockReference::Tag("fork_tip".into()),
-                BlockReference::Tag("fork_tip".into()),
-            )
-            .with_expected_status(PayloadStatusEnum::Valid)
-            .with_node_idx(0),
-        )
-}
-
-/// Verifies disk-level reorg in v1 (plain key) storage mode.
-///
-/// Confirms `find_disk_reorg()` detects persisted blocks on the wrong fork and calls
-/// `RemoveBlocksAbove` to truncate, then re-persists the correct fork chain.
-#[tokio::test]
-async fn test_engine_tree_disk_reorg_v1_e2e() -> Result<()> {
-    reth_tracing::init_test_tracing();
-    disk_reorg_test(false).run::<EthereumNode>().await?;
-    Ok(())
-}
-
-/// v2 variant: Verifies disk-level reorg in v2 storage mode.
-///
-/// Same scenario as v1 but with hashed changeset keys in static files and rocksdb history.
-/// Exercises `find_disk_reorg()` → `RemoveBlocksAbove` with v2 hashed key format.
-#[tokio::test]
-async fn test_engine_tree_disk_reorg_v2_e2e() -> Result<()> {
-    reth_tracing::init_test_tracing();
-    disk_reorg_test(true).run::<EthereumNode>().await?;
-    Ok(())
-}

crates/ethereum/evm/src/lib.rs

@@ -273,6 +273,7 @@ where
             gas_limit: payload.payload.gas_limit(),
             basefee: payload.payload.saturated_base_fee_per_gas(),
             blob_excess_gas_and_price,
+            slot_num: 0,
         };
 
         Ok(EvmEnv { cfg_env, block_env })

crates/ethereum/evm/src/test_utils.rs

@@ -108,8 +108,7 @@ impl<'a, DB: Database, I: Inspector<EthEvmContext<&'a mut State<DB>>>> BlockExec
             result: ResultAndState::new(
                 ExecutionResult::Success {
                     reason: SuccessReason::Return,
-                    gas_used: 0,
-                    gas_refunded: 0,
+                    gas: Default::default(),
                     logs: vec![],
                     output: Output::Call(Bytes::from(vec![])),
                 },

crates/exex/exex/src/backfill/test_utils.rs

@@ -18,7 +18,6 @@ use reth_provider::{
 };
 use reth_revm::database::StateProviderDatabase;
 use reth_testing_utils::generators::sign_tx_with_key_pair;
-use reth_trie_common::KeccakKeyHasher;
 use secp256k1::Keypair;
 
 pub(crate) fn to_execution_outcome(
@@ -78,9 +77,12 @@ where
     let execution_outcome = to_execution_outcome(block.number(), &block_execution_output);
 
     // Commit the block's execution outcome to the database
-    let hashed_state = execution_outcome.hash_state_slow::<KeccakKeyHasher>().into_sorted();
     let provider_rw = provider_factory.provider_rw()?;
-    provider_rw.append_blocks_with_state(vec![block.clone()], &execution_outcome, hashed_state)?;
+    provider_rw.append_blocks_with_state(
+        vec![block.clone()],
+        &execution_outcome,
+        Default::default(),
+    )?;
     provider_rw.commit()?;
 
     Ok(block_execution_output)
@@ -208,12 +210,11 @@ where
     execution_outcome.state_mut().reverts.sort();
 
     // Commit the block's execution outcome to the database
-    let hashed_state = execution_outcome.hash_state_slow::<KeccakKeyHasher>().into_sorted();
     let provider_rw = provider_factory.provider_rw()?;
     provider_rw.append_blocks_with_state(
         vec![block1.clone(), block2.clone()],
         &execution_outcome,
-        hashed_state,
+        Default::default(),
     )?;
     provider_rw.commit()?;
 

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

@@ -589,7 +589,7 @@ impl EthMessageID {
 
     /// Returns the max value for the given version.
     pub const fn max(version: EthVersion) -> u8 {
-        if version as u8 >= EthVersion::Eth69 as u8 {
+        if version.is_eth69() {
             Self::BlockRangeUpdate.to_u8()
         } else {
             Self::Receipts.to_u8()
@@ -937,13 +937,6 @@ mod tests {
         assert!(matches!(decoded, StatusMessage::Legacy(s) if s == status));
     }
 
-    #[test]
-    fn eth_message_id_max_includes_block_range_update() {
-        assert_eq!(EthMessageID::max(EthVersion::Eth69), EthMessageID::BlockRangeUpdate.to_u8(),);
-        assert_eq!(EthMessageID::max(EthVersion::Eth70), EthMessageID::BlockRangeUpdate.to_u8(),);
-        assert_eq!(EthMessageID::max(EthVersion::Eth68), EthMessageID::Receipts.to_u8());
-    }
-
     #[test]
     fn decode_status_rejects_non_status() {
         let msg = EthMessage::<EthNetworkPrimitives>::GetBlockBodies(RequestPair {

crates/net/network-api/src/events.rs

@@ -8,7 +8,7 @@ use reth_eth_wire_types::{
 };
 use reth_ethereum_forks::ForkId;
 use reth_network_p2p::error::{RequestError, RequestResult};
-use reth_network_peers::{NodeRecord, PeerId};
+use reth_network_peers::PeerId;
 use reth_network_types::{PeerAddr, PeerKind};
 use reth_tokio_util::EventStream;
 use std::{
@@ -152,13 +152,8 @@ pub trait NetworkEventListenerProvider: NetworkPeersEvents {
 pub enum DiscoveryEvent {
     /// Discovered a node
     NewNode(DiscoveredEvent),
-    /// Retrieved a [`ForkId`] from the peer via ENR request.
-    ///
-    /// Contains the full [`NodeRecord`] (peer ID + address) and the reported [`ForkId`].
-    /// Used to verify fork compatibility before admitting the peer.
-    ///
-    /// See also <https://eips.ethereum.org/EIPS/eip-868>
-    EnrForkId(NodeRecord, ForkId),
+    /// Retrieved a [`ForkId`] from the peer via ENR request, See <https://eips.ethereum.org/EIPS/eip-868>
+    EnrForkId(PeerId, ForkId),
 }
 
 /// Represents events related to peer discovery in the network.

crates/net/network-types/src/peers/config.rs

@@ -172,11 +172,6 @@ pub struct PeersConfig {
     /// IPs within the specified CIDR ranges will be allowed.
     #[cfg_attr(feature = "serde", serde(skip))]
     pub ip_filter: IpFilter,
-    /// If true, discovered peers without a confirmed ENR [`ForkId`](alloy_eip2124::ForkId)
-    /// (EIP-868) will not be added to the peer set until their fork ID is verified.
-    ///
-    /// This filters out peers from other networks that pollute the discovery table.
-    pub enforce_enr_fork_id: bool,
 }
 
 impl Default for PeersConfig {
@@ -196,7 +191,6 @@ impl Default for PeersConfig {
             max_backoff_count: 5,
             incoming_ip_throttle_duration: INBOUND_IP_THROTTLE_DURATION,
             ip_filter: IpFilter::default(),
-            enforce_enr_fork_id: false,
         }
     }
 }
@@ -320,13 +314,6 @@ impl PeersConfig {
         self
     }
 
-    /// If set, discovered peers without a confirmed ENR [`ForkId`](alloy_eip2124::ForkId) will not
-    /// be added to the peer set until their fork ID is verified via EIP-868.
-    pub const fn with_enforce_enr_fork_id(mut self, enforce: bool) -> Self {
-        self.enforce_enr_fork_id = enforce;
-        self
-    }
-
     /// Returns settings for testing
     #[cfg(any(test, feature = "test-utils"))]
     pub fn test() -> Self {

crates/net/network/src/discovery.rs

@@ -240,7 +240,7 @@ impl Discovery {
                 self.on_node_record_update(record, None);
             }
             DiscoveryUpdate::EnrForkId(node, fork_id) => {
-                self.queued_events.push_back(DiscoveryEvent::EnrForkId(node, fork_id))
+                self.queued_events.push_back(DiscoveryEvent::EnrForkId(node.id, fork_id))
             }
             DiscoveryUpdate::Removed(peer_id) => {
                 self.discovered_nodes.remove(&peer_id);

crates/net/network/src/manager.rs

@@ -25,7 +25,7 @@ use crate::{
     listener::ConnectionListener,
     message::{NewBlockMessage, PeerMessage},
     metrics::{
-        BackedOffPeersMetrics, ClosedSessionsMetrics, DirectionalDisconnectMetrics, NetworkMetrics,
+        BackedOffPeersMetrics, ClosedSessionsMetrics, DisconnectMetrics, NetworkMetrics,
         PendingSessionFailureMetrics, NETWORK_POOL_TRANSACTIONS_SCOPE,
     },
     network::{NetworkHandle, NetworkHandleMessage},
@@ -140,8 +140,8 @@ pub struct NetworkManager<N: NetworkPrimitives = EthNetworkPrimitives> {
     num_active_peers: Arc<AtomicUsize>,
     /// Metrics for the Network
     metrics: NetworkMetrics,
-    /// Disconnect metrics for the Network, split by connection direction.
-    disconnect_metrics: DirectionalDisconnectMetrics,
+    /// Disconnect metrics for the Network
+    disconnect_metrics: DisconnectMetrics,
     /// Closed sessions metrics, split by direction.
     closed_sessions_metrics: ClosedSessionsMetrics,
     /// Pending session failure metrics, split by direction.
@@ -864,9 +864,6 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
                     "Session disconnected"
                 );
 
-                // Capture direction before state is reset to Idle
-                let is_inbound = self.swarm.state().peers().is_inbound_peer(&peer_id);
-
                 let reason = if let Some(ref err) = error {
                     // If the connection was closed due to an error, we report
                     // the peer
@@ -890,11 +887,7 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
                 self.update_active_connection_metrics();
 
                 if let Some(reason) = reason {
-                    if is_inbound {
-                        self.disconnect_metrics.increment_inbound(reason);
-                    } else {
-                        self.disconnect_metrics.increment_outbound(reason);
-                    }
+                    self.disconnect_metrics.increment(reason);
                 }
                 self.metrics
                     .backed_off_peers
@@ -917,7 +910,7 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
                         .on_incoming_pending_session_dropped(remote_addr, err);
                     self.pending_session_failure_metrics.inbound.increment(1);
                     if let Some(reason) = err.as_disconnected() {
-                        self.disconnect_metrics.increment_inbound(reason);
+                        self.disconnect_metrics.increment(reason);
                     }
                 } else {
                     self.swarm
@@ -950,7 +943,7 @@ impl<N: NetworkPrimitives> NetworkManager<N> {
                         BackoffReason::from_disconnect(err.as_disconnected()),
                     );
                     if let Some(reason) = err.as_disconnected() {
-                        self.disconnect_metrics.increment_outbound(reason);
+                        self.disconnect_metrics.increment(reason);
                     }
                 } else {
                     self.swarm

crates/net/network/src/metrics.rs

@@ -301,34 +301,6 @@ macro_rules! duration_metered_exec {
     }};
 }
 
-/// Direction-aware wrapper for disconnect metrics.
-///
-/// Tracks disconnect reasons for inbound and outbound connections separately, in addition to
-/// the combined (legacy) counters.
-#[derive(Debug, Default)]
-pub(crate) struct DirectionalDisconnectMetrics {
-    /// Combined disconnect metrics (all directions).
-    pub(crate) total: DisconnectMetrics,
-    /// Disconnect metrics for inbound connections only.
-    pub(crate) inbound: InboundDisconnectMetrics,
-    /// Disconnect metrics for outbound connections only.
-    pub(crate) outbound: OutboundDisconnectMetrics,
-}
-
-impl DirectionalDisconnectMetrics {
-    /// Increments disconnect counters for an inbound connection.
-    pub(crate) fn increment_inbound(&self, reason: DisconnectReason) {
-        self.total.increment(reason);
-        self.inbound.increment(reason);
-    }
-
-    /// Increments disconnect counters for an outbound connection.
-    pub(crate) fn increment_outbound(&self, reason: DisconnectReason) {
-        self.total.increment(reason);
-        self.outbound.increment(reason);
-    }
-}
-
 /// Metrics for Disconnection types
 ///
 /// These are just counters, and ideally we would implement these metrics on a peer-by-peer basis,
@@ -398,144 +370,6 @@ impl DisconnectMetrics {
     }
 }
 
-/// Disconnect metrics scoped to inbound connections only.
-///
-/// These counters track disconnect reasons exclusively for sessions that were initiated by
-/// remote peers connecting to this node. This helps operators distinguish between being rejected
-/// by remote peers (outbound) vs rejecting incoming peers (inbound).
-#[derive(Metrics)]
-#[metrics(scope = "network.inbound")]
-pub struct InboundDisconnectMetrics {
-    /// Number of inbound peer disconnects due to `DisconnectRequested` (0x00)
-    pub(crate) disconnect_requested: Counter,
-
-    /// Number of inbound peer disconnects due to `TcpSubsystemError` (0x01)
-    pub(crate) tcp_subsystem_error: Counter,
-
-    /// Number of inbound peer disconnects due to `ProtocolBreach` (0x02)
-    pub(crate) protocol_breach: Counter,
-
-    /// Number of inbound peer disconnects due to `UselessPeer` (0x03)
-    pub(crate) useless_peer: Counter,
-
-    /// Number of inbound peer disconnects due to `TooManyPeers` (0x04)
-    pub(crate) too_many_peers: Counter,
-
-    /// Number of inbound peer disconnects due to `AlreadyConnected` (0x05)
-    pub(crate) already_connected: Counter,
-
-    /// Number of inbound peer disconnects due to `IncompatibleP2PProtocolVersion` (0x06)
-    pub(crate) incompatible: Counter,
-
-    /// Number of inbound peer disconnects due to `NullNodeIdentity` (0x07)
-    pub(crate) null_node_identity: Counter,
-
-    /// Number of inbound peer disconnects due to `ClientQuitting` (0x08)
-    pub(crate) client_quitting: Counter,
-
-    /// Number of inbound peer disconnects due to `UnexpectedHandshakeIdentity` (0x09)
-    pub(crate) unexpected_identity: Counter,
-
-    /// Number of inbound peer disconnects due to `ConnectedToSelf` (0x0a)
-    pub(crate) connected_to_self: Counter,
-
-    /// Number of inbound peer disconnects due to `PingTimeout` (0x0b)
-    pub(crate) ping_timeout: Counter,
-
-    /// Number of inbound peer disconnects due to `SubprotocolSpecific` (0x10)
-    pub(crate) subprotocol_specific: Counter,
-}
-
-impl InboundDisconnectMetrics {
-    /// Increments the proper counter for the given disconnect reason
-    pub(crate) fn increment(&self, reason: DisconnectReason) {
-        match reason {
-            DisconnectReason::DisconnectRequested => self.disconnect_requested.increment(1),
-            DisconnectReason::TcpSubsystemError => self.tcp_subsystem_error.increment(1),
-            DisconnectReason::ProtocolBreach => self.protocol_breach.increment(1),
-            DisconnectReason::UselessPeer => self.useless_peer.increment(1),
-            DisconnectReason::TooManyPeers => self.too_many_peers.increment(1),
-            DisconnectReason::AlreadyConnected => self.already_connected.increment(1),
-            DisconnectReason::IncompatibleP2PProtocolVersion => self.incompatible.increment(1),
-            DisconnectReason::NullNodeIdentity => self.null_node_identity.increment(1),
-            DisconnectReason::ClientQuitting => self.client_quitting.increment(1),
-            DisconnectReason::UnexpectedHandshakeIdentity => self.unexpected_identity.increment(1),
-            DisconnectReason::ConnectedToSelf => self.connected_to_self.increment(1),
-            DisconnectReason::PingTimeout => self.ping_timeout.increment(1),
-            DisconnectReason::SubprotocolSpecific => self.subprotocol_specific.increment(1),
-        }
-    }
-}
-
-/// Disconnect metrics scoped to outbound connections only.
-///
-/// These counters track disconnect reasons exclusively for sessions that this node initiated
-/// by dialing out to remote peers. A high `too_many_peers` count here indicates remote peers
-/// are rejecting our connection attempts because they are full.
-#[derive(Metrics)]
-#[metrics(scope = "network.outbound")]
-pub struct OutboundDisconnectMetrics {
-    /// Number of outbound peer disconnects due to `DisconnectRequested` (0x00)
-    pub(crate) disconnect_requested: Counter,
-
-    /// Number of outbound peer disconnects due to `TcpSubsystemError` (0x01)
-    pub(crate) tcp_subsystem_error: Counter,
-
-    /// Number of outbound peer disconnects due to `ProtocolBreach` (0x02)
-    pub(crate) protocol_breach: Counter,
-
-    /// Number of outbound peer disconnects due to `UselessPeer` (0x03)
-    pub(crate) useless_peer: Counter,
-
-    /// Number of outbound peer disconnects due to `TooManyPeers` (0x04)
-    pub(crate) too_many_peers: Counter,
-
-    /// Number of outbound peer disconnects due to `AlreadyConnected` (0x05)
-    pub(crate) already_connected: Counter,
-
-    /// Number of outbound peer disconnects due to `IncompatibleP2PProtocolVersion` (0x06)
-    pub(crate) incompatible: Counter,
-
-    /// Number of outbound peer disconnects due to `NullNodeIdentity` (0x07)
-    pub(crate) null_node_identity: Counter,
-
-    /// Number of outbound peer disconnects due to `ClientQuitting` (0x08)
-    pub(crate) client_quitting: Counter,
-
-    /// Number of outbound peer disconnects due to `UnexpectedHandshakeIdentity` (0x09)
-    pub(crate) unexpected_identity: Counter,
-
-    /// Number of outbound peer disconnects due to `ConnectedToSelf` (0x0a)
-    pub(crate) connected_to_self: Counter,
-
-    /// Number of outbound peer disconnects due to `PingTimeout` (0x0b)
-    pub(crate) ping_timeout: Counter,
-
-    /// Number of outbound peer disconnects due to `SubprotocolSpecific` (0x10)
-    pub(crate) subprotocol_specific: Counter,
-}
-
-impl OutboundDisconnectMetrics {
-    /// Increments the proper counter for the given disconnect reason
-    pub(crate) fn increment(&self, reason: DisconnectReason) {
-        match reason {
-            DisconnectReason::DisconnectRequested => self.disconnect_requested.increment(1),
-            DisconnectReason::TcpSubsystemError => self.tcp_subsystem_error.increment(1),
-            DisconnectReason::ProtocolBreach => self.protocol_breach.increment(1),
-            DisconnectReason::UselessPeer => self.useless_peer.increment(1),
-            DisconnectReason::TooManyPeers => self.too_many_peers.increment(1),
-            DisconnectReason::AlreadyConnected => self.already_connected.increment(1),
-            DisconnectReason::IncompatibleP2PProtocolVersion => self.incompatible.increment(1),
-            DisconnectReason::NullNodeIdentity => self.null_node_identity.increment(1),
-            DisconnectReason::ClientQuitting => self.client_quitting.increment(1),
-            DisconnectReason::UnexpectedHandshakeIdentity => self.unexpected_identity.increment(1),
-            DisconnectReason::ConnectedToSelf => self.connected_to_self.increment(1),
-            DisconnectReason::PingTimeout => self.ping_timeout.increment(1),
-            DisconnectReason::SubprotocolSpecific => self.subprotocol_specific.increment(1),
-        }
-    }
-}
-
 /// Metrics for the `EthRequestHandler`
 #[derive(Metrics)]
 #[metrics(scope = "network")]

crates/net/network/src/peers.rs

@@ -92,9 +92,6 @@ pub struct PeersManager {
     incoming_ip_throttle_duration: Duration,
     /// IP address filter for restricting network connections to specific IP ranges.
     ip_filter: reth_net_banlist::IpFilter,
-    /// If true, discovered peers without a confirmed ENR fork ID will not be added until their
-    /// fork ID is verified via EIP-868.
-    enforce_enr_fork_id: bool,
 }
 
 impl PeersManager {
@@ -114,7 +111,6 @@ impl PeersManager {
             max_backoff_count,
             incoming_ip_throttle_duration,
             ip_filter,
-            enforce_enr_fork_id,
         } = config;
         let (manager_tx, handle_rx) = mpsc::unbounded_channel();
         let now = Instant::now();
@@ -171,7 +167,6 @@ impl PeersManager {
             net_connection_state: NetworkConnectionState::default(),
             incoming_ip_throttle_duration,
             ip_filter,
-            enforce_enr_fork_id,
         }
     }
 
@@ -180,11 +175,6 @@ impl PeersManager {
         PeersHandle::new(self.manager_tx.clone())
     }
 
-    /// Returns `true` if discovered peers must have a confirmed ENR fork ID before being added.
-    pub(crate) const fn enforce_enr_fork_id(&self) -> bool {
-        self.enforce_enr_fork_id
-    }
-
     /// Returns the number of peers in the peer set
     #[inline]
     pub(crate) fn num_known_peers(&self) -> usize {
@@ -218,13 +208,6 @@ impl PeersManager {
         })
     }
 
-    /// Returns `true` if the given peer is connected via an inbound session.
-    pub(crate) fn is_inbound_peer(&self, peer_id: &PeerId) -> bool {
-        self.peers.get(peer_id).is_some_and(|p| {
-            matches!(p.state, PeerConnectionState::In | PeerConnectionState::DisconnectingIn)
-        })
-    }
-
     /// Returns an iterator over all peer ids for peers with the given kind
     pub(crate) fn peers_by_kind(&self, kind: PeerKind) -> impl Iterator<Item = PeerId> + '_ {
         self.peers.iter().filter_map(move |(peer_id, peer)| (peer.kind == kind).then_some(*peer_id))
@@ -755,6 +738,17 @@ impl PeersManager {
         }
     }
 
+    /// Called as follow-up for a discovered peer.
+    ///
+    /// The [`ForkId`] is retrieved from an ENR record that the peer announces over the discovery
+    /// protocol
+    pub(crate) fn set_discovered_fork_id(&mut self, peer_id: PeerId, fork_id: ForkId) {
+        if let Some(peer) = self.peers.get_mut(&peer_id) {
+            trace!(target: "net::peers", ?peer_id, ?fork_id, "set discovered fork id");
+            peer.fork_id = Some(Box::new(fork_id));
+        }
+    }
+
     /// Called for a newly discovered peer.
     ///
     /// If the peer already exists, then the address, kind and `fork_id` will be updated.

crates/net/network/src/state.rs

@@ -332,19 +332,9 @@ impl<N: NetworkPrimitives> NetworkState<N> {
                     fork_id,
                 });
             }
-            DiscoveryEvent::EnrForkId(record, fork_id) => {
-                let peer_id = record.id;
-                let tcp_addr = record.tcp_addr();
-                if tcp_addr.port() == 0 {
-                    return
-                }
-                let udp_addr = record.udp_addr();
-                let addr = PeerAddr::new(tcp_addr, Some(udp_addr));
-                self.queued_messages.push_back(StateAction::DiscoveredEnrForkId {
-                    peer_id,
-                    addr,
-                    fork_id,
-                });
+            DiscoveryEvent::EnrForkId(peer_id, fork_id) => {
+                self.queued_messages
+                    .push_back(StateAction::DiscoveredEnrForkId { peer_id, fork_id });
             }
         }
     }
@@ -562,8 +552,6 @@ pub(crate) enum StateAction<N: NetworkPrimitives> {
     /// Retrieved a [`ForkId`] from the peer via ENR request, See <https://eips.ethereum.org/EIPS/eip-868>
     DiscoveredEnrForkId {
         peer_id: PeerId,
-        /// The address of the peer.
-        addr: PeerAddr,
         /// The reported [`ForkId`] by this peer.
         fork_id: ForkId,
     },

crates/net/network/src/swarm.rs

@@ -246,28 +246,18 @@ impl<N: NetworkPrimitives> Swarm<N> {
             StateAction::PeerAdded(peer_id) => return Some(SwarmEvent::PeerAdded(peer_id)),
             StateAction::PeerRemoved(peer_id) => return Some(SwarmEvent::PeerRemoved(peer_id)),
             StateAction::DiscoveredNode { peer_id, addr, fork_id } => {
+                // Don't try to connect to peer if node is shutting down
                 if self.is_shutting_down() {
                     return None
                 }
-
-                // When `enforce_enr_fork_id` is enabled, peers discovered without a confirmed
-                // fork ID (via EIP-868 ENR) are deferred — they'll only be added once a
-                // `DiscoveredEnrForkId` event arrives with a validated fork ID.
-                //
-                // When disabled (default), peers without a fork ID are admitted immediately.
-                // Peers that *do* carry a fork ID are always validated against ours.
-                let enforce = self.state().peers().enforce_enr_fork_id();
-                let allow = match fork_id {
-                    Some(f) => self.sessions.is_valid_fork_id(f),
-                    None => !enforce,
-                };
-                if allow {
+                // Insert peer only if no fork id or a valid fork id
+                if fork_id.map_or_else(|| true, |f| self.sessions.is_valid_fork_id(f)) {
                     self.state_mut().peers_mut().add_peer(peer_id, addr, fork_id);
                 }
             }
-            StateAction::DiscoveredEnrForkId { peer_id, addr, fork_id } => {
+            StateAction::DiscoveredEnrForkId { peer_id, fork_id } => {
                 if self.sessions.is_valid_fork_id(fork_id) {
-                    self.state_mut().peers_mut().add_peer(peer_id, addr, Some(fork_id));
+                    self.state_mut().peers_mut().set_discovered_fork_id(peer_id, fork_id);
                 } else {
                     trace!(target: "net", ?peer_id, remote_fork_id=?fork_id, our_fork_id=?self.sessions.fork_id(), "fork id mismatch, removing peer");
                     self.state_mut().peers_mut().remove_peer(peer_id);

crates/node/core/src/args/engine.rs

@@ -43,7 +43,6 @@ pub struct DefaultEngineValues {
     disable_trie_cache: bool,
     sparse_trie_prune_depth: usize,
     sparse_trie_max_storage_tries: usize,
-    disable_sparse_trie_cache_pruning: bool,
     state_root_task_timeout: Option<String>,
 }
 
@@ -199,12 +198,6 @@ impl DefaultEngineValues {
         self
     }
 
-    /// Set whether to disable sparse trie cache pruning by default
-    pub const fn with_disable_sparse_trie_cache_pruning(mut self, v: bool) -> Self {
-        self.disable_sparse_trie_cache_pruning = v;
-        self
-    }
-
     /// Set the default state root task timeout
     pub fn with_state_root_task_timeout(mut self, v: Option<String>) -> Self {
         self.state_root_task_timeout = v;
@@ -238,7 +231,6 @@ impl Default for DefaultEngineValues {
             disable_trie_cache: false,
             sparse_trie_prune_depth: DEFAULT_SPARSE_TRIE_PRUNE_DEPTH,
             sparse_trie_max_storage_tries: DEFAULT_SPARSE_TRIE_MAX_STORAGE_TRIES,
-            disable_sparse_trie_cache_pruning: false,
             state_root_task_timeout: Some("1s".to_string()),
         }
     }
@@ -380,12 +372,6 @@ pub struct EngineArgs {
     #[arg(long = "engine.sparse-trie-max-storage-tries", default_value_t = DefaultEngineValues::get_global().sparse_trie_max_storage_tries)]
     pub sparse_trie_max_storage_tries: usize,
 
-    /// Fully disable sparse trie cache pruning. When set, the cached sparse trie is preserved
-    /// without any node pruning or storage trie eviction between blocks. Useful for benchmarking
-    /// the effects of retaining the full trie cache.
-    #[arg(long = "engine.disable-sparse-trie-cache-pruning", default_value_t = DefaultEngineValues::get_global().disable_sparse_trie_cache_pruning)]
-    pub disable_sparse_trie_cache_pruning: bool,
-
     /// Configure the timeout for the state root task before spawning a sequential fallback.
     /// If the state root task takes longer than this, a sequential computation starts in
     /// parallel and whichever finishes first is used.
@@ -429,7 +415,6 @@ impl Default for EngineArgs {
             disable_trie_cache,
             sparse_trie_prune_depth,
             sparse_trie_max_storage_tries,
-            disable_sparse_trie_cache_pruning,
             state_root_task_timeout,
         } = DefaultEngineValues::get_global().clone();
         Self {
@@ -460,7 +445,6 @@ impl Default for EngineArgs {
             disable_trie_cache,
             sparse_trie_prune_depth,
             sparse_trie_max_storage_tries,
-            disable_sparse_trie_cache_pruning,
             state_root_task_timeout: state_root_task_timeout
                 .as_deref()
                 .map(|s| humantime::parse_duration(s).expect("valid default duration")),
@@ -496,7 +480,6 @@ impl EngineArgs {
             .with_disable_trie_cache(self.disable_trie_cache)
             .with_sparse_trie_prune_depth(self.sparse_trie_prune_depth)
             .with_sparse_trie_max_storage_tries(self.sparse_trie_max_storage_tries)
-            .with_disable_sparse_trie_cache_pruning(self.disable_sparse_trie_cache_pruning)
             .with_state_root_task_timeout(self.state_root_task_timeout.filter(|d| !d.is_zero()))
     }
 }
@@ -551,7 +534,6 @@ mod tests {
             disable_trie_cache: true,
             sparse_trie_prune_depth: 10,
             sparse_trie_max_storage_tries: 100,
-            disable_sparse_trie_cache_pruning: true,
             state_root_task_timeout: Some(Duration::from_secs(2)),
         };
 
@@ -588,7 +570,6 @@ mod tests {
             "10",
             "--engine.sparse-trie-max-storage-tries",
             "100",
-            "--engine.disable-sparse-trie-cache-pruning",
             "--engine.state-root-task-timeout",
             "2s",
         ])

crates/node/core/src/args/mod.rs

@@ -76,7 +76,11 @@ pub use era::{DefaultEraHost, EraArgs, EraSourceArgs};
 mod static_files;
 pub use static_files::{StaticFilesArgs, MINIMAL_BLOCKS_PER_FILE};
 
-/// `StorageArgs` for configuring storage settings.
+/// `RocksDbArgs` for configuring RocksDB table routing.
+mod rocksdb;
+pub use rocksdb::{RocksDbArgs, RocksDbArgsError};
+
+/// `StorageArgs` for configuring storage mode (v2 vs v1/legacy).
 mod storage;
 pub use storage::StorageArgs;
 

crates/node/core/src/args/network.rs

@@ -227,14 +227,6 @@ pub struct NetworkArgs {
     /// Example: --netrestrict "192.168.0.0/16,10.0.0.0/8"
     #[arg(long, value_name = "NETRESTRICT")]
     pub netrestrict: Option<String>,
-
-    /// Enforce EIP-868 ENR fork ID validation for discovered peers.
-    ///
-    /// When enabled, peers discovered without a confirmed fork ID are not added to the peer set
-    /// until their fork ID is verified via EIP-868 ENR request. This filters out peers from other
-    /// networks that pollute the discovery table.
-    #[arg(long)]
-    pub enforce_enr_fork_id: bool,
 }
 
 impl NetworkArgs {
@@ -341,8 +333,7 @@ impl NetworkArgs {
             )
             .with_max_inbound_opt(self.resolved_max_inbound_peers())
             .with_max_outbound_opt(self.resolved_max_outbound_peers())
-            .with_ip_filter(ip_filter)
-            .with_enforce_enr_fork_id(self.enforce_enr_fork_id);
+            .with_ip_filter(ip_filter);
 
         // Configure basic network stack
         NetworkConfigBuilder::<N>::new(secret_key)
@@ -500,7 +491,6 @@ impl Default for NetworkArgs {
             required_block_hashes: vec![],
             network_id: None,
             netrestrict: None,
-            enforce_enr_fork_id: false,
         }
     }
 }

crates/node/core/src/args/rocksdb.rs

@@ -0,0 +1,160 @@
+//! clap [Args](clap::Args) for `RocksDB` table routing configuration
+
+use clap::{ArgAction, Args};
+
+/// Parameters for `RocksDB` table routing configuration.
+///
+/// These flags control which database tables are stored in `RocksDB` instead of MDBX.
+/// All flags are genesis-initialization-only: changing them after genesis requires a re-sync.
+///
+/// When `--storage.v2` is used, the defaults for these flags change to enable `RocksDB` routing.
+/// Individual flags can still override those defaults when explicitly set.
+#[derive(Debug, Args, PartialEq, Eq, Clone, Copy, Default)]
+#[command(next_help_heading = "RocksDB")]
+pub struct RocksDbArgs {
+    /// Route all supported tables to `RocksDB` instead of MDBX.
+    ///
+    /// This enables `RocksDB` for `tx-hash`, `storages-history`, and `account-history` tables.
+    /// Cannot be combined with individual flags set to false.
+    #[arg(long = "rocksdb.all", action = ArgAction::SetTrue)]
+    pub all: bool,
+
+    /// Route tx hash -> number table to `RocksDB` instead of MDBX.
+    ///
+    /// This is a genesis-initialization-only flag: changing it after genesis requires a re-sync.
+    /// Defaults to the base storage mode (v1: false, v2: true).
+    #[arg(long = "rocksdb.tx-hash", action = ArgAction::Set)]
+    pub tx_hash: Option<bool>,
+
+    /// Route storages history tables to `RocksDB` instead of MDBX.
+    ///
+    /// This is a genesis-initialization-only flag: changing it after genesis requires a re-sync.
+    /// Defaults to the base storage mode (v1: false, v2: true).
+    #[arg(long = "rocksdb.storages-history", action = ArgAction::Set)]
+    pub storages_history: Option<bool>,
+
+    /// Route account history tables to `RocksDB` instead of MDBX.
+    ///
+    /// This is a genesis-initialization-only flag: changing it after genesis requires a re-sync.
+    /// Defaults to the base storage mode (v1: false, v2: true).
+    #[arg(long = "rocksdb.account-history", action = ArgAction::Set)]
+    pub account_history: Option<bool>,
+}
+
+impl RocksDbArgs {
+    /// Validates the `RocksDB` arguments.
+    ///
+    /// Returns an error if `--rocksdb.all` is used with any individual flag explicitly set to
+    /// `false`.
+    pub const fn validate(&self) -> Result<(), RocksDbArgsError> {
+        if self.all {
+            if matches!(self.tx_hash, Some(false)) {
+                return Err(RocksDbArgsError::ConflictingFlags("tx-hash"));
+            }
+            if matches!(self.storages_history, Some(false)) {
+                return Err(RocksDbArgsError::ConflictingFlags("storages-history"));
+            }
+            if matches!(self.account_history, Some(false)) {
+                return Err(RocksDbArgsError::ConflictingFlags("account-history"));
+            }
+        }
+        Ok(())
+    }
+}
+
+/// Error type for `RocksDB` argument validation.
+#[derive(Debug, Clone, PartialEq, Eq, thiserror::Error)]
+pub enum RocksDbArgsError {
+    /// `--rocksdb.all` cannot be combined with an individual flag set to false.
+    #[error("--rocksdb.all cannot be combined with --rocksdb.{0}=false")]
+    ConflictingFlags(&'static str),
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use clap::Parser;
+
+    #[derive(Parser)]
+    struct CommandParser<T: Args> {
+        #[command(flatten)]
+        args: T,
+    }
+
+    #[test]
+    fn test_default_rocksdb_args() {
+        let args = CommandParser::<RocksDbArgs>::parse_from(["reth"]).args;
+        assert_eq!(args, RocksDbArgs::default());
+        assert!(!args.all);
+        assert!(args.tx_hash.is_none());
+        assert!(args.storages_history.is_none());
+        assert!(args.account_history.is_none());
+    }
+
+    #[test]
+    fn test_parse_all_flag() {
+        let args = CommandParser::<RocksDbArgs>::parse_from(["reth", "--rocksdb.all"]).args;
+        assert!(args.all);
+        assert!(args.tx_hash.is_none());
+    }
+
+    #[test]
+    fn test_parse_individual_flags() {
+        let args = CommandParser::<RocksDbArgs>::parse_from([
+            "reth",
+            "--rocksdb.tx-hash=true",
+            "--rocksdb.storages-history=false",
+            "--rocksdb.account-history=true",
+        ])
+        .args;
+        assert!(!args.all);
+        assert_eq!(args.tx_hash, Some(true));
+        assert_eq!(args.storages_history, Some(false));
+        assert_eq!(args.account_history, Some(true));
+    }
+
+    #[test]
+    fn test_validate_all_with_none_ok() {
+        let args =
+            RocksDbArgs { all: true, tx_hash: None, storages_history: None, account_history: None };
+        assert!(args.validate().is_ok());
+    }
+
+    #[test]
+    fn test_validate_all_with_true_ok() {
+        let args = RocksDbArgs {
+            all: true,
+            tx_hash: Some(true),
+            storages_history: Some(true),
+            account_history: Some(true),
+        };
+        assert!(args.validate().is_ok());
+    }
+
+    #[test]
+    fn test_validate_all_with_false_errors() {
+        let args = RocksDbArgs {
+            all: true,
+            tx_hash: Some(false),
+            storages_history: None,
+            account_history: None,
+        };
+        assert_eq!(args.validate(), Err(RocksDbArgsError::ConflictingFlags("tx-hash")));
+
+        let args = RocksDbArgs {
+            all: true,
+            tx_hash: None,
+            storages_history: Some(false),
+            account_history: None,
+        };
+        assert_eq!(args.validate(), Err(RocksDbArgsError::ConflictingFlags("storages-history")));
+
+        let args = RocksDbArgs {
+            all: true,
+            tx_hash: None,
+            storages_history: None,
+            account_history: Some(false),
+        };
+        assert_eq!(args.validate(), Err(RocksDbArgsError::ConflictingFlags("account-history")));
+    }
+}

crates/node/core/src/args/static_files.rs

@@ -9,6 +9,9 @@ use reth_config::config::{BlocksPerFileConfig, StaticFilesConfig};
 pub const MINIMAL_BLOCKS_PER_FILE: u64 = 10000;
 
 /// Parameters for static files configuration
+///
+/// When `--storage.v2` is used, the defaults for the storage flags change to enable static file
+/// storage. Individual flags can still override those defaults when explicitly set.
 #[derive(Debug, Args, PartialEq, Eq, Clone, Copy, Default)]
 #[command(next_help_heading = "Static Files")]
 pub struct StaticFilesArgs {
@@ -35,6 +38,53 @@ pub struct StaticFilesArgs {
     /// Number of blocks per file for the storage changesets segment.
     #[arg(long = "static-files.blocks-per-file.storage-change-sets")]
     pub blocks_per_file_storage_change_sets: Option<u64>,
+
+    /// Store receipts in static files instead of the database.
+    ///
+    /// When enabled, receipts will be written to static files on disk instead of the database.
+    ///
+    /// Note: This setting can only be configured at genesis initialization. Once
+    /// the node has been initialized, changing this flag requires re-syncing from scratch.
+    ///
+    /// Defaults to the base storage mode (v1: false, v2: true).
+    #[arg(long = "static-files.receipts", action = clap::ArgAction::Set)]
+    pub receipts: Option<bool>,
+
+    /// Store transaction senders in static files instead of the database.
+    ///
+    /// When enabled, transaction senders will be written to static files on disk instead of the
+    /// database.
+    ///
+    /// Note: This setting can only be configured at genesis initialization. Once
+    /// the node has been initialized, changing this flag requires re-syncing from scratch.
+    ///
+    /// Defaults to the base storage mode (v1: false, v2: true).
+    #[arg(long = "static-files.transaction-senders", action = clap::ArgAction::Set)]
+    pub transaction_senders: Option<bool>,
+
+    /// Store account changesets in static files.
+    ///
+    /// When enabled, account changesets will be written to static files on disk instead of the
+    /// database.
+    ///
+    /// Note: This setting can only be configured at genesis initialization. Once
+    /// the node has been initialized, changing this flag requires re-syncing from scratch.
+    ///
+    /// Defaults to the base storage mode (v1: false, v2: true).
+    #[arg(long = "static-files.account-change-sets", action = clap::ArgAction::Set)]
+    pub account_changesets: Option<bool>,
+
+    /// Store storage changesets in static files.
+    ///
+    /// When enabled, storage changesets will be written to static files on disk instead of the
+    /// database.
+    ///
+    /// Note: This setting can only be configured at genesis initialization. Once
+    /// the node has been initialized, changing this flag requires re-syncing from scratch.
+    ///
+    /// Defaults to the base storage mode (v1: false, v2: true).
+    #[arg(long = "static-files.storage-change-sets", action = clap::ArgAction::Set)]
+    pub storage_changesets: Option<bool>,
 }
 
 impl StaticFilesArgs {

crates/node/core/src/args/storage.rs

@@ -1,13 +1,11 @@
-//! clap [Args](clap::Args) for storage configuration
+//! clap [Args](clap::Args) for storage mode configuration
 
 use clap::{ArgAction, Args};
 
-/// Parameters for storage configuration.
+/// Parameters for storage mode configuration.
 ///
 /// This controls whether the node uses v2 storage defaults (with `RocksDB` and static file
 /// optimizations) or v1/legacy storage defaults.
-///
-/// Individual storage settings can be overridden with `--static-files.*` and `--rocksdb.*` flags.
 #[derive(Debug, Args, PartialEq, Eq, Clone, Copy, Default)]
 #[command(next_help_heading = "Storage")]
 pub struct StorageArgs {
@@ -25,6 +23,16 @@ pub struct StorageArgs {
     /// flags.
     #[arg(long = "storage.v2", action = ArgAction::SetTrue)]
     pub v2: bool,
+
+    /// Use hashed state tables (`HashedAccounts`/`HashedStorages`) as canonical state
+    /// representation instead of plain state tables.
+    ///
+    /// When enabled, execution writes directly to hashed tables, eliminating the need for
+    /// separate hashing stages. This should only be enabled for new databases.
+    ///
+    /// WARNING: Changing this setting on an existing database requires a full resync.
+    #[arg(long = "storage.use-hashed-state", default_value_t = false)]
+    pub use_hashed_state: bool,
 }
 
 #[cfg(test)]
@@ -32,24 +40,21 @@ mod tests {
     use super::*;
     use clap::Parser;
 
-    /// A helper type to parse Args more easily
     #[derive(Parser)]
-    struct CommandParser<T: Args> {
+    struct CommandParser {
         #[command(flatten)]
-        args: T,
+        args: StorageArgs,
     }
 
     #[test]
     fn test_default_storage_args() {
-        let default_args = StorageArgs::default();
-        let args = CommandParser::<StorageArgs>::parse_from(["reth"]).args;
-        assert_eq!(args, default_args);
+        let args = CommandParser::parse_from(["reth"]).args;
         assert!(!args.v2);
     }
 
     #[test]
     fn test_parse_v2_flag() {
-        let args = CommandParser::<StorageArgs>::parse_from(["reth", "--storage.v2"]).args;
+        let args = CommandParser::parse_from(["reth", "--storage.v2"]).args;
         assert!(args.v2);
     }
 }

crates/node/core/src/node_config.rs

@@ -3,7 +3,7 @@
 use crate::{
     args::{
         DatabaseArgs, DatadirArgs, DebugArgs, DevArgs, EngineArgs, NetworkArgs, PayloadBuilderArgs,
-        PruningArgs, RpcServerArgs, StaticFilesArgs, StorageArgs, TxPoolArgs,
+        PruningArgs, RocksDbArgs, RpcServerArgs, StaticFilesArgs, StorageArgs, TxPoolArgs,
     },
     dirs::{ChainPath, DataDirPath},
     utils::get_single_header,
@@ -152,7 +152,10 @@ pub struct NodeConfig<ChainSpec> {
     /// All static files related arguments
     pub static_files: StaticFilesArgs,
 
-    /// All storage related arguments with --storage prefix
+    /// All `RocksDB` table routing arguments
+    pub rocksdb: RocksDbArgs,
+
+    /// Storage mode configuration (v2 vs v1/legacy)
     pub storage: StorageArgs,
 }
 
@@ -185,6 +188,7 @@ impl<ChainSpec> NodeConfig<ChainSpec> {
             engine: EngineArgs::default(),
             era: EraArgs::default(),
             static_files: StaticFilesArgs::default(),
+            rocksdb: RocksDbArgs::default(),
             storage: StorageArgs::default(),
         }
     }
@@ -260,6 +264,7 @@ impl<ChainSpec> NodeConfig<ChainSpec> {
             engine,
             era,
             static_files,
+            rocksdb,
             storage,
             ..
         } = self;
@@ -280,6 +285,7 @@ impl<ChainSpec> NodeConfig<ChainSpec> {
             engine,
             era,
             static_files,
+            rocksdb,
             storage,
         }
     }
@@ -349,12 +355,6 @@ impl<ChainSpec> NodeConfig<ChainSpec> {
         self
     }
 
-    /// Set the storage args for the node
-    pub const fn with_storage(mut self, storage: StorageArgs) -> Self {
-        self.storage = storage;
-        self
-    }
-
     /// Returns pruning configuration.
     pub fn prune_config(&self) -> Option<PruneConfig>
     where
@@ -363,17 +363,42 @@ impl<ChainSpec> NodeConfig<ChainSpec> {
         self.pruning.prune_config(&self.chain)
     }
 
-    /// Returns the effective storage settings derived from `--storage.v2`.
+    /// Returns the effective storage settings derived from `--storage.v2`, static-file, and
+    /// `RocksDB` CLI args.
     ///
     /// The base storage mode is determined by `--storage.v2`:
     /// - When `--storage.v2` is set: uses [`StorageSettings::v2()`] defaults
-    /// - Otherwise: uses [`StorageSettings::base()`] defaults
+    /// - Otherwise: uses [`StorageSettings::v1()`] defaults
+    ///
+    /// Individual `--static-files.*` and `--rocksdb.*` flags override the base when explicitly set.
     pub const fn storage_settings(&self) -> StorageSettings {
-        if self.storage.v2 {
-            StorageSettings::v2()
-        } else {
-            StorageSettings::base()
+        let mut s = if self.storage.v2 { StorageSettings::v2() } else { StorageSettings::base() };
+
+        // Apply static files overrides (only when explicitly set)
+        s = s
+            .with_receipts_in_static_files_opt(self.static_files.receipts)
+            .with_transaction_senders_in_static_files_opt(self.static_files.transaction_senders)
+            .with_account_changesets_in_static_files_opt(self.static_files.account_changesets)
+            .with_storage_changesets_in_static_files_opt(self.static_files.storage_changesets);
+
+        // Apply rocksdb overrides
+        // --rocksdb.all sets all rocksdb flags to true
+        if self.rocksdb.all {
+            s = s
+                .with_transaction_hash_numbers_in_rocksdb(true)
+                .with_storages_history_in_rocksdb(true)
+                .with_account_history_in_rocksdb(true);
         }
+
+        // Individual rocksdb flags override --rocksdb.all when explicitly set
+        s = s
+            .with_transaction_hash_numbers_in_rocksdb_opt(self.rocksdb.tx_hash)
+            .with_storages_history_in_rocksdb_opt(self.rocksdb.storages_history)
+            .with_account_history_in_rocksdb_opt(self.rocksdb.account_history);
+
+        s = s.with_use_hashed_state(self.storage.use_hashed_state);
+
+        s
     }
 
     /// Returns the max block that the node should run to, looking it up from the network if
@@ -570,6 +595,7 @@ impl<ChainSpec> NodeConfig<ChainSpec> {
             engine: self.engine,
             era: self.era,
             static_files: self.static_files,
+            rocksdb: self.rocksdb,
             storage: self.storage,
         }
     }
@@ -612,6 +638,7 @@ impl<ChainSpec> Clone for NodeConfig<ChainSpec> {
             engine: self.engine.clone(),
             era: self.era.clone(),
             static_files: self.static_files,
+            rocksdb: self.rocksdb,
             storage: self.storage,
         }
     }

crates/node/events/src/node.rs

@@ -265,7 +265,7 @@ impl NodeState {
                 warn!(number=block.number(), hash=?block.hash(), "Encountered invalid block");
             }
             ConsensusEngineEvent::BlockReceived(num_hash) => {
-                info!(number=num_hash.number, hash=?num_hash.hash, "Received new payload from consensus engine");
+                info!(number=num_hash.number, hash=?num_hash.hash, "Received block from consensus engine");
             }
         }
     }

crates/primitives-traits/src/account.rs

@@ -4,7 +4,7 @@ use alloy_genesis::GenesisAccount;
 use alloy_primitives::{keccak256, Bytes, B256, U256};
 use alloy_trie::TrieAccount;
 use derive_more::Deref;
-use revm_bytecode::{Bytecode as RevmBytecode, BytecodeDecodeError};
+use revm_bytecode::{Bytecode as RevmBytecode, BytecodeDecodeError, BytecodeKind};
 use revm_state::AccountInfo;
 
 #[cfg(any(test, feature = "reth-codec"))]
@@ -16,10 +16,10 @@ pub mod compact_ids {
     /// Identifier for removed bytecode variant.
     pub const REMOVED_BYTECODE_ID: u8 = 1;
 
-    /// Identifier for [`LegacyAnalyzed`](revm_bytecode::Bytecode::LegacyAnalyzed).
+    /// Identifier for [`LegacyAnalyzed`](revm_bytecode::BytecodeKind::LegacyAnalyzed).
     pub const LEGACY_ANALYZED_BYTECODE_ID: u8 = 2;
 
-    /// Identifier for [`Eip7702`](revm_bytecode::Bytecode::Eip7702).
+    /// Identifier for [`Eip7702`](revm_bytecode::BytecodeKind::Eip7702).
     pub const EIP7702_BYTECODE_ID: u8 = 4;
 }
 
@@ -137,22 +137,19 @@ impl reth_codecs::Compact for Bytecode {
     {
         use compact_ids::{EIP7702_BYTECODE_ID, LEGACY_ANALYZED_BYTECODE_ID};
 
-        let bytecode = match &self.0 {
-            RevmBytecode::LegacyAnalyzed(analyzed) => analyzed.bytecode(),
-            RevmBytecode::Eip7702(eip7702) => eip7702.raw(),
-        };
+        let bytecode = self.0.bytecode();
         buf.put_u32(bytecode.len() as u32);
         buf.put_slice(bytecode.as_ref());
-        let len = match &self.0 {
+        let len = match self.0.kind() {
             // [`REMOVED_BYTECODE_ID`] has been removed.
-            RevmBytecode::LegacyAnalyzed(analyzed) => {
+            BytecodeKind::LegacyAnalyzed => {
                 buf.put_u8(LEGACY_ANALYZED_BYTECODE_ID);
-                buf.put_u64(analyzed.original_len() as u64);
-                let map = analyzed.jump_table().as_slice();
+                buf.put_u64(self.0.len() as u64);
+                let map = self.0.legacy_jump_table().unwrap().as_slice();
                 buf.put_slice(map);
                 1 + 8 + map.len()
             }
-            RevmBytecode::Eip7702(_) => {
+            BytecodeKind::Eip7702 => {
                 buf.put_u8(EIP7702_BYTECODE_ID);
                 1
             }
@@ -251,12 +248,10 @@ impl From<Account> for AccountInfo {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
-
     use super::*;
     use alloy_primitives::{hex_literal::hex, B256, U256};
     use reth_codecs::Compact;
-    use revm_bytecode::{JumpTable, LegacyAnalyzedBytecode};
+    use revm_bytecode::JumpTable;
 
     #[test]
     fn test_account() {
@@ -313,12 +308,11 @@ mod tests {
         assert_eq!(len, 17);
 
         let mut buf = vec![];
-        let bytecode =
-            Bytecode(RevmBytecode::LegacyAnalyzed(Arc::new(LegacyAnalyzedBytecode::new(
-                Bytes::from(&hex!("ff00")),
-                2,
-                JumpTable::from_slice(&[0], 2),
-            ))));
+        let bytecode = Bytecode(RevmBytecode::new_analyzed(
+            Bytes::from(&hex!("ff00")),
+            2,
+            JumpTable::from_slice(&[0], 2),
+        ));
         let len = bytecode.to_compact(&mut buf);
         assert_eq!(len, 16);
 

crates/primitives-traits/src/lib.rs

@@ -164,7 +164,7 @@ pub use alloy_primitives::{logs_bloom, Log, LogData};
 pub mod proofs;
 
 mod storage;
-pub use storage::{StorageEntry, StorageSlotKey, ValueWithSubKey};
+pub use storage::{StorageEntry, ValueWithSubKey};
 
 pub mod sync;
 

crates/primitives-traits/src/storage.rs

@@ -1,4 +1,4 @@
-use alloy_primitives::{keccak256, B256, U256};
+use alloy_primitives::{B256, U256};
 
 /// Trait for `DupSort` table values that contain a subkey.
 ///
@@ -12,117 +12,6 @@ pub trait ValueWithSubKey {
     fn get_subkey(&self) -> Self::SubKey;
 }
 
-/// A storage slot key that tracks whether it holds a plain (unhashed) EVM slot
-/// or a keccak256-hashed slot.
-///
-/// This enum replaces the `use_hashed_state: bool` parameter pattern by carrying
-/// provenance with the key itself. Once tagged at a read/write boundary, downstream
-/// code can call [`Self::to_hashed`] without risk of double-hashing — hashing a
-/// [`StorageSlotKey::Hashed`] is a no-op.
-///
-/// The on-disk encoding is unchanged (raw 32-byte [`B256`]). The variant is set
-/// by the code that knows the context (which table, which storage mode).
-#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum StorageSlotKey {
-    /// An unhashed EVM storage slot, as produced by REVM execution.
-    Plain(B256),
-    /// A keccak256-hashed storage slot, as stored in `HashedStorages` and
-    /// in v2-mode `StorageChangeSets`.
-    Hashed(B256),
-}
-
-impl Default for StorageSlotKey {
-    fn default() -> Self {
-        Self::Plain(B256::ZERO)
-    }
-}
-
-impl StorageSlotKey {
-    /// Create a plain slot key from a REVM [`U256`] storage index.
-    pub const fn from_u256(slot: U256) -> Self {
-        Self::Plain(B256::new(slot.to_be_bytes()))
-    }
-
-    /// Create a plain slot key from a raw [`B256`].
-    pub const fn plain(key: B256) -> Self {
-        Self::Plain(key)
-    }
-
-    /// Create a hashed slot key from a raw [`B256`].
-    pub const fn hashed(key: B256) -> Self {
-        Self::Hashed(key)
-    }
-
-    /// Tag a raw [`B256`] based on the storage mode.
-    ///
-    /// When `use_hashed_state` is true the key is assumed already hashed.
-    /// When false it is assumed to be a plain slot.
-    pub const fn from_raw(key: B256, use_hashed_state: bool) -> Self {
-        if use_hashed_state {
-            Self::Hashed(key)
-        } else {
-            Self::Plain(key)
-        }
-    }
-
-    /// Returns the raw [`B256`] regardless of variant.
-    pub const fn as_b256(&self) -> B256 {
-        match *self {
-            Self::Plain(b) | Self::Hashed(b) => b,
-        }
-    }
-
-    /// Returns `true` if this key is already hashed.
-    pub const fn is_hashed(&self) -> bool {
-        matches!(self, Self::Hashed(_))
-    }
-
-    /// Returns `true` if this key is plain (unhashed).
-    pub const fn is_plain(&self) -> bool {
-        matches!(self, Self::Plain(_))
-    }
-
-    /// Produce the keccak256-hashed form of this slot key.
-    ///
-    /// - If already [`Hashed`](Self::Hashed), returns the inner value as-is (no double-hash).
-    /// - If [`Plain`](Self::Plain), applies keccak256 and returns the result.
-    pub fn to_hashed(&self) -> B256 {
-        match *self {
-            Self::Hashed(b) => b,
-            Self::Plain(b) => keccak256(b),
-        }
-    }
-
-    /// Convert a plain slot to its changeset representation.
-    ///
-    /// In v2 mode (`use_hashed_state = true`), the changeset stores hashed keys,
-    /// so the plain key is hashed. In v1 mode, the plain key is stored as-is.
-    ///
-    /// Panics (debug) if called on an already-hashed key.
-    pub fn to_changeset_key(self, use_hashed_state: bool) -> B256 {
-        debug_assert!(self.is_plain(), "to_changeset_key called on already-hashed key");
-        if use_hashed_state {
-            self.to_hashed()
-        } else {
-            self.as_b256()
-        }
-    }
-
-    /// Like [`to_changeset_key`](Self::to_changeset_key) but returns a tagged
-    /// [`StorageSlotKey`] instead of a raw [`B256`].
-    ///
-    /// Panics (debug) if called on an already-hashed key.
-    pub fn to_changeset(self, use_hashed_state: bool) -> Self {
-        Self::from_raw(self.to_changeset_key(use_hashed_state), use_hashed_state)
-    }
-}
-
-impl From<StorageSlotKey> for B256 {
-    fn from(key: StorageSlotKey) -> Self {
-        key.as_b256()
-    }
-}
-
 /// Account storage entry.
 ///
 /// `key` is the subkey when used as a value in the `StorageChangeSets` table.
@@ -142,14 +31,6 @@ impl StorageEntry {
     pub const fn new(key: B256, value: U256) -> Self {
         Self { key, value }
     }
-
-    /// Tag this entry's key as a [`StorageSlotKey`] based on the storage mode.
-    ///
-    /// When `use_hashed_state` is true, the key is tagged as already-hashed.
-    /// When false, it is tagged as plain.
-    pub const fn slot_key(&self, use_hashed_state: bool) -> StorageSlotKey {
-        StorageSlotKey::from_raw(self.key, use_hashed_state)
-    }
 }
 
 impl ValueWithSubKey for StorageEntry {

crates/prune/prune/src/segments/user/account_history.rs

@@ -75,7 +75,7 @@ where
 
         // Check where account history indices are stored
         #[cfg(all(unix, feature = "rocksdb"))]
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().account_history_in_rocksdb {
             return self.prune_rocksdb(provider, input, range, range_end);
         }
 
@@ -405,7 +405,9 @@ mod tests {
                 let segment = AccountHistory::new(prune_mode);
 
                 let provider = db.factory.database_provider_rw().unwrap();
-                provider.set_storage_settings_cache(StorageSettings::v1());
+                provider.set_storage_settings_cache(
+                    StorageSettings::default().with_account_changesets_in_static_files(false),
+                );
                 let result = segment.prune(&provider, input).unwrap();
                 limiter.increment_deleted_entries_count_by(result.pruned);
 
@@ -506,11 +508,7 @@ mod tests {
         test_prune(1400, 3, (PruneProgress::Finished, 804));
     }
 
-    /// Tests the `prune_static_files` code path. On unix with rocksdb feature, v2 storage
-    /// routes to `prune_rocksdb` instead, so this test only runs without rocksdb (the
-    /// `prune_rocksdb_path` test covers that configuration).
     #[test]
-    #[cfg(not(all(unix, feature = "rocksdb")))]
     fn prune_static_file() {
         let db = TestStageDB::default();
         let mut rng = generators::rng();
@@ -566,7 +564,9 @@ mod tests {
                 let segment = AccountHistory::new(prune_mode);
 
                 let provider = db.factory.database_provider_rw().unwrap();
-                provider.set_storage_settings_cache(StorageSettings::v2());
+                provider.set_storage_settings_cache(
+                    StorageSettings::default().with_account_changesets_in_static_files(true),
+                );
                 let result = segment.prune(&provider, input).unwrap();
                 limiter.increment_deleted_entries_count_by(result.pruned);
 
@@ -714,7 +714,11 @@ mod tests {
             PruneInput { previous_checkpoint: None, to_block, limiter: PruneLimiter::default() };
         let segment = AccountHistory::new(prune_mode);
 
-        db.factory.set_storage_settings_cache(StorageSettings::v2());
+        db.factory.set_storage_settings_cache(
+            StorageSettings::default()
+                .with_account_changesets_in_static_files(true)
+                .with_account_history_in_rocksdb(true),
+        );
 
         let provider = db.factory.database_provider_rw().unwrap();
         let result = segment.prune(&provider, input).unwrap();
@@ -828,7 +832,9 @@ mod tests {
         let segment = AccountHistory::new(prune_mode);
 
         let provider = db.factory.database_provider_rw().unwrap();
-        provider.set_storage_settings_cache(StorageSettings::v1());
+        provider.set_storage_settings_cache(
+            StorageSettings::default().with_account_changesets_in_static_files(false),
+        );
         let result = segment.prune(&provider, input).unwrap();
 
         // Should report that there's more data
@@ -886,7 +892,9 @@ mod tests {
         };
 
         let provider2 = db.factory.database_provider_rw().unwrap();
-        provider2.set_storage_settings_cache(StorageSettings::v1());
+        provider2.set_storage_settings_cache(
+            StorageSettings::default().with_account_changesets_in_static_files(false),
+        );
         let result2 = segment.prune(&provider2, input2).unwrap();
 
         assert!(result2.progress.is_finished(), "Second run should complete");

crates/prune/prune/src/segments/user/storage_history.rs

@@ -76,7 +76,7 @@ where
 
         // Check where storage history indices are stored
         #[cfg(all(unix, feature = "rocksdb"))]
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().storages_history_in_rocksdb {
             return self.prune_rocksdb(provider, input, range, range_end);
         }
 
@@ -135,7 +135,7 @@ impl StorageHistory {
             let (block_address, entry) = result?;
             let block_number = block_address.block_number();
             let address = block_address.address();
-            highest_deleted_storages.insert((address, entry.key.as_b256()), block_number);
+            highest_deleted_storages.insert((address, entry.key), block_number);
             last_changeset_pruned_block = Some(block_number);
             pruned_changesets += 1;
             limiter.increment_deleted_entries_count();
@@ -273,7 +273,7 @@ impl StorageHistory {
             let (block_address, entry) = result?;
             let block_number = block_address.block_number();
             let address = block_address.address();
-            highest_deleted_storages.insert((address, entry.key.as_b256()), block_number);
+            highest_deleted_storages.insert((address, entry.key), block_number);
             last_changeset_pruned_block = Some(block_number);
             changesets_processed += 1;
             limiter.increment_deleted_entries_count();
@@ -413,7 +413,9 @@ mod tests {
             let segment = StorageHistory::new(prune_mode);
 
             let provider = db.factory.database_provider_rw().unwrap();
-            provider.set_storage_settings_cache(StorageSettings::v1());
+            provider.set_storage_settings_cache(
+                StorageSettings::default().with_storage_changesets_in_static_files(false),
+            );
             let result = segment.prune(&provider, input).unwrap();
             limiter.increment_deleted_entries_count_by(result.pruned);
 
@@ -518,11 +520,7 @@ mod tests {
         test_prune(1200, 3, (PruneProgress::Finished, 202));
     }
 
-    /// Tests the `prune_static_files` code path. On unix with rocksdb feature, v2 storage
-    /// routes to `prune_rocksdb` instead, so this test only runs without rocksdb (the
-    /// `prune_rocksdb_path` test covers that configuration).
     #[test]
-    #[cfg(not(all(unix, feature = "rocksdb")))]
     fn prune_static_file() {
         let db = TestStageDB::default();
         let mut rng = generators::rng();
@@ -579,7 +577,9 @@ mod tests {
             let segment = StorageHistory::new(prune_mode);
 
             let provider = db.factory.database_provider_rw().unwrap();
-            provider.set_storage_settings_cache(StorageSettings::v2());
+            provider.set_storage_settings_cache(
+                StorageSettings::default().with_storage_changesets_in_static_files(true),
+            );
             let result = segment.prune(&provider, input).unwrap();
             limiter.increment_deleted_entries_count_by(result.pruned);
 
@@ -739,7 +739,9 @@ mod tests {
         let segment = StorageHistory::new(prune_mode);
 
         let provider = db.factory.database_provider_rw().unwrap();
-        provider.set_storage_settings_cache(StorageSettings::v1());
+        provider.set_storage_settings_cache(
+            StorageSettings::default().with_storage_changesets_in_static_files(false),
+        );
         let result = segment.prune(&provider, input).unwrap();
 
         // Should report that there's more data
@@ -791,7 +793,9 @@ mod tests {
         };
 
         let provider2 = db.factory.database_provider_rw().unwrap();
-        provider2.set_storage_settings_cache(StorageSettings::v1());
+        provider2.set_storage_settings_cache(
+            StorageSettings::default().with_storage_changesets_in_static_files(false),
+        );
         let result2 = segment.prune(&provider2, input2).unwrap();
 
         assert!(result2.progress.is_finished(), "Second run should complete");
@@ -891,7 +895,11 @@ mod tests {
         let segment = StorageHistory::new(prune_mode);
 
         let provider = db.factory.database_provider_rw().unwrap();
-        provider.set_storage_settings_cache(StorageSettings::v2());
+        provider.set_storage_settings_cache(
+            StorageSettings::default()
+                .with_storage_changesets_in_static_files(true)
+                .with_storages_history_in_rocksdb(true),
+        );
         let result = segment.prune(&provider, input).unwrap();
         provider.commit().expect("commit");
 

crates/prune/prune/src/segments/user/transaction_lookup.rs

@@ -96,7 +96,7 @@ where
 
         // Check where transaction hash numbers are stored
         #[cfg(all(unix, feature = "rocksdb"))]
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().transaction_hash_numbers_in_rocksdb {
             return self.prune_rocksdb(provider, input, start, end);
         }
 
@@ -491,7 +491,9 @@ mod tests {
         let segment = TransactionLookup::new(prune_mode);
 
         // Enable RocksDB storage for transaction hash numbers
-        db.factory.set_storage_settings_cache(StorageSettings::v2());
+        db.factory.set_storage_settings_cache(
+            StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+        );
 
         let provider = db.factory.database_provider_rw().unwrap();
         let result = segment.prune(&provider, input).unwrap();
@@ -576,7 +578,9 @@ mod tests {
         }
 
         // Enable RocksDB storage for transaction hash numbers
-        db.factory.set_storage_settings_cache(StorageSettings::v2());
+        db.factory.set_storage_settings_cache(
+            StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+        );
 
         let to_block: BlockNumber = 6;
         let prune_mode = PruneMode::Before(to_block);

crates/revm/src/test_utils.rs

@@ -160,14 +160,6 @@ impl StateProvider for StateProviderTest {
     ) -> ProviderResult<Option<alloy_primitives::StorageValue>> {
         Ok(self.accounts.get(&account).and_then(|(storage, _)| storage.get(&storage_key).copied()))
     }
-
-    fn storage_by_hashed_key(
-        &self,
-        _address: Address,
-        _hashed_storage_key: StorageKey,
-    ) -> ProviderResult<Option<alloy_primitives::StorageValue>> {
-        Ok(None)
-    }
 }
 
 impl BytecodeReader for StateProviderTest {

crates/revm/src/witness.rs

@@ -70,8 +70,8 @@ impl ExecutionWitnessRecord {
                 }
             }
         }
-        // BTreeMap keys are ordered, so the first key is the smallest
-        self.lowest_block_number = statedb.block_hashes.keys().next().copied()
+        // Get the lowest block number from the cache
+        self.lowest_block_number = statedb.block_hashes.lowest().map(|(n, _)| n)
     }
 
     /// Creates the record from the state after execution.

crates/rpc/rpc-eth-api/src/helpers/estimate.rs

@@ -172,7 +172,7 @@ pub trait EstimateCall: Call {
         };
 
         let gas_refund = match res.result {
-            ExecutionResult::Success { gas_refunded, .. } => gas_refunded,
+            ExecutionResult::Success { gas, .. } => gas.inner_refunded(),
             ExecutionResult::Halt { reason, .. } => {
                 // here we don't check for invalid opcode because already executed with highest gas
                 // limit

crates/rpc/rpc-eth-types/src/cache/db.rs

@@ -154,14 +154,6 @@ impl StateProvider for StateProviderTraitObjWrapper {
         self.0.storage(account, storage_key)
     }
 
-    fn storage_by_hashed_key(
-        &self,
-        address: Address,
-        hashed_storage_key: alloy_primitives::StorageKey,
-    ) -> reth_errors::ProviderResult<Option<alloy_primitives::StorageValue>> {
-        self.0.storage_by_hashed_key(address, hashed_storage_key)
-    }
-
     fn account_code(
         &self,
         addr: &Address,

crates/rpc/rpc-eth-types/src/error/api.rs

@@ -125,9 +125,7 @@ pub trait FromEvmError<Evm: ConfigureEvm>:
         match result {
             ExecutionResult::Success { output, .. } => Ok(output.into_data()),
             ExecutionResult::Revert { output, .. } => Err(Self::from_revert(output)),
-            ExecutionResult::Halt { reason, gas_used } => {
-                Err(Self::from_evm_halt(reason, gas_used))
-            }
+            ExecutionResult::Halt { reason, gas } => Err(Self::from_evm_halt(reason, gas.used())),
         }
     }
 }

crates/rpc/rpc-eth-types/src/simulate.rs

@@ -352,7 +352,7 @@ where
     let mut log_index = 0;
     for (index, (result, tx)) in results.into_iter().zip(block.body().transactions()).enumerate() {
         let call = match result {
-            ExecutionResult::Halt { reason, gas_used } => {
+            ExecutionResult::Halt { reason, gas } => {
                 let error = Err::from_evm_halt(reason, tx.gas_limit());
                 #[allow(clippy::needless_update)]
                 SimCallResult {
@@ -362,12 +362,12 @@ where
                         code: SIMULATE_VM_ERROR_CODE,
                         ..SimulateError::invalid_params()
                     }),
-                    gas_used,
+                    gas_used: gas.used(),
                     logs: Vec::new(),
                     status: false,
                 }
             }
-            ExecutionResult::Revert { output, gas_used } => {
+            ExecutionResult::Revert { output, gas } => {
                 let error = Err::from_revert(output.clone());
                 #[allow(clippy::needless_update)]
                 SimCallResult {
@@ -377,15 +377,15 @@ where
                         code: SIMULATE_REVERT_CODE,
                         ..SimulateError::invalid_params()
                     }),
-                    gas_used,
+                    gas_used: gas.used(),
                     status: false,
                     logs: Vec::new(),
                 }
             }
-            ExecutionResult::Success { output, gas_used, logs, .. } => SimCallResult {
+            ExecutionResult::Success { output, gas, logs, .. } => SimCallResult {
                 return_data: output.into_data(),
                 error: None,
-                gas_used,
+                gas_used: gas.used(),
                 logs: logs
                     .into_iter()
                     .map(|log| {

crates/stages/stages/src/stages/execution.rs

@@ -22,7 +22,6 @@ use reth_stages_api::{
     UnwindInput, UnwindOutput,
 };
 use reth_static_file_types::StaticFileSegment;
-use reth_trie::KeccakKeyHasher;
 use std::{
     cmp::{max, Ordering},
     collections::BTreeMap,
@@ -462,16 +461,9 @@ where
             }
         }
 
-        // Write output. When `use_hashed_state` is enabled, `write_state` skips writing to
-        // plain account/storage tables and only writes bytecodes and changesets. The hashed
-        // state is then written separately below.
+        // write output
         provider.write_state(&state, OriginalValuesKnown::Yes, StateWriteConfig::default())?;
 
-        if provider.cached_storage_settings().use_hashed_state() {
-            let hashed_state = state.hash_state_slow::<KeccakKeyHasher>();
-            provider.write_hashed_state(&hashed_state.into_sorted())?;
-        }
-
         let db_write_duration = time.elapsed();
         debug!(
             target: "sync::stages::execution",
@@ -1269,7 +1261,8 @@ mod tests {
         // but no receipt data is written.
 
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory
+            .set_storage_settings_cache(StorageSettings::v1().with_receipts_in_static_files(true));
 
         // Setup with block 1
         let provider_rw = factory.database_provider_rw().unwrap();

crates/stages/stages/src/stages/hashing_account.rs

@@ -9,9 +9,7 @@ use reth_db_api::{
 };
 use reth_etl::Collector;
 use reth_primitives_traits::Account;
-use reth_provider::{
-    AccountExtReader, DBProvider, HashingWriter, StatsReader, StorageSettingsCache,
-};
+use reth_provider::{AccountExtReader, DBProvider, HashingWriter, StatsReader};
 use reth_stages_api::{
     AccountHashingCheckpoint, EntitiesCheckpoint, ExecInput, ExecOutput, Stage, StageCheckpoint,
     StageError, StageId, UnwindInput, UnwindOutput,
@@ -136,11 +134,7 @@ impl Default for AccountHashingStage {
 
 impl<Provider> Stage<Provider> for AccountHashingStage
 where
-    Provider: DBProvider<Tx: DbTxMut>
-        + HashingWriter
-        + AccountExtReader
-        + StatsReader
-        + StorageSettingsCache,
+    Provider: DBProvider<Tx: DbTxMut> + HashingWriter + AccountExtReader + StatsReader,
 {
     /// Return the id of the stage
     fn id(&self) -> StageId {
@@ -148,21 +142,11 @@ where
     }
 
     /// Execute the stage.
-    ///
-    /// When `use_hashed_state` is enabled, this stage is a no-op because the execution stage
-    /// writes directly to `HashedAccounts`. Otherwise, it hashes plain state to populate hashed
-    /// tables.
     fn execute(&mut self, provider: &Provider, input: ExecInput) -> Result<ExecOutput, StageError> {
         if input.target_reached() {
             return Ok(ExecOutput::done(input.checkpoint()))
         }
 
-        // If using hashed state as canonical, execution already writes to `HashedAccounts`,
-        // so this stage becomes a no-op.
-        if provider.cached_storage_settings().use_hashed_state() {
-            return Ok(ExecOutput::done(input.checkpoint().with_block_number(input.target())));
-        }
-
         let (from_block, to_block) = input.next_block_range().into_inner();
 
         // if there are more blocks then threshold it is faster to go over Plain state and hash all
@@ -250,14 +234,10 @@ where
         provider: &Provider,
         input: UnwindInput,
     ) -> Result<UnwindOutput, StageError> {
-        // NOTE: this runs in both v1 and v2 mode. In v2 mode, execution writes
-        // directly to `HashedAccounts`, but the unwind must still revert those
-        // entries here because `MerkleUnwind` runs after this stage (in unwind
-        // order) and needs `HashedAccounts` to reflect the target block state
-        // before it can verify the state root.
         let (range, unwind_progress, _) =
             input.unwind_block_range_with_threshold(self.commit_threshold);
 
+        // Aggregate all transition changesets and make a list of accounts that have been changed.
         provider.unwind_account_hashing_range(range)?;
 
         let mut stage_checkpoint =

crates/stages/stages/src/stages/hashing_storage.rs

@@ -15,7 +15,6 @@ use reth_stages_api::{
     EntitiesCheckpoint, ExecInput, ExecOutput, Stage, StageCheckpoint, StageError, StageId,
     StorageHashingCheckpoint, UnwindInput, UnwindOutput,
 };
-use reth_storage_api::StorageSettingsCache;
 use reth_storage_errors::provider::ProviderResult;
 use std::{
     fmt::Debug,
@@ -69,11 +68,7 @@ impl Default for StorageHashingStage {
 
 impl<Provider> Stage<Provider> for StorageHashingStage
 where
-    Provider: DBProvider<Tx: DbTxMut>
-        + StorageReader
-        + HashingWriter
-        + StatsReader
-        + StorageSettingsCache,
+    Provider: DBProvider<Tx: DbTxMut> + StorageReader + HashingWriter + StatsReader,
 {
     /// Return the id of the stage
     fn id(&self) -> StageId {
@@ -87,12 +82,6 @@ where
             return Ok(ExecOutput::done(input.checkpoint()))
         }
 
-        // If use_hashed_state is enabled, execution writes directly to `HashedStorages`,
-        // so this stage becomes a no-op.
-        if provider.cached_storage_settings().use_hashed_state() {
-            return Ok(ExecOutput::done(input.checkpoint().with_block_number(input.target())));
-        }
-
         let (from_block, to_block) = input.next_block_range().into_inner();
 
         // if there are more blocks then threshold it is faster to go over Plain state and hash all
@@ -187,11 +176,6 @@ where
         provider: &Provider,
         input: UnwindInput,
     ) -> Result<UnwindOutput, StageError> {
-        // NOTE: this runs in both v1 and v2 mode. In v2 mode, execution writes
-        // directly to `HashedStorages`, but the unwind must still revert those
-        // entries here because `MerkleUnwind` runs after this stage (in unwind
-        // order) and needs `HashedStorages` to reflect the target block state
-        // before it can verify the state root.
         let (range, unwind_progress, _) =
             input.unwind_block_range_with_threshold(self.commit_threshold);
 

crates/stages/stages/src/stages/index_account_history.rs

@@ -103,7 +103,7 @@ where
 
         let mut range = input.next_block_range();
         let first_sync = input.checkpoint().block_number == 0;
-        let use_rocksdb = provider.cached_storage_settings().storage_v2;
+        let use_rocksdb = provider.cached_storage_settings().account_history_in_rocksdb;
 
         // On first sync we might have history coming from genesis. We clear the table since it's
         // faster to rebuild from scratch.
@@ -122,7 +122,7 @@ where
 
         info!(target: "sync::stages::index_account_history::exec", ?first_sync, ?use_rocksdb, "Collecting indices");
 
-        let collector = if provider.cached_storage_settings().storage_v2 {
+        let collector = if provider.cached_storage_settings().account_changesets_in_static_files {
             // Use the provider-based collection that can read from static files.
             collect_account_history_indices(provider, range.clone(), &self.etl_config)?
         } else {
@@ -666,43 +666,32 @@ mod tests {
     #[cfg(all(unix, feature = "rocksdb"))]
     mod rocksdb_tests {
         use super::*;
-        use reth_provider::{
-            providers::StaticFileWriter, RocksDBProviderFactory, StaticFileProviderFactory,
-        };
-        use reth_static_file_types::StaticFileSegment;
+        use reth_provider::RocksDBProviderFactory;
         use reth_storage_api::StorageSettings;
 
-        /// Sets up v2 account test data: writes block body indices to MDBX and
-        /// account changesets to static files (matching realistic v2 layout).
-        fn setup_v2_account_data(db: &TestStageDB, block_range: std::ops::RangeInclusive<u64>) {
-            db.factory.set_storage_settings_cache(StorageSettings::v2());
-
-            db.commit(|tx| {
-                for block in block_range.clone() {
-                    tx.put::<tables::BlockBodyIndices>(
-                        block,
-                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
-                    )?;
-                }
-                Ok(())
-            })
-            .unwrap();
-
-            let static_file_provider = db.factory.static_file_provider();
-            let mut writer =
-                static_file_provider.latest_writer(StaticFileSegment::AccountChangeSets).unwrap();
-            for block in block_range {
-                writer.append_account_changeset(vec![acc()], block).unwrap();
-            }
-            writer.commit().unwrap();
-        }
-
         /// Test that when `account_history_in_rocksdb` is enabled, the stage
         /// writes account history indices to `RocksDB` instead of MDBX.
         #[tokio::test]
         async fn execute_writes_to_rocksdb_when_enabled() {
+            // init
             let db = TestStageDB::default();
-            setup_v2_account_data(&db, 0..=10);
+
+            // Enable RocksDB for account history
+            db.factory.set_storage_settings_cache(
+                StorageSettings::v1().with_account_history_in_rocksdb(true),
+            );
+
+            db.commit(|tx| {
+                for block in 0..=10 {
+                    tx.put::<tables::BlockBodyIndices>(
+                        block,
+                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
+                    )?;
+                    tx.put::<tables::AccountChangeSets>(block, acc())?;
+                }
+                Ok(())
+            })
+            .unwrap();
 
             let input = ExecInput { target: Some(10), ..Default::default() };
             let mut stage = IndexAccountHistoryStage::default();
@@ -732,7 +721,22 @@ mod tests {
         #[tokio::test]
         async fn unwind_works_when_rocksdb_enabled() {
             let db = TestStageDB::default();
-            setup_v2_account_data(&db, 0..=10);
+
+            db.factory.set_storage_settings_cache(
+                StorageSettings::v1().with_account_history_in_rocksdb(true),
+            );
+
+            db.commit(|tx| {
+                for block in 0..=10 {
+                    tx.put::<tables::BlockBodyIndices>(
+                        block,
+                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
+                    )?;
+                    tx.put::<tables::AccountChangeSets>(block, acc())?;
+                }
+                Ok(())
+            })
+            .unwrap();
 
             let input = ExecInput { target: Some(10), ..Default::default() };
             let mut stage = IndexAccountHistoryStage::default();
@@ -768,7 +772,22 @@ mod tests {
         #[tokio::test]
         async fn execute_incremental_sync() {
             let db = TestStageDB::default();
-            setup_v2_account_data(&db, 0..=10);
+
+            db.factory.set_storage_settings_cache(
+                StorageSettings::v1().with_account_history_in_rocksdb(true),
+            );
+
+            db.commit(|tx| {
+                for block in 0..=5 {
+                    tx.put::<tables::BlockBodyIndices>(
+                        block,
+                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
+                    )?;
+                    tx.put::<tables::AccountChangeSets>(block, acc())?;
+                }
+                Ok(())
+            })
+            .unwrap();
 
             let input = ExecInput { target: Some(5), ..Default::default() };
             let mut stage = IndexAccountHistoryStage::default();
@@ -783,6 +802,18 @@ mod tests {
             let blocks: Vec<u64> = result.unwrap().iter().collect();
             assert_eq!(blocks, (0..=5).collect::<Vec<_>>());
 
+            db.commit(|tx| {
+                for block in 6..=10 {
+                    tx.put::<tables::BlockBodyIndices>(
+                        block,
+                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
+                    )?;
+                    tx.put::<tables::AccountChangeSets>(block, acc())?;
+                }
+                Ok(())
+            })
+            .unwrap();
+
             let input = ExecInput { target: Some(10), checkpoint: Some(StageCheckpoint::new(5)) };
             let provider = db.factory.database_provider_rw().unwrap();
             let out = stage.execute(&provider, input).unwrap();

crates/stages/stages/src/stages/index_storage_history.rs

@@ -107,7 +107,7 @@ where
 
         let mut range = input.next_block_range();
         let first_sync = input.checkpoint().block_number == 0;
-        let use_rocksdb = provider.cached_storage_settings().storage_v2;
+        let use_rocksdb = provider.cached_storage_settings().storages_history_in_rocksdb;
 
         // On first sync we might have history coming from genesis. We clear the table since it's
         // faster to rebuild from scratch.
@@ -125,7 +125,7 @@ where
         }
 
         info!(target: "sync::stages::index_storage_history::exec", ?first_sync, ?use_rocksdb, "Collecting indices");
-        let collector = if provider.cached_storage_settings().storage_v2 {
+        let collector = if provider.cached_storage_settings().storage_changesets_in_static_files {
             collect_storage_history_indices(provider, range.clone(), &self.etl_config)?
         } else {
             collect_history_indices::<_, tables::StorageChangeSets, tables::StoragesHistory, _>(
@@ -694,51 +694,33 @@ mod tests {
     #[cfg(all(unix, feature = "rocksdb"))]
     mod rocksdb_tests {
         use super::*;
-        use reth_db_api::models::StorageBeforeTx;
-        use reth_provider::{providers::StaticFileWriter, RocksDBProviderFactory};
-        use reth_static_file_types::StaticFileSegment;
+        use reth_provider::RocksDBProviderFactory;
         use reth_storage_api::StorageSettings;
 
-        /// Sets up v2 storage test data: writes block body indices to MDBX and
-        /// storage changesets to static files (matching realistic v2 layout).
-        fn setup_v2_storage_data(db: &TestStageDB, block_range: std::ops::RangeInclusive<u64>) {
-            db.factory.set_storage_settings_cache(StorageSettings::v2());
-
-            db.commit(|tx| {
-                for block in block_range.clone() {
-                    tx.put::<tables::BlockBodyIndices>(
-                        block,
-                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
-                    )?;
-                }
-                Ok(())
-            })
-            .unwrap();
-
-            let static_file_provider = db.factory.static_file_provider();
-            let mut writer =
-                static_file_provider.latest_writer(StaticFileSegment::StorageChangeSets).unwrap();
-            for block in block_range {
-                writer
-                    .append_storage_changeset(
-                        vec![StorageBeforeTx {
-                            address: ADDRESS,
-                            key: STORAGE_KEY,
-                            value: U256::ZERO,
-                        }],
-                        block,
-                    )
-                    .unwrap();
-            }
-            writer.commit().unwrap();
-        }
-
         /// Test that when `storages_history_in_rocksdb` is enabled, the stage
         /// writes storage history indices to `RocksDB` instead of MDBX.
         #[tokio::test]
         async fn execute_writes_to_rocksdb_when_enabled() {
             let db = TestStageDB::default();
-            setup_v2_storage_data(&db, 0..=10);
+
+            db.factory.set_storage_settings_cache(
+                StorageSettings::v1().with_storages_history_in_rocksdb(true),
+            );
+
+            db.commit(|tx| {
+                for block in 0..=10 {
+                    tx.put::<tables::BlockBodyIndices>(
+                        block,
+                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
+                    )?;
+                    tx.put::<tables::StorageChangeSets>(
+                        block_number_address(block),
+                        storage(STORAGE_KEY),
+                    )?;
+                }
+                Ok(())
+            })
+            .unwrap();
 
             let input = ExecInput { target: Some(10), ..Default::default() };
             let mut stage = IndexStorageHistoryStage::default();
@@ -766,7 +748,25 @@ mod tests {
         #[tokio::test]
         async fn unwind_works_when_rocksdb_enabled() {
             let db = TestStageDB::default();
-            setup_v2_storage_data(&db, 0..=10);
+
+            db.factory.set_storage_settings_cache(
+                StorageSettings::v1().with_storages_history_in_rocksdb(true),
+            );
+
+            db.commit(|tx| {
+                for block in 0..=10 {
+                    tx.put::<tables::BlockBodyIndices>(
+                        block,
+                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
+                    )?;
+                    tx.put::<tables::StorageChangeSets>(
+                        block_number_address(block),
+                        storage(STORAGE_KEY),
+                    )?;
+                }
+                Ok(())
+            })
+            .unwrap();
 
             let input = ExecInput { target: Some(10), ..Default::default() };
             let mut stage = IndexStorageHistoryStage::default();
@@ -803,7 +803,25 @@ mod tests {
         #[tokio::test]
         async fn unwind_to_zero_keeps_block_zero() {
             let db = TestStageDB::default();
-            setup_v2_storage_data(&db, 0..=5);
+
+            db.factory.set_storage_settings_cache(
+                StorageSettings::v1().with_storages_history_in_rocksdb(true),
+            );
+
+            db.commit(|tx| {
+                for block in 0..=5 {
+                    tx.put::<tables::BlockBodyIndices>(
+                        block,
+                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
+                    )?;
+                    tx.put::<tables::StorageChangeSets>(
+                        block_number_address(block),
+                        storage(STORAGE_KEY),
+                    )?;
+                }
+                Ok(())
+            })
+            .unwrap();
 
             let input = ExecInput { target: Some(5), ..Default::default() };
             let mut stage = IndexStorageHistoryStage::default();
@@ -834,7 +852,25 @@ mod tests {
         #[tokio::test]
         async fn execute_incremental_sync() {
             let db = TestStageDB::default();
-            setup_v2_storage_data(&db, 0..=10);
+
+            db.factory.set_storage_settings_cache(
+                StorageSettings::v1().with_storages_history_in_rocksdb(true),
+            );
+
+            db.commit(|tx| {
+                for block in 0..=5 {
+                    tx.put::<tables::BlockBodyIndices>(
+                        block,
+                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
+                    )?;
+                    tx.put::<tables::StorageChangeSets>(
+                        block_number_address(block),
+                        storage(STORAGE_KEY),
+                    )?;
+                }
+                Ok(())
+            })
+            .unwrap();
 
             let input = ExecInput { target: Some(5), ..Default::default() };
             let mut stage = IndexStorageHistoryStage::default();
@@ -849,6 +885,21 @@ mod tests {
             let blocks: Vec<u64> = result.unwrap().iter().collect();
             assert_eq!(blocks, (0..=5).collect::<Vec<_>>());
 
+            db.commit(|tx| {
+                for block in 6..=10 {
+                    tx.put::<tables::BlockBodyIndices>(
+                        block,
+                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
+                    )?;
+                    tx.put::<tables::StorageChangeSets>(
+                        block_number_address(block),
+                        storage(STORAGE_KEY),
+                    )?;
+                }
+                Ok(())
+            })
+            .unwrap();
+
             let input = ExecInput { target: Some(10), checkpoint: Some(StageCheckpoint::new(5)) };
             let provider = db.factory.database_provider_rw().unwrap();
             let out = stage.execute(&provider, input).unwrap();
@@ -868,8 +919,27 @@ mod tests {
             use reth_db_api::models::sharded_key::NUM_OF_INDICES_IN_SHARD;
 
             let db = TestStageDB::default();
+
+            db.factory.set_storage_settings_cache(
+                StorageSettings::v1().with_storages_history_in_rocksdb(true),
+            );
+
             let num_blocks = (NUM_OF_INDICES_IN_SHARD * 2 + 100) as u64;
-            setup_v2_storage_data(&db, 0..=num_blocks - 1);
+
+            db.commit(|tx| {
+                for block in 0..num_blocks {
+                    tx.put::<tables::BlockBodyIndices>(
+                        block,
+                        StoredBlockBodyIndices { tx_count: 3, ..Default::default() },
+                    )?;
+                    tx.put::<tables::StorageChangeSets>(
+                        block_number_address(block),
+                        storage(STORAGE_KEY),
+                    )?;
+                }
+                Ok(())
+            })
+            .unwrap();
 
             let input = ExecInput { target: Some(num_blocks - 1), ..Default::default() };
             let mut stage = IndexStorageHistoryStage::default();

crates/stages/stages/src/stages/merkle.rs

@@ -9,7 +9,7 @@ use reth_db_api::{
 use reth_primitives_traits::{GotExpected, SealedHeader};
 use reth_provider::{
     ChangeSetReader, DBProvider, HeaderProvider, ProviderError, StageCheckpointReader,
-    StageCheckpointWriter, StatsReader, StorageChangeSetReader, StorageSettingsCache, TrieWriter,
+    StageCheckpointWriter, StatsReader, StorageChangeSetReader, TrieWriter,
 };
 use reth_stages_api::{
     BlockErrorKind, EntitiesCheckpoint, ExecInput, ExecOutput, MerkleCheckpoint, Stage,
@@ -160,7 +160,6 @@ where
         + HeaderProvider
         + ChangeSetReader
         + StorageChangeSetReader
-        + StorageSettingsCache
         + StageCheckpointReader
         + StageCheckpointWriter,
 {

crates/stages/stages/src/stages/sender_recovery.rs

@@ -540,7 +540,9 @@ mod tests {
         let mut rng = generators::rng();
 
         let runner = SenderRecoveryTestRunner::default();
-        runner.db.factory.set_storage_settings_cache(StorageSettings::v2());
+        runner.db.factory.set_storage_settings_cache(
+            StorageSettings::v1().with_transaction_senders_in_static_files(true),
+        );
         let input = ExecInput {
             target: Some(target),
             checkpoint: Some(StageCheckpoint::new(stage_progress)),

crates/stages/stages/src/stages/tx_lookup.rs

@@ -200,7 +200,7 @@ where
         }
 
         #[cfg(all(unix, feature = "rocksdb"))]
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().transaction_hash_numbers_in_rocksdb {
             provider.commit_pending_rocksdb_batches()?;
             provider.rocksdb_provider().flush(&[Tables::TransactionHashNumbers.name()])?;
         }
@@ -618,7 +618,9 @@ mod tests {
             let runner = TransactionLookupTestRunner::default();
 
             // Enable RocksDB for transaction hash numbers
-            runner.db.factory.set_storage_settings_cache(StorageSettings::v2());
+            runner.db.factory.set_storage_settings_cache(
+                StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+            );
 
             let input = ExecInput {
                 target: Some(previous_stage),
@@ -684,7 +686,9 @@ mod tests {
             let runner = TransactionLookupTestRunner::default();
 
             // Enable RocksDB for transaction hash numbers
-            runner.db.factory.set_storage_settings_cache(StorageSettings::v2());
+            runner.db.factory.set_storage_settings_cache(
+                StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+            );
 
             // Insert blocks with transactions
             let blocks = random_block_range(

crates/stages/stages/src/stages/utils.rs

@@ -208,10 +208,7 @@ where
 
     for (idx, changeset_result) in walker.enumerate() {
         let (BlockNumberAddress((block_number, address)), storage) = changeset_result?;
-        cache
-            .entry(AddressStorageKey((address, storage.key.as_b256())))
-            .or_default()
-            .push(block_number);
+        cache.entry(AddressStorageKey((address, storage.key))).or_default().push(block_number);
 
         if idx > 0 && idx % interval == 0 && total_changesets > 1000 {
             info!(target: "sync::stages::index_history", progress = %format!("{:.4}%", (idx as f64 / total_changesets as f64) * 100.0), "Collecting indices");

crates/stages/stages/tests/pipeline.rs

@@ -3,7 +3,7 @@
 use alloy_consensus::{constants::ETH_TO_WEI, Header, TxEip1559, TxReceipt};
 use alloy_eips::eip1559::INITIAL_BASE_FEE;
 use alloy_genesis::{Genesis, GenesisAccount};
-use alloy_primitives::{bytes, keccak256, Address, Bytes, TxKind, B256, U256};
+use alloy_primitives::{bytes, Address, Bytes, TxKind, B256, U256};
 use reth_chainspec::{ChainSpecBuilder, ChainSpecProvider, MAINNET};
 use reth_config::config::StageConfig;
 use reth_consensus::noop::NoopConsensus;
@@ -36,7 +36,7 @@ use reth_stages::sets::DefaultStages;
 use reth_stages_api::{Pipeline, StageId};
 use reth_static_file::StaticFileProducer;
 use reth_storage_api::{
-    ChangeSetReader, StateProvider, StorageChangeSetReader, StorageSettings, StorageSettingsCache,
+    ChangeSetReader, StateProvider, StorageChangeSetReader, StorageSettingsCache,
 };
 use reth_testing_utils::generators::{self, generate_key, sign_tx_with_key_pair};
 use reth_trie::{HashedPostState, KeccakKeyHasher, StateRoot};
@@ -79,7 +79,7 @@ fn assert_changesets_queryable(
     let settings = provider.cached_storage_settings();
 
     // Verify storage changesets
-    if settings.storage_v2 {
+    if settings.storage_changesets_in_static_files {
         let static_file_provider = provider_factory.static_file_provider();
         static_file_provider.initialize_index()?;
         let storage_changesets =
@@ -89,11 +89,6 @@ fn assert_changesets_queryable(
             "storage changesets should be queryable from static files for blocks {:?}",
             block_range
         );
-
-        // Verify keys are in hashed format (v2 mode)
-        for (_, entry) in &storage_changesets {
-            assert!(entry.key.is_hashed(), "v2: storage changeset keys should be tagged as hashed");
-        }
     } else {
         let storage_changesets: Vec<_> = provider
             .tx_ref()
@@ -105,20 +100,10 @@ fn assert_changesets_queryable(
             "storage changesets should be queryable from MDBX for blocks {:?}",
             block_range
         );
-
-        // Verify keys are plain (not hashed) in v1 mode
-        for (_, entry) in &storage_changesets {
-            let key = entry.key;
-            assert_ne!(
-                key,
-                keccak256(key),
-                "v1: storage changeset key should be plain (not its own keccak256)"
-            );
-        }
     }
 
     // Verify account changesets
-    if settings.storage_v2 {
+    if settings.account_changesets_in_static_files {
         let static_file_provider = provider_factory.static_file_provider();
         static_file_provider.initialize_index()?;
         let account_changesets =
@@ -216,22 +201,19 @@ where
     pipeline
 }
 
-/// Shared helper for pipeline forward sync and unwind tests.
+/// Tests pipeline with ALL stages enabled using both ETH transfers and contract storage changes.
 ///
+/// This test:
 /// 1. Pre-funds a signer account and deploys a Counter contract in genesis
 /// 2. Each block contains two transactions:
 ///    - ETH transfer to a recipient (account state changes)
 ///    - Counter `increment()` call (storage state changes)
 /// 3. Runs the full pipeline with ALL stages enabled
-/// 4. Forward syncs to `num_blocks`, unwinds to `unwind_target`, then re-syncs back to `num_blocks`
+/// 4. Forward syncs to block 5, unwinds to block 2
 ///
-/// When `storage_settings` is `Some`, the pipeline provider factory is configured with the given
-/// settings before genesis initialization (e.g. v2 storage mode).
-async fn run_pipeline_forward_and_unwind(
-    storage_settings: Option<StorageSettings>,
-    num_blocks: u64,
-    unwind_target: u64,
-) -> eyre::Result<()> {
+/// This exercises both account and storage hashing/history stages.
+#[tokio::test(flavor = "multi_thread")]
+async fn test_pipeline() -> eyre::Result<()> {
     reth_tracing::init_test_tracing();
 
     // Generate a keypair for signing transactions
@@ -277,6 +259,7 @@ async fn run_pipeline_forward_and_unwind(
     let evm_config = EthEvmConfig::new(chain_spec.clone());
 
     // Build blocks by actually executing transactions to get correct state roots
+    let num_blocks = 5u64;
     let mut blocks: Vec<SealedBlock<Block>> = Vec::new();
     let mut parent_hash = genesis.hash();
 
@@ -401,15 +384,11 @@ async fn run_pipeline_forward_and_unwind(
     // This is needed because we wrote state during block generation for computing state roots
     let pipeline_provider_factory =
         create_test_provider_factory_with_chain_spec(chain_spec.clone());
-    if let Some(settings) = storage_settings {
-        pipeline_provider_factory.set_storage_settings_cache(settings);
-    }
     init_genesis(&pipeline_provider_factory).expect("init genesis");
     let pipeline_genesis =
         pipeline_provider_factory.sealed_header(0)?.expect("genesis should exist");
     let pipeline_consensus = NoopConsensus::arc();
 
-    let blocks_clone = blocks.clone();
     let file_client = create_file_client_from_blocks(blocks);
     let max_block = file_client.max_block().unwrap();
     let tip = file_client.tip().expect("tip");
@@ -438,7 +417,7 @@ async fn run_pipeline_forward_and_unwind(
     {
         let provider = pipeline_provider_factory.provider()?;
         let last_block = provider.last_block_number()?;
-        assert_eq!(last_block, num_blocks, "should have synced {num_blocks} blocks");
+        assert_eq!(last_block, 5, "should have synced 5 blocks");
 
         for stage_id in [
             StageId::Headers,
@@ -456,28 +435,29 @@ async fn run_pipeline_forward_and_unwind(
             let checkpoint = provider.get_stage_checkpoint(stage_id)?;
             assert_eq!(
                 checkpoint.map(|c| c.block_number),
-                Some(num_blocks),
-                "{stage_id} checkpoint should be at block {num_blocks}"
+                Some(5),
+                "{stage_id} checkpoint should be at block 5"
             );
         }
 
         // Verify the counter contract's storage was updated
-        // After num_blocks blocks with 1 increment each, slot 0 should be num_blocks
+        // After 5 blocks with 1 increment each, slot 0 should be 5
         let state = provider.latest();
         let counter_storage = state.storage(CONTRACT_ADDRESS, B256::ZERO)?;
         assert_eq!(
             counter_storage,
-            Some(U256::from(num_blocks)),
-            "Counter storage slot 0 should be {num_blocks} after {num_blocks} increments"
+            Some(U256::from(5)),
+            "Counter storage slot 0 should be 5 after 5 increments"
         );
     }
 
     // Verify changesets are queryable before unwind
     // This validates that the #21561 fix works - unwind needs to read changesets from the correct
     // source
-    assert_changesets_queryable(&pipeline_provider_factory, 1..=num_blocks)?;
+    assert_changesets_queryable(&pipeline_provider_factory, 1..=5)?;
 
-    // Unwind to unwind_target
+    // Unwind to block 2
+    let unwind_target = 2u64;
     pipeline.unwind(unwind_target, None)?;
 
     // Verify unwind
@@ -504,114 +484,7 @@ async fn run_pipeline_forward_and_unwind(
                 );
             }
         }
-
-        let state = provider.latest();
-        let counter_storage = state.storage(CONTRACT_ADDRESS, B256::ZERO)?;
-        assert_eq!(
-            counter_storage,
-            Some(U256::from(unwind_target)),
-            "Counter storage slot 0 should be {unwind_target} after unwinding to block {unwind_target}"
-        );
-    }
-
-    // Re-sync: build a new pipeline starting from unwind_target and sync back to num_blocks
-    let resync_file_client = create_file_client_from_blocks(blocks_clone);
-    let resync_consensus = NoopConsensus::arc();
-    let resync_stages_config = StageConfig::default();
-
-    let unwind_head = pipeline_provider_factory
-        .sealed_header(unwind_target)?
-        .expect("unwind target header should exist");
-
-    let mut resync_header_downloader =
-        ReverseHeadersDownloaderBuilder::new(resync_stages_config.headers)
-            .build(resync_file_client.clone(), resync_consensus.clone())
-            .into_task();
-    resync_header_downloader.update_local_head(unwind_head);
-    resync_header_downloader.update_sync_target(SyncTarget::Tip(tip));
-
-    let mut resync_body_downloader = BodiesDownloaderBuilder::new(resync_stages_config.bodies)
-        .build(resync_file_client, resync_consensus, pipeline_provider_factory.clone())
-        .into_task();
-    resync_body_downloader
-        .set_download_range(unwind_target + 1..=max_block)
-        .expect("set download range");
-
-    let resync_pipeline = build_pipeline(
-        pipeline_provider_factory.clone(),
-        resync_header_downloader,
-        resync_body_downloader,
-        max_block,
-        tip,
-    );
-
-    let (_resync_pipeline, resync_result) = resync_pipeline.run_as_fut(None).await;
-    resync_result?;
-
-    // Verify re-sync
-    {
-        let provider = pipeline_provider_factory.provider()?;
-        let last_block = provider.last_block_number()?;
-        assert_eq!(last_block, num_blocks, "should have re-synced to {num_blocks} blocks");
-
-        for stage_id in [
-            StageId::Headers,
-            StageId::Bodies,
-            StageId::SenderRecovery,
-            StageId::Execution,
-            StageId::AccountHashing,
-            StageId::StorageHashing,
-            StageId::MerkleExecute,
-            StageId::TransactionLookup,
-            StageId::IndexAccountHistory,
-            StageId::IndexStorageHistory,
-            StageId::Finish,
-        ] {
-            let checkpoint = provider.get_stage_checkpoint(stage_id)?;
-            assert_eq!(
-                checkpoint.map(|c| c.block_number),
-                Some(num_blocks),
-                "{stage_id} checkpoint should be at block {num_blocks} after re-sync"
-            );
-        }
-
-        let state = provider.latest();
-        let counter_storage = state.storage(CONTRACT_ADDRESS, B256::ZERO)?;
-        assert_eq!(
-            counter_storage,
-            Some(U256::from(num_blocks)),
-            "Counter storage slot 0 should be {num_blocks} after re-sync"
-        );
     }
 
     Ok(())
 }
-
-/// Tests pipeline with ALL stages enabled using both ETH transfers and contract storage changes.
-///
-/// This test:
-/// 1. Pre-funds a signer account and deploys a Counter contract in genesis
-/// 2. Each block contains two transactions:
-///    - ETH transfer to a recipient (account state changes)
-///    - Counter `increment()` call (storage state changes)
-/// 3. Runs the full pipeline with ALL stages enabled
-/// 4. Forward syncs to block 5, unwinds to block 2, then re-syncs to block 5
-///
-/// This exercises both account and storage hashing/history stages.
-#[tokio::test(flavor = "multi_thread")]
-async fn test_pipeline() -> eyre::Result<()> {
-    run_pipeline_forward_and_unwind(None, 5, 2).await
-}
-
-/// Same as [`test_pipeline`] but runs with v2 storage settings (`use_hashed_state=true`,
-/// `is_v2()=true`, etc.).
-///
-/// In v2 mode:
-/// - The execution stage writes directly to `HashedAccounts`/`HashedStorages`
-/// - `AccountHashingStage` and `StorageHashingStage` are no-ops during forward execution
-/// - Changesets are stored in static files with pre-hashed storage keys
-/// - Unwind must still revert hashed state via the hashing stages before `MerkleUnwind` validates
-#[tokio::test(flavor = "multi_thread")]
-async fn test_pipeline_v2() -> eyre::Result<()> {
-    run_pipeline_forward_and_unwind(Some(StorageSettings::v2()), 5, 2).await
-}

crates/storage/db-api/src/models/metadata.rs

@@ -5,101 +5,208 @@ use serde::{Deserialize, Serialize};
 
 /// Storage configuration settings for this node.
 ///
-/// Controls whether this node uses v2 storage layout (static files + `RocksDB` routing)
-/// or v1/legacy layout (everything in MDBX).
-///
 /// These should be set during `init_genesis` or `init_db` depending on whether we want dictate
 /// behaviour of new or old nodes respectively.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Compact, Serialize, Deserialize)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Default, Serialize, Deserialize, Compact)]
 #[cfg_attr(any(test, feature = "arbitrary"), derive(arbitrary::Arbitrary))]
 #[add_arbitrary_tests(compact)]
 pub struct StorageSettings {
-    /// Whether this node uses v2 storage layout.
+    /// Whether this node always writes receipts to static files.
     ///
-    /// When `true`, enables all v2 storage features:
-    /// - Receipts and transaction senders in static files
-    /// - History indices in `RocksDB` (accounts, storages, transaction hashes)
-    /// - Account and storage changesets in static files
-    /// - Hashed state tables as canonical state representation
-    ///
-    /// When `false`, uses v1/legacy layout (everything in MDBX).
-    pub storage_v2: bool,
+    /// If this is set to FALSE AND receipt pruning IS ENABLED, all receipts should be written to DB. Otherwise, they should be written to static files. This ensures that older nodes do not need to migrate their current DB tables to static files. For more, read: <https://github.com/paradigmxyz/reth/issues/18890#issuecomment-3457760097>
+    #[serde(default)]
+    pub receipts_in_static_files: bool,
+    /// Whether this node always writes transaction senders to static files.
+    #[serde(default)]
+    pub transaction_senders_in_static_files: bool,
+    /// Whether `StoragesHistory` is stored in `RocksDB`.
+    #[serde(default)]
+    pub storages_history_in_rocksdb: bool,
+    /// Whether `TransactionHashNumbers` is stored in `RocksDB`.
+    #[serde(default)]
+    pub transaction_hash_numbers_in_rocksdb: bool,
+    /// Whether `AccountsHistory` is stored in `RocksDB`.
+    #[serde(default)]
+    pub account_history_in_rocksdb: bool,
+    /// Whether this node should read and write account changesets from static files.
+    #[serde(default)]
+    pub account_changesets_in_static_files: bool,
+    /// Whether this node should read and write storage changesets from static files.
+    #[serde(default)]
+    pub storage_changesets_in_static_files: bool,
+    /// Whether to use hashed state tables (`HashedAccounts`/`HashedStorages`) as the canonical
+    /// state representation instead of plain state tables.
+    #[serde(default)]
+    pub use_hashed_state: bool,
 }
 
 impl StorageSettings {
     /// Returns the default base `StorageSettings`.
     ///
-    /// When the `edge` feature is enabled, returns [`Self::v2()`] so that CI and
-    /// edge builds automatically use v2 storage defaults. Otherwise returns
-    /// [`Self::v1()`]. The `--storage.v2` CLI flag can also opt into v2 at runtime
-    /// regardless of feature flags.
+    /// Always returns [`Self::v1()`]. Use the `--storage.v2` CLI flag to opt into
+    /// [`Self::v2()`] at runtime. The `rocksdb` feature only makes the v2 backend
+    /// *available*; it does not activate it by default.
     pub const fn base() -> Self {
-        #[cfg(feature = "edge")]
-        {
-            Self::v2()
-        }
-        #[cfg(not(feature = "edge"))]
-        {
-            Self::v1()
-        }
+        Self::v1()
     }
 
     /// Creates `StorageSettings` for v2 nodes with all storage features enabled:
     /// - Receipts and transaction senders in static files
     /// - History indices in `RocksDB` (storages, accounts, transaction hashes)
     /// - Account and storage changesets in static files
-    /// - Hashed state as canonical state representation
     ///
     /// Use this when the `--storage.v2` CLI flag is set.
     pub const fn v2() -> Self {
-        Self { storage_v2: true }
+        Self {
+            receipts_in_static_files: true,
+            transaction_senders_in_static_files: true,
+            account_changesets_in_static_files: true,
+            storage_changesets_in_static_files: true,
+            storages_history_in_rocksdb: true,
+            transaction_hash_numbers_in_rocksdb: true,
+            account_history_in_rocksdb: true,
+            use_hashed_state: false,
+        }
     }
 
     /// Creates `StorageSettings` for v1/legacy nodes.
     ///
-    /// This keeps all data in MDBX, matching the original storage layout.
+    /// This explicitly sets `receipts_in_static_files` and `transaction_senders_in_static_files` to
+    /// `false`, ensuring older nodes continue writing receipts and transaction senders to the
+    /// database when receipt pruning is enabled.
     pub const fn v1() -> Self {
-        Self { storage_v2: false }
+        Self {
+            receipts_in_static_files: false,
+            transaction_senders_in_static_files: false,
+            storages_history_in_rocksdb: false,
+            transaction_hash_numbers_in_rocksdb: false,
+            account_history_in_rocksdb: false,
+            account_changesets_in_static_files: false,
+            storage_changesets_in_static_files: false,
+            use_hashed_state: false,
+        }
     }
 
-    /// Returns `true` if this node uses v2 storage layout.
-    pub const fn is_v2(&self) -> bool {
-        self.storage_v2
+    /// Sets the `receipts_in_static_files` flag to the provided value.
+    pub const fn with_receipts_in_static_files(mut self, value: bool) -> Self {
+        self.receipts_in_static_files = value;
+        self
     }
 
-    /// Whether receipts are stored in static files.
-    pub const fn receipts_in_static_files(&self) -> bool {
-        self.storage_v2
+    /// Sets the `transaction_senders_in_static_files` flag to the provided value.
+    pub const fn with_transaction_senders_in_static_files(mut self, value: bool) -> Self {
+        self.transaction_senders_in_static_files = value;
+        self
     }
 
-    /// Whether transaction senders are stored in static files.
-    pub const fn transaction_senders_in_static_files(&self) -> bool {
-        self.storage_v2
+    /// Sets the `storages_history_in_rocksdb` flag to the provided value.
+    pub const fn with_storages_history_in_rocksdb(mut self, value: bool) -> Self {
+        self.storages_history_in_rocksdb = value;
+        self
     }
 
-    /// Whether storages history is stored in `RocksDB`.
-    pub const fn storages_history_in_rocksdb(&self) -> bool {
-        self.storage_v2
+    /// Sets the `transaction_hash_numbers_in_rocksdb` flag to the provided value.
+    pub const fn with_transaction_hash_numbers_in_rocksdb(mut self, value: bool) -> Self {
+        self.transaction_hash_numbers_in_rocksdb = value;
+        self
     }
 
-    /// Whether transaction hash numbers are stored in `RocksDB`.
-    pub const fn transaction_hash_numbers_in_rocksdb(&self) -> bool {
-        self.storage_v2
+    /// Sets the `account_history_in_rocksdb` flag to the provided value.
+    pub const fn with_account_history_in_rocksdb(mut self, value: bool) -> Self {
+        self.account_history_in_rocksdb = value;
+        self
     }
 
-    /// Whether account history is stored in `RocksDB`.
-    pub const fn account_history_in_rocksdb(&self) -> bool {
-        self.storage_v2
+    /// Sets the `account_changesets_in_static_files` flag to the provided value.
+    pub const fn with_account_changesets_in_static_files(mut self, value: bool) -> Self {
+        self.account_changesets_in_static_files = value;
+        self
     }
 
-    /// Whether to use hashed state tables (`HashedAccounts`/`HashedStorages`) as the canonical
-    /// state representation instead of plain state tables. Implied by v2 storage layout.
-    pub const fn use_hashed_state(&self) -> bool {
-        self.storage_v2
+    /// Sets the `storage_changesets_in_static_files` flag to the provided value.
+    pub const fn with_storage_changesets_in_static_files(mut self, value: bool) -> Self {
+        self.storage_changesets_in_static_files = value;
+        self
+    }
+
+    /// Sets the `use_hashed_state` flag to the provided value.
+    pub const fn with_use_hashed_state(mut self, value: bool) -> Self {
+        self.use_hashed_state = value;
+        self
+    }
+
+    /// Sets `receipts_in_static_files` if `value` is `Some`.
+    pub const fn with_receipts_in_static_files_opt(mut self, value: Option<bool>) -> Self {
+        if let Some(v) = value {
+            self.receipts_in_static_files = v;
+        }
+        self
+    }
+
+    /// Sets `transaction_senders_in_static_files` if `value` is `Some`.
+    pub const fn with_transaction_senders_in_static_files_opt(
+        mut self,
+        value: Option<bool>,
+    ) -> Self {
+        if let Some(v) = value {
+            self.transaction_senders_in_static_files = v;
+        }
+        self
+    }
+
+    /// Sets `account_changesets_in_static_files` if `value` is `Some`.
+    pub const fn with_account_changesets_in_static_files_opt(
+        mut self,
+        value: Option<bool>,
+    ) -> Self {
+        if let Some(v) = value {
+            self.account_changesets_in_static_files = v;
+        }
+        self
+    }
+
+    /// Sets `storage_changesets_in_static_files` if `value` is `Some`.
+    pub const fn with_storage_changesets_in_static_files_opt(
+        mut self,
+        value: Option<bool>,
+    ) -> Self {
+        if let Some(v) = value {
+            self.storage_changesets_in_static_files = v;
+        }
+        self
+    }
+
+    /// Sets `transaction_hash_numbers_in_rocksdb` if `value` is `Some`.
+    pub const fn with_transaction_hash_numbers_in_rocksdb_opt(
+        mut self,
+        value: Option<bool>,
+    ) -> Self {
+        if let Some(v) = value {
+            self.transaction_hash_numbers_in_rocksdb = v;
+        }
+        self
+    }
+
+    /// Sets `storages_history_in_rocksdb` if `value` is `Some`.
+    pub const fn with_storages_history_in_rocksdb_opt(mut self, value: Option<bool>) -> Self {
+        if let Some(v) = value {
+            self.storages_history_in_rocksdb = v;
+        }
+        self
+    }
+
+    /// Sets `account_history_in_rocksdb` if `value` is `Some`.
+    pub const fn with_account_history_in_rocksdb_opt(mut self, value: Option<bool>) -> Self {
+        if let Some(v) = value {
+            self.account_history_in_rocksdb = v;
+        }
+        self
     }
 
     /// Returns `true` if any tables are configured to be stored in `RocksDB`.
     pub const fn any_in_rocksdb(&self) -> bool {
-        self.storage_v2
+        self.transaction_hash_numbers_in_rocksdb ||
+            self.account_history_in_rocksdb ||
+            self.storages_history_in_rocksdb
     }
 }

crates/storage/db-common/src/init.rs

@@ -214,13 +214,13 @@ where
     // not the genesis block number. This would cause increment_block(N) to fail.
     let static_file_provider = provider_rw.static_file_provider();
     if genesis_block_number > 0 {
-        if genesis_storage_settings.storage_v2 {
+        if genesis_storage_settings.account_changesets_in_static_files {
             static_file_provider
                 .get_writer(genesis_block_number, StaticFileSegment::AccountChangeSets)?
                 .user_header_mut()
                 .set_expected_block_start(genesis_block_number);
         }
-        if genesis_storage_settings.storage_v2 {
+        if genesis_storage_settings.storage_changesets_in_static_files {
             static_file_provider
                 .get_writer(genesis_block_number, StaticFileSegment::StorageChangeSets)?
                 .user_header_mut()
@@ -259,7 +259,7 @@ where
         .user_header_mut()
         .set_block_range(genesis_block_number, genesis_block_number);
 
-    if genesis_storage_settings.storage_v2 {
+    if genesis_storage_settings.transaction_senders_in_static_files {
         static_file_provider
             .get_writer(genesis_block_number, StaticFileSegment::TransactionSenders)?
             .user_header_mut()
@@ -1052,7 +1052,7 @@ mod tests {
                 )
             };
 
-            let (accounts, storages) = if settings.storage_v2 {
+            let (accounts, storages) = if settings.account_history_in_rocksdb {
                 collect_rocksdb(&rocksdb)
             } else {
                 collect_from_mdbx(&factory)
@@ -1075,7 +1075,10 @@ mod tests {
         init_genesis_with_settings(&factory, StorageSettings::v1()).unwrap();
 
         // Request different settings - should warn but succeed
-        let result = init_genesis_with_settings(&factory, StorageSettings::v2());
+        let result = init_genesis_with_settings(
+            &factory,
+            StorageSettings::v1().with_receipts_in_static_files(true),
+        );
 
         // Should succeed (warning is logged, not an error)
         assert!(result.is_ok());
@@ -1084,7 +1087,7 @@ mod tests {
     #[test]
     fn allow_same_storage_settings() {
         let factory = create_test_provider_factory_with_chain_spec(MAINNET.clone());
-        let settings = StorageSettings::v2();
+        let settings = StorageSettings::v1().with_receipts_in_static_files(true);
         init_genesis_with_settings(&factory, settings).unwrap();
 
         let result = init_genesis_with_settings(&factory, settings);

crates/storage/provider/src/changeset_walker.rs

@@ -5,7 +5,8 @@ use crate::ProviderResult;
 use alloy_primitives::BlockNumber;
 use reth_db::models::AccountBeforeTx;
 use reth_db_api::models::BlockNumberAddress;
-use reth_storage_api::{ChangeSetReader, ChangesetEntry, StorageChangeSetReader};
+use reth_primitives_traits::StorageEntry;
+use reth_storage_api::{ChangeSetReader, StorageChangeSetReader};
 use std::ops::{Bound, RangeBounds};
 
 /// Iterator that walks account changesets from static files in a block range.
@@ -109,7 +110,7 @@ pub struct StaticFileStorageChangesetWalker<P> {
     /// Current block being processed
     current_block: BlockNumber,
     /// Changesets for current block
-    current_changesets: Vec<(BlockNumberAddress, ChangesetEntry)>,
+    current_changesets: Vec<(BlockNumberAddress, StorageEntry)>,
     /// Index within current block's changesets
     changeset_index: usize,
 }
@@ -143,7 +144,7 @@ impl<P> Iterator for StaticFileStorageChangesetWalker<P>
 where
     P: StorageChangeSetReader,
 {
-    type Item = ProviderResult<(BlockNumberAddress, ChangesetEntry)>;
+    type Item = ProviderResult<(BlockNumberAddress, StorageEntry)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         if let Some(changeset) = self.current_changesets.get(self.changeset_index).copied() {

crates/storage/provider/src/either_writer.rs

@@ -162,7 +162,7 @@ impl<'a> EitherWriter<'a, (), ()> {
         P: DBProvider + NodePrimitivesProvider + StorageSettingsCache + StaticFileProviderFactory,
         P::Tx: DbTxMut,
     {
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().account_changesets_in_static_files {
             Ok(EitherWriter::StaticFile(
                 provider
                     .get_static_file_writer(block_number, StaticFileSegment::AccountChangeSets)?,
@@ -183,7 +183,7 @@ impl<'a> EitherWriter<'a, (), ()> {
         P: DBProvider + NodePrimitivesProvider + StorageSettingsCache + StaticFileProviderFactory,
         P::Tx: DbTxMut,
     {
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().storage_changesets_in_static_files {
             Ok(EitherWriter::StaticFile(
                 provider
                     .get_static_file_writer(block_number, StaticFileSegment::StorageChangeSets)?,
@@ -206,7 +206,7 @@ impl<'a> EitherWriter<'a, (), ()> {
     pub fn receipts_destination<P: DBProvider + StorageSettingsCache>(
         provider: &P,
     ) -> EitherWriterDestination {
-        let receipts_in_static_files = provider.cached_storage_settings().storage_v2;
+        let receipts_in_static_files = provider.cached_storage_settings().receipts_in_static_files;
         let prune_modes = provider.prune_modes_ref();
 
         if !receipts_in_static_files && prune_modes.has_receipts_pruning() ||
@@ -225,7 +225,7 @@ impl<'a> EitherWriter<'a, (), ()> {
     pub fn account_changesets_destination<P: DBProvider + StorageSettingsCache>(
         provider: &P,
     ) -> EitherWriterDestination {
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().account_changesets_in_static_files {
             EitherWriterDestination::StaticFile
         } else {
             EitherWriterDestination::Database
@@ -238,7 +238,7 @@ impl<'a> EitherWriter<'a, (), ()> {
     pub fn storage_changesets_destination<P: DBProvider + StorageSettingsCache>(
         provider: &P,
     ) -> EitherWriterDestination {
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().storage_changesets_in_static_files {
             EitherWriterDestination::StaticFile
         } else {
             EitherWriterDestination::Database
@@ -255,7 +255,7 @@ impl<'a> EitherWriter<'a, (), ()> {
         P::Tx: DbTxMut,
     {
         #[cfg(all(unix, feature = "rocksdb"))]
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().storages_history_in_rocksdb {
             return Ok(EitherWriter::RocksDB(_rocksdb_batch));
         }
 
@@ -272,7 +272,7 @@ impl<'a> EitherWriter<'a, (), ()> {
         P::Tx: DbTxMut,
     {
         #[cfg(all(unix, feature = "rocksdb"))]
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().transaction_hash_numbers_in_rocksdb {
             return Ok(EitherWriter::RocksDB(_rocksdb_batch));
         }
 
@@ -291,7 +291,7 @@ impl<'a> EitherWriter<'a, (), ()> {
         P::Tx: DbTxMut,
     {
         #[cfg(all(unix, feature = "rocksdb"))]
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().account_history_in_rocksdb {
             return Ok(EitherWriter::RocksDB(_rocksdb_batch));
         }
 
@@ -764,7 +764,7 @@ impl<'a> EitherReader<'a, (), ()> {
         P::Tx: DbTx,
     {
         #[cfg(all(unix, feature = "rocksdb"))]
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().storages_history_in_rocksdb {
             return Ok(EitherReader::RocksDB(
                 _rocksdb_tx.expect("storages_history_in_rocksdb requires rocksdb tx"),
             ));
@@ -786,7 +786,7 @@ impl<'a> EitherReader<'a, (), ()> {
         P::Tx: DbTx,
     {
         #[cfg(all(unix, feature = "rocksdb"))]
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().transaction_hash_numbers_in_rocksdb {
             return Ok(EitherReader::RocksDB(
                 _rocksdb_tx.expect("transaction_hash_numbers_in_rocksdb requires rocksdb tx"),
             ));
@@ -808,7 +808,7 @@ impl<'a> EitherReader<'a, (), ()> {
         P::Tx: DbTx,
     {
         #[cfg(all(unix, feature = "rocksdb"))]
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().account_history_in_rocksdb {
             return Ok(EitherReader::RocksDB(
                 _rocksdb_tx.expect("account_history_in_rocksdb requires rocksdb tx"),
             ));
@@ -1046,7 +1046,7 @@ impl EitherWriterDestination {
         P: StorageSettingsCache,
     {
         // Write senders to static files only if they're explicitly enabled
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().transaction_senders_in_static_files {
             Self::StaticFile
         } else {
             Self::Database
@@ -1059,7 +1059,7 @@ impl EitherWriterDestination {
         P: StorageSettingsCache,
     {
         // Write account changesets to static files only if they're explicitly enabled
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().account_changesets_in_static_files {
             Self::StaticFile
         } else {
             Self::Database
@@ -1072,7 +1072,7 @@ impl EitherWriterDestination {
         P: StorageSettingsCache,
     {
         // Write storage changesets to static files only if they're explicitly enabled
-        if provider.cached_storage_settings().storage_v2 {
+        if provider.cached_storage_settings().storage_changesets_in_static_files {
             Self::StaticFile
         } else {
             Self::Database
@@ -1127,7 +1127,9 @@ mod tests {
             writer.commit().unwrap();
         }
 
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::default().with_account_changesets_in_static_files(true),
+        );
 
         let provider = factory.database_provider_ro().unwrap();
 
@@ -1159,11 +1161,10 @@ mod tests {
         ];
 
         for transaction_senders_in_static_files in [false, true] {
-            factory.set_storage_settings_cache(if transaction_senders_in_static_files {
-                StorageSettings::v2()
-            } else {
+            factory.set_storage_settings_cache(
                 StorageSettings::v1()
-            });
+                    .with_transaction_senders_in_static_files(transaction_senders_in_static_files),
+            );
 
             let provider = factory.database_provider_rw().unwrap();
             let mut writer = EitherWriter::new_senders(&provider, 0).unwrap();
@@ -1233,7 +1234,9 @@ mod rocksdb_tests {
         let factory = create_test_provider_factory();
 
         // Enable RocksDB for transaction hash numbers
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+        );
 
         let hash1 = B256::from([1u8; 32]);
         let hash2 = B256::from([2u8; 32]);
@@ -1275,7 +1278,9 @@ mod rocksdb_tests {
         let factory = create_test_provider_factory();
 
         // Enable RocksDB for transaction hash numbers
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+        );
 
         let hash = B256::from([1u8; 32]);
         let tx_num = 100u64;
@@ -1827,7 +1832,9 @@ mod rocksdb_tests {
         let factory = create_test_provider_factory();
 
         // Enable RocksDB for transaction hash numbers
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+        );
 
         let hash1 = B256::from([1u8; 32]);
         let hash2 = B256::from([2u8; 32]);
@@ -1885,7 +1892,9 @@ mod rocksdb_tests {
     fn test_settings_mismatch_panics() {
         let factory = create_test_provider_factory();
 
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_account_history_in_rocksdb(true),
+        );
 
         let provider = factory.database_provider_ro().unwrap();
         let _ = EitherReader::<(), ()>::new_accounts_history(&provider, None);

crates/storage/provider/src/providers/blockchain_provider.rs

@@ -23,13 +23,11 @@ use reth_chainspec::ChainInfo;
 use reth_db_api::models::{AccountBeforeTx, BlockNumberAddress, StoredBlockBodyIndices};
 use reth_execution_types::ExecutionOutcome;
 use reth_node_types::{BlockTy, HeaderTy, NodeTypesWithDB, ReceiptTy, TxTy};
-use reth_primitives_traits::{Account, RecoveredBlock, SealedHeader};
+use reth_primitives_traits::{Account, RecoveredBlock, SealedHeader, StorageEntry};
 use reth_prune_types::{PruneCheckpoint, PruneSegment};
 use reth_stages_types::{StageCheckpoint, StageId};
 use reth_static_file_types::StaticFileSegment;
-use reth_storage_api::{
-    BlockBodyIndicesProvider, ChangesetEntry, NodePrimitivesProvider, StorageChangeSetReader,
-};
+use reth_storage_api::{BlockBodyIndicesProvider, NodePrimitivesProvider, StorageChangeSetReader};
 use reth_storage_errors::provider::ProviderResult;
 use reth_trie::{HashedPostState, KeccakKeyHasher};
 use revm_database::BundleState;
@@ -715,7 +713,7 @@ impl<N: ProviderNodeTypes> StorageChangeSetReader for BlockchainProvider<N> {
     fn storage_changeset(
         &self,
         block_number: BlockNumber,
-    ) -> ProviderResult<Vec<(BlockNumberAddress, ChangesetEntry)>> {
+    ) -> ProviderResult<Vec<(BlockNumberAddress, StorageEntry)>> {
         self.consistent_provider()?.storage_changeset(block_number)
     }
 
@@ -724,14 +722,14 @@ impl<N: ProviderNodeTypes> StorageChangeSetReader for BlockchainProvider<N> {
         block_number: BlockNumber,
         address: Address,
         storage_key: B256,
-    ) -> ProviderResult<Option<ChangesetEntry>> {
+    ) -> ProviderResult<Option<StorageEntry>> {
         self.consistent_provider()?.get_storage_before_block(block_number, address, storage_key)
     }
 
     fn storage_changesets_range(
         &self,
         range: impl RangeBounds<BlockNumber>,
-    ) -> ProviderResult<Vec<(BlockNumberAddress, ChangesetEntry)>> {
+    ) -> ProviderResult<Vec<(BlockNumberAddress, StorageEntry)>> {
         self.consistent_provider()?.storage_changesets_range(range)
     }
 

crates/storage/provider/src/providers/consistent.rs

@@ -21,16 +21,13 @@ use reth_chainspec::ChainInfo;
 use reth_db_api::models::{AccountBeforeTx, BlockNumberAddress, StoredBlockBodyIndices};
 use reth_execution_types::{BundleStateInit, ExecutionOutcome, RevertsInit};
 use reth_node_types::{BlockTy, HeaderTy, ReceiptTy, TxTy};
-use reth_primitives_traits::{
-    Account, BlockBody, RecoveredBlock, SealedHeader, StorageEntry, StorageSlotKey,
-};
+use reth_primitives_traits::{Account, BlockBody, RecoveredBlock, SealedHeader, StorageEntry};
 use reth_prune_types::{PruneCheckpoint, PruneSegment};
 use reth_stages_types::{StageCheckpoint, StageId};
 use reth_static_file_types::StaticFileSegment;
 use reth_storage_api::{
-    BlockBodyIndicesProvider, ChangesetEntry, DatabaseProviderFactory, NodePrimitivesProvider,
-    StateProvider, StateProviderBox, StorageChangeSetReader, StorageSettingsCache,
-    TryIntoHistoricalStateProvider,
+    BlockBodyIndicesProvider, DatabaseProviderFactory, NodePrimitivesProvider, StateProvider,
+    StateProviderBox, StorageChangeSetReader, TryIntoHistoricalStateProvider,
 };
 use reth_storage_errors::provider::ProviderResult;
 use revm_database::states::PlainStorageRevert;
@@ -217,16 +214,13 @@ impl<N: ProviderNodeTypes> ConsistentProvider<N> {
         )))
     }
 
-    /// Populate a [`BundleStateInit`] and [`RevertsInit`] based on the given storage and account
-    /// changesets.
-    ///
-    /// When `use_hashed_state` is enabled, storage changeset keys are already hashed, so current
-    /// values are read directly from [`reth_db_api::tables::HashedStorages`]. Otherwise, values
-    /// are read via [`StateProvider::storage`] which queries plain state tables.
+    /// Populate a [`BundleStateInit`] and [`RevertsInit`] using cursors over the
+    /// [`reth_db::PlainAccountState`] and [`reth_db::PlainStorageState`] tables, based on the given
+    /// storage and account changesets.
     fn populate_bundle_state(
         &self,
         account_changeset: Vec<(u64, AccountBeforeTx)>,
-        storage_changeset: Vec<(BlockNumberAddress, ChangesetEntry)>,
+        storage_changeset: Vec<(BlockNumberAddress, StorageEntry)>,
         block_range_end: BlockNumber,
     ) -> ProviderResult<(BundleStateInit, RevertsInit)> {
         let mut state: BundleStateInit = HashMap::default();
@@ -263,16 +257,10 @@ impl<N: ProviderNodeTypes> ConsistentProvider<N> {
             };
 
             // match storage.
-            match account_state.2.entry(old_storage.key.as_b256()) {
+            match account_state.2.entry(old_storage.key) {
                 hash_map::Entry::Vacant(entry) => {
-                    let new_storage_value = match old_storage.key {
-                        StorageSlotKey::Hashed(_) => state_provider
-                            .storage_by_hashed_key(address, old_storage.key.as_b256())?
-                            .unwrap_or_default(),
-                        StorageSlotKey::Plain(_) => state_provider
-                            .storage(address, old_storage.key.as_b256())?
-                            .unwrap_or_default(),
-                    };
+                    let new_storage_value =
+                        state_provider.storage(address, old_storage.key)?.unwrap_or_default();
                     entry.insert((old_storage.value, new_storage_value));
                 }
                 hash_map::Entry::Occupied(mut entry) => {
@@ -286,7 +274,7 @@ impl<N: ProviderNodeTypes> ConsistentProvider<N> {
                 .entry(address)
                 .or_default()
                 .1
-                .push(StorageEntry::from(old_storage));
+                .push(old_storage);
         }
 
         Ok((state, reverts))
@@ -1312,8 +1300,7 @@ impl<N: ProviderNodeTypes> StorageChangeSetReader for ConsistentProvider<N> {
     fn storage_changeset(
         &self,
         block_number: BlockNumber,
-    ) -> ProviderResult<Vec<(BlockNumberAddress, ChangesetEntry)>> {
-        let use_hashed = self.storage_provider.cached_storage_settings().use_hashed_state();
+    ) -> ProviderResult<Vec<(BlockNumberAddress, StorageEntry)>> {
         if let Some(state) =
             self.head_block.as_ref().and_then(|b| b.block_on_chain(block_number.into()))
         {
@@ -1329,10 +1316,9 @@ impl<N: ProviderNodeTypes> StorageChangeSetReader for ConsistentProvider<N> {
                 .flatten()
                 .flat_map(|revert: PlainStorageRevert| {
                     revert.storage_revert.into_iter().map(move |(key, value)| {
-                        let tagged_key = StorageSlotKey::from_u256(key).to_changeset(use_hashed);
                         (
                             BlockNumberAddress((block_number, revert.address)),
-                            ChangesetEntry { key: tagged_key, value: value.to_previous_value() },
+                            StorageEntry { key: key.into(), value: value.to_previous_value() },
                         )
                     })
                 })
@@ -1367,8 +1353,7 @@ impl<N: ProviderNodeTypes> StorageChangeSetReader for ConsistentProvider<N> {
         block_number: BlockNumber,
         address: Address,
         storage_key: B256,
-    ) -> ProviderResult<Option<ChangesetEntry>> {
-        let use_hashed = self.storage_provider.cached_storage_settings().use_hashed_state();
+    ) -> ProviderResult<Option<StorageEntry>> {
         if let Some(state) =
             self.head_block.as_ref().and_then(|b| b.block_on_chain(block_number.into()))
         {
@@ -1387,11 +1372,9 @@ impl<N: ProviderNodeTypes> StorageChangeSetReader for ConsistentProvider<N> {
                         return None
                     }
                     revert.storage_revert.into_iter().find_map(|(key, value)| {
-                        let tagged_key = StorageSlotKey::from_u256(key).to_changeset(use_hashed);
-                        (tagged_key.as_b256() == storage_key).then(|| ChangesetEntry {
-                            key: tagged_key,
-                            value: value.to_previous_value(),
-                        })
+                        let key = key.into();
+                        (key == storage_key)
+                            .then(|| StorageEntry { key, value: value.to_previous_value() })
                     })
                 });
             Ok(changeset)
@@ -1415,14 +1398,12 @@ impl<N: ProviderNodeTypes> StorageChangeSetReader for ConsistentProvider<N> {
     fn storage_changesets_range(
         &self,
         range: impl RangeBounds<BlockNumber>,
-    ) -> ProviderResult<Vec<(BlockNumberAddress, ChangesetEntry)>> {
+    ) -> ProviderResult<Vec<(BlockNumberAddress, StorageEntry)>> {
         let range = to_range(range);
         let mut changesets = Vec::new();
         let database_start = range.start;
         let mut database_end = range.end;
 
-        let use_hashed = self.storage_provider.cached_storage_settings().use_hashed_state();
-
         if let Some(head_block) = &self.head_block {
             database_end = head_block.anchor().number;
 
@@ -1440,14 +1421,9 @@ impl<N: ProviderNodeTypes> StorageChangeSetReader for ConsistentProvider<N> {
                     .flatten()
                     .flat_map(|revert: PlainStorageRevert| {
                         revert.storage_revert.into_iter().map(move |(key, value)| {
-                            let tagged_key =
-                                StorageSlotKey::from_u256(key).to_changeset(use_hashed);
                             (
                                 BlockNumberAddress((state.number(), revert.address)),
-                                ChangesetEntry {
-                                    key: tagged_key,
-                                    value: value.to_previous_value(),
-                                },
+                                StorageEntry { key: key.into(), value: value.to_previous_value() },
                             )
                         })
                     });
@@ -2084,648 +2060,4 @@ mod tests {
 
         Ok(())
     }
-
-    #[test]
-    fn test_get_state_storage_value_hashed_state() -> eyre::Result<()> {
-        use alloy_primitives::{keccak256, U256};
-        use reth_db_api::{models::StorageSettings, tables, transaction::DbTxMut};
-        use reth_primitives_traits::StorageEntry;
-        use reth_storage_api::StorageSettingsCache;
-        use std::collections::HashMap;
-
-        let address = alloy_primitives::Address::with_last_byte(1);
-        let account = reth_primitives_traits::Account {
-            nonce: 1,
-            balance: U256::from(1000),
-            bytecode_hash: None,
-        };
-        let slot = U256::from(0x42);
-        let slot_b256 = B256::from(slot);
-        let hashed_address = keccak256(address);
-        let hashed_slot = keccak256(slot_b256);
-
-        let mut rng = generators::rng();
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
-
-        let blocks = random_block_range(
-            &mut rng,
-            0..=1,
-            BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..1, ..Default::default() },
-        );
-
-        let provider_rw = factory.provider_rw()?;
-        provider_rw.append_blocks_with_state(
-            blocks
-                .into_iter()
-                .map(|b| b.try_recover().expect("failed to seal block with senders"))
-                .collect(),
-            &ExecutionOutcome {
-                bundle: BundleState::new(
-                    [(address, None, Some(account.into()), {
-                        let mut s = HashMap::default();
-                        s.insert(slot, (U256::ZERO, U256::from(100)));
-                        s
-                    })],
-                    [
-                        Vec::new(),
-                        vec![(address, Some(Some(account.into())), vec![(slot, U256::ZERO)])],
-                    ],
-                    [],
-                ),
-                first_block: 0,
-                ..Default::default()
-            },
-            Default::default(),
-        )?;
-
-        provider_rw.tx_ref().put::<tables::HashedStorages>(
-            hashed_address,
-            StorageEntry { key: hashed_slot, value: U256::from(100) },
-        )?;
-        provider_rw.tx_ref().put::<tables::HashedAccounts>(hashed_address, account)?;
-
-        provider_rw.commit()?;
-
-        let provider = BlockchainProvider::new(factory)?;
-        let consistent_provider = provider.consistent_provider()?;
-
-        let outcome =
-            consistent_provider.get_state(1..=1)?.expect("should return execution outcome");
-
-        let state = &outcome.bundle.state;
-        let account_state = state.get(&address).expect("should have account in bundle state");
-        let storage = &account_state.storage;
-
-        let slot_as_u256 = U256::from_be_bytes(*hashed_slot);
-        let storage_slot = storage.get(&slot_as_u256).expect("should have the slot in storage");
-
-        assert_eq!(
-            storage_slot.present_value,
-            U256::from(100),
-            "present_value should be 100 (the actual value in HashedStorages)"
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    #[cfg(all(unix, feature = "rocksdb"))]
-    fn test_get_state_storage_value_hashed_state_historical() -> eyre::Result<()> {
-        use alloy_primitives::{keccak256, U256};
-        use reth_db_api::{models::StorageSettings, tables, transaction::DbTxMut};
-        use reth_primitives_traits::StorageEntry;
-        use reth_storage_api::StorageSettingsCache;
-        use std::collections::HashMap;
-
-        let address = alloy_primitives::Address::with_last_byte(1);
-        let account = reth_primitives_traits::Account {
-            nonce: 1,
-            balance: U256::from(1000),
-            bytecode_hash: None,
-        };
-        let slot = U256::from(0x42);
-        let slot_b256 = B256::from(slot);
-        let hashed_address = keccak256(address);
-        let hashed_slot = keccak256(slot_b256);
-
-        let mut rng = generators::rng();
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
-
-        let blocks = random_block_range(
-            &mut rng,
-            0..=3,
-            BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..1, ..Default::default() },
-        );
-
-        let provider_rw = factory.provider_rw()?;
-        provider_rw.append_blocks_with_state(
-            blocks
-                .into_iter()
-                .map(|b| b.try_recover().expect("failed to seal block with senders"))
-                .collect(),
-            &ExecutionOutcome {
-                bundle: BundleState::new(
-                    [(address, None, Some(account.into()), {
-                        let mut s = HashMap::default();
-                        s.insert(slot, (U256::ZERO, U256::from(300)));
-                        s
-                    })],
-                    [
-                        Vec::new(),
-                        vec![(address, Some(Some(account.into())), vec![(slot, U256::ZERO)])],
-                        vec![(address, Some(Some(account.into())), vec![(slot, U256::from(100))])],
-                        vec![(address, Some(Some(account.into())), vec![(slot, U256::from(200))])],
-                    ],
-                    [],
-                ),
-                first_block: 0,
-                ..Default::default()
-            },
-            Default::default(),
-        )?;
-
-        provider_rw.tx_ref().put::<tables::HashedStorages>(
-            hashed_address,
-            StorageEntry { key: hashed_slot, value: U256::from(300) },
-        )?;
-        provider_rw.tx_ref().put::<tables::HashedAccounts>(hashed_address, account)?;
-
-        provider_rw.commit()?;
-
-        let provider = BlockchainProvider::new(factory)?;
-        let consistent_provider = provider.consistent_provider()?;
-
-        let outcome =
-            consistent_provider.get_state(1..=2)?.expect("should return execution outcome");
-
-        let state = &outcome.bundle.state;
-        let account_state = state.get(&address).expect("should have account in bundle state");
-        let storage = &account_state.storage;
-
-        let slot_as_u256 = U256::from_be_bytes(*hashed_slot);
-        let storage_slot = storage.get(&slot_as_u256).expect("should have the slot in storage");
-
-        assert_eq!(
-            storage_slot.present_value,
-            U256::from(200),
-            "present_value should be 200 (the value at block 2, not 300 which is the latest)"
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_get_state_storage_value_plain_state() -> eyre::Result<()> {
-        use alloy_primitives::U256;
-        use reth_db_api::{models::StorageSettings, tables, transaction::DbTxMut};
-        use reth_primitives_traits::StorageEntry;
-        use reth_storage_api::StorageSettingsCache;
-        use std::collections::HashMap;
-
-        let address = alloy_primitives::Address::with_last_byte(1);
-        let account = reth_primitives_traits::Account {
-            nonce: 1,
-            balance: U256::from(1000),
-            bytecode_hash: None,
-        };
-        let slot = U256::from(0x42);
-        let slot_b256 = B256::from(slot);
-
-        let mut rng = generators::rng();
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v1());
-
-        let blocks = random_block_range(
-            &mut rng,
-            0..=1,
-            BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..1, ..Default::default() },
-        );
-
-        let provider_rw = factory.provider_rw()?;
-        provider_rw.append_blocks_with_state(
-            blocks
-                .into_iter()
-                .map(|b| b.try_recover().expect("failed to seal block with senders"))
-                .collect(),
-            &ExecutionOutcome {
-                bundle: BundleState::new(
-                    [(address, None, Some(account.into()), {
-                        let mut s = HashMap::default();
-                        s.insert(slot, (U256::ZERO, U256::from(100)));
-                        s
-                    })],
-                    [
-                        Vec::new(),
-                        vec![(address, Some(Some(account.into())), vec![(slot, U256::ZERO)])],
-                    ],
-                    [],
-                ),
-                first_block: 0,
-                ..Default::default()
-            },
-            Default::default(),
-        )?;
-
-        provider_rw.tx_ref().put::<tables::PlainStorageState>(
-            address,
-            StorageEntry { key: slot_b256, value: U256::from(100) },
-        )?;
-        provider_rw.tx_ref().put::<tables::PlainAccountState>(address, account)?;
-
-        provider_rw.commit()?;
-
-        let provider = BlockchainProvider::new(factory)?;
-        let consistent_provider = provider.consistent_provider()?;
-
-        let outcome =
-            consistent_provider.get_state(1..=1)?.expect("should return execution outcome");
-
-        let state = &outcome.bundle.state;
-        let account_state = state.get(&address).expect("should have account in bundle state");
-        let storage = &account_state.storage;
-
-        let storage_slot = storage.get(&slot).expect("should have the slot in storage");
-
-        assert_eq!(
-            storage_slot.present_value,
-            U256::from(100),
-            "present_value should be 100 (the actual value in PlainStorageState)"
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_storage_changeset_consistent_keys_hashed_state() -> eyre::Result<()> {
-        use alloy_primitives::{keccak256, U256};
-        use reth_db_api::models::StorageSettings;
-        use reth_storage_api::{StorageChangeSetReader, StorageSettingsCache};
-        use std::collections::HashMap;
-
-        let mut rng = generators::rng();
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
-
-        let (database_blocks, in_memory_blocks) = random_blocks(&mut rng, 1, 1, None, None, 0..1);
-
-        let address = alloy_primitives::Address::with_last_byte(1);
-        let account = reth_primitives_traits::Account {
-            nonce: 1,
-            balance: U256::from(1000),
-            bytecode_hash: None,
-        };
-        let slot = U256::from(0x42);
-
-        let provider_rw = factory.provider_rw()?;
-        provider_rw.append_blocks_with_state(
-            database_blocks
-                .into_iter()
-                .map(|b| b.try_recover().expect("failed to seal block with senders"))
-                .collect(),
-            &ExecutionOutcome {
-                bundle: BundleState::new(
-                    [(address, None, Some(account.into()), {
-                        let mut s = HashMap::default();
-                        s.insert(slot, (U256::ZERO, U256::from(100)));
-                        s
-                    })],
-                    [[(address, Some(Some(account.into())), vec![(slot, U256::ZERO)])]],
-                    [],
-                ),
-                first_block: 0,
-                ..Default::default()
-            },
-            Default::default(),
-        )?;
-        provider_rw.commit()?;
-
-        let provider = BlockchainProvider::new(factory)?;
-
-        let in_mem_block = in_memory_blocks.first().unwrap();
-        let senders = in_mem_block.senders().expect("failed to recover senders");
-        let chain = NewCanonicalChain::Commit {
-            new: vec![ExecutedBlock {
-                recovered_block: Arc::new(RecoveredBlock::new_sealed(
-                    in_mem_block.clone(),
-                    senders,
-                )),
-                execution_output: Arc::new(BlockExecutionOutput {
-                    state: BundleState::new(
-                        [(address, None, Some(account.into()), {
-                            let mut s = HashMap::default();
-                            s.insert(slot, (U256::from(100), U256::from(200)));
-                            s
-                        })],
-                        [[(address, Some(Some(account.into())), vec![(slot, U256::from(100))])]],
-                        [],
-                    ),
-                    result: BlockExecutionResult {
-                        receipts: Default::default(),
-                        requests: Default::default(),
-                        gas_used: 0,
-                        blob_gas_used: 0,
-                    },
-                }),
-                ..Default::default()
-            }],
-        };
-        provider.canonical_in_memory_state.update_chain(chain);
-
-        let consistent_provider = provider.consistent_provider()?;
-
-        let db_changeset = consistent_provider.storage_changeset(0)?;
-        let mem_changeset = consistent_provider.storage_changeset(1)?;
-
-        let slot_b256 = B256::from(slot);
-        let _hashed_slot_b256 = keccak256(slot_b256);
-
-        assert_eq!(db_changeset.len(), 1);
-        assert_eq!(mem_changeset.len(), 1);
-
-        let db_key = db_changeset[0].1.key;
-        let mem_key = mem_changeset[0].1.key;
-
-        assert_eq!(
-            db_key, mem_key,
-            "DB and in-memory changesets should return the same key format (hashed) for the same logical slot"
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_storage_changeset_consistent_keys_plain_state() -> eyre::Result<()> {
-        use alloy_primitives::U256;
-        use reth_db_api::models::StorageSettings;
-        use reth_storage_api::{StorageChangeSetReader, StorageSettingsCache};
-        use std::collections::HashMap;
-
-        let mut rng = generators::rng();
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v1());
-
-        let (database_blocks, in_memory_blocks) = random_blocks(&mut rng, 1, 1, None, None, 0..1);
-
-        let address = alloy_primitives::Address::with_last_byte(1);
-        let account = reth_primitives_traits::Account {
-            nonce: 1,
-            balance: U256::from(1000),
-            bytecode_hash: None,
-        };
-        let slot = U256::from(0x42);
-
-        let provider_rw = factory.provider_rw()?;
-        provider_rw.append_blocks_with_state(
-            database_blocks
-                .into_iter()
-                .map(|b| b.try_recover().expect("failed to seal block with senders"))
-                .collect(),
-            &ExecutionOutcome {
-                bundle: BundleState::new(
-                    [(address, None, Some(account.into()), {
-                        let mut s = HashMap::default();
-                        s.insert(slot, (U256::ZERO, U256::from(100)));
-                        s
-                    })],
-                    [[(address, Some(Some(account.into())), vec![(slot, U256::ZERO)])]],
-                    [],
-                ),
-                first_block: 0,
-                ..Default::default()
-            },
-            Default::default(),
-        )?;
-        provider_rw.commit()?;
-
-        let provider = BlockchainProvider::new(factory)?;
-
-        let in_mem_block = in_memory_blocks.first().unwrap();
-        let senders = in_mem_block.senders().expect("failed to recover senders");
-        let chain = NewCanonicalChain::Commit {
-            new: vec![ExecutedBlock {
-                recovered_block: Arc::new(RecoveredBlock::new_sealed(
-                    in_mem_block.clone(),
-                    senders,
-                )),
-                execution_output: Arc::new(BlockExecutionOutput {
-                    state: BundleState::new(
-                        [(address, None, Some(account.into()), {
-                            let mut s = HashMap::default();
-                            s.insert(slot, (U256::from(100), U256::from(200)));
-                            s
-                        })],
-                        [[(address, Some(Some(account.into())), vec![(slot, U256::from(100))])]],
-                        [],
-                    ),
-                    result: BlockExecutionResult {
-                        receipts: Default::default(),
-                        requests: Default::default(),
-                        gas_used: 0,
-                        blob_gas_used: 0,
-                    },
-                }),
-                ..Default::default()
-            }],
-        };
-        provider.canonical_in_memory_state.update_chain(chain);
-
-        let consistent_provider = provider.consistent_provider()?;
-
-        let db_changeset = consistent_provider.storage_changeset(0)?;
-        let mem_changeset = consistent_provider.storage_changeset(1)?;
-
-        let slot_b256 = B256::from(slot);
-
-        assert_eq!(db_changeset.len(), 1);
-        assert_eq!(mem_changeset.len(), 1);
-
-        let db_key = db_changeset[0].1.key.as_b256();
-        let mem_key = mem_changeset[0].1.key.as_b256();
-
-        assert_eq!(db_key, slot_b256, "DB changeset should use plain (unhashed) key");
-        assert_eq!(mem_key, slot_b256, "In-memory changeset should use plain (unhashed) key");
-        assert_eq!(
-            db_key, mem_key,
-            "DB and in-memory changesets should return the same key format (plain) for the same logical slot"
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_storage_changesets_range_consistent_keys_hashed_state() -> eyre::Result<()> {
-        use alloy_primitives::U256;
-        use reth_db_api::models::StorageSettings;
-        use reth_storage_api::{StorageChangeSetReader, StorageSettingsCache};
-        use std::collections::HashMap;
-
-        let mut rng = generators::rng();
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
-
-        let (database_blocks, in_memory_blocks) = random_blocks(&mut rng, 2, 1, None, None, 0..1);
-
-        let address = alloy_primitives::Address::with_last_byte(1);
-        let account = reth_primitives_traits::Account {
-            nonce: 1,
-            balance: U256::from(1000),
-            bytecode_hash: None,
-        };
-        let slot = U256::from(0x42);
-
-        let provider_rw = factory.provider_rw()?;
-        provider_rw.append_blocks_with_state(
-            database_blocks
-                .into_iter()
-                .map(|b| b.try_recover().expect("failed to seal block with senders"))
-                .collect(),
-            &ExecutionOutcome {
-                bundle: BundleState::new(
-                    [(address, None, Some(account.into()), {
-                        let mut s = HashMap::default();
-                        s.insert(slot, (U256::ZERO, U256::from(100)));
-                        s
-                    })],
-                    vec![
-                        vec![(address, Some(Some(account.into())), vec![(slot, U256::ZERO)])],
-                        vec![],
-                    ],
-                    [],
-                ),
-                first_block: 0,
-                ..Default::default()
-            },
-            Default::default(),
-        )?;
-        provider_rw.commit()?;
-
-        let provider = BlockchainProvider::new(factory)?;
-
-        let in_mem_block = in_memory_blocks.first().unwrap();
-        let senders = in_mem_block.senders().expect("failed to recover senders");
-        let chain = NewCanonicalChain::Commit {
-            new: vec![ExecutedBlock {
-                recovered_block: Arc::new(RecoveredBlock::new_sealed(
-                    in_mem_block.clone(),
-                    senders,
-                )),
-                execution_output: Arc::new(BlockExecutionOutput {
-                    state: BundleState::new(
-                        [(address, None, Some(account.into()), {
-                            let mut s = HashMap::default();
-                            s.insert(slot, (U256::from(100), U256::from(200)));
-                            s
-                        })],
-                        [[(address, Some(Some(account.into())), vec![(slot, U256::from(100))])]],
-                        [],
-                    ),
-                    result: BlockExecutionResult {
-                        receipts: Default::default(),
-                        requests: Default::default(),
-                        gas_used: 0,
-                        blob_gas_used: 0,
-                    },
-                }),
-                ..Default::default()
-            }],
-        };
-        provider.canonical_in_memory_state.update_chain(chain);
-
-        let consistent_provider = provider.consistent_provider()?;
-
-        let all_changesets = consistent_provider.storage_changesets_range(0..=2)?;
-
-        assert_eq!(all_changesets.len(), 2, "should have one changeset entry per block");
-
-        let keys: Vec<B256> = all_changesets.iter().map(|(_, entry)| entry.key.as_b256()).collect();
-
-        assert_eq!(
-            keys[0], keys[1],
-            "same logical slot should produce identical keys whether from DB or memory"
-        );
-
-        Ok(())
-    }
-
-    #[test]
-    fn test_storage_changesets_range_consistent_keys_plain_state() -> eyre::Result<()> {
-        use alloy_primitives::U256;
-        use reth_db_api::models::StorageSettings;
-        use reth_storage_api::{StorageChangeSetReader, StorageSettingsCache};
-        use std::collections::HashMap;
-
-        let mut rng = generators::rng();
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v1());
-
-        let (database_blocks, in_memory_blocks) = random_blocks(&mut rng, 2, 1, None, None, 0..1);
-
-        let address = alloy_primitives::Address::with_last_byte(1);
-        let account = reth_primitives_traits::Account {
-            nonce: 1,
-            balance: U256::from(1000),
-            bytecode_hash: None,
-        };
-        let slot = U256::from(0x42);
-
-        let provider_rw = factory.provider_rw()?;
-        provider_rw.append_blocks_with_state(
-            database_blocks
-                .into_iter()
-                .map(|b| b.try_recover().expect("failed to seal block with senders"))
-                .collect(),
-            &ExecutionOutcome {
-                bundle: BundleState::new(
-                    [(address, None, Some(account.into()), {
-                        let mut s = HashMap::default();
-                        s.insert(slot, (U256::ZERO, U256::from(100)));
-                        s
-                    })],
-                    vec![
-                        vec![(address, Some(Some(account.into())), vec![(slot, U256::ZERO)])],
-                        vec![],
-                    ],
-                    [],
-                ),
-                first_block: 0,
-                ..Default::default()
-            },
-            Default::default(),
-        )?;
-        provider_rw.commit()?;
-
-        let provider = BlockchainProvider::new(factory)?;
-
-        let in_mem_block = in_memory_blocks.first().unwrap();
-        let senders = in_mem_block.senders().expect("failed to recover senders");
-        let chain = NewCanonicalChain::Commit {
-            new: vec![ExecutedBlock {
-                recovered_block: Arc::new(RecoveredBlock::new_sealed(
-                    in_mem_block.clone(),
-                    senders,
-                )),
-                execution_output: Arc::new(BlockExecutionOutput {
-                    state: BundleState::new(
-                        [(address, None, Some(account.into()), {
-                            let mut s = HashMap::default();
-                            s.insert(slot, (U256::from(100), U256::from(200)));
-                            s
-                        })],
-                        [[(address, Some(Some(account.into())), vec![(slot, U256::from(100))])]],
-                        [],
-                    ),
-                    result: BlockExecutionResult {
-                        receipts: Default::default(),
-                        requests: Default::default(),
-                        gas_used: 0,
-                        blob_gas_used: 0,
-                    },
-                }),
-                ..Default::default()
-            }],
-        };
-        provider.canonical_in_memory_state.update_chain(chain);
-
-        let consistent_provider = provider.consistent_provider()?;
-
-        let all_changesets = consistent_provider.storage_changesets_range(0..=2)?;
-
-        assert_eq!(all_changesets.len(), 2, "should have one changeset entry per block");
-
-        let slot_b256 = B256::from(slot);
-        let keys: Vec<B256> = all_changesets.iter().map(|(_, entry)| entry.key.as_b256()).collect();
-
-        assert_eq!(
-            keys[0], keys[1],
-            "same logical slot should produce identical keys whether from DB or memory"
-        );
-        assert_eq!(
-            keys[0], slot_b256,
-            "keys should be plain/unhashed when use_hashed_state is false"
-        );
-
-        Ok(())
-    }
 }

crates/storage/provider/src/providers/rocksdb/invariants.rs

@@ -62,21 +62,21 @@ impl RocksDBProvider {
         let mut unwind_target: Option<BlockNumber> = None;
 
         // Heal TransactionHashNumbers if stored in RocksDB
-        if provider.cached_storage_settings().storage_v2 &&
+        if provider.cached_storage_settings().transaction_hash_numbers_in_rocksdb &&
             let Some(target) = self.heal_transaction_hash_numbers(provider)?
         {
             unwind_target = Some(unwind_target.map_or(target, |t| t.min(target)));
         }
 
         // Heal StoragesHistory if stored in RocksDB
-        if provider.cached_storage_settings().storage_v2 &&
+        if provider.cached_storage_settings().storages_history_in_rocksdb &&
             let Some(target) = self.heal_storages_history(provider)?
         {
             unwind_target = Some(unwind_target.map_or(target, |t| t.min(target)));
         }
 
         // Heal AccountsHistory if stored in RocksDB
-        if provider.cached_storage_settings().storage_v2 &&
+        if provider.cached_storage_settings().account_history_in_rocksdb &&
             let Some(target) = self.heal_accounts_history(provider)?
         {
             unwind_target = Some(unwind_target.map_or(target, |t| t.min(target)));
@@ -317,10 +317,7 @@ impl RocksDBProvider {
 
             let unique_keys: HashSet<_> = changesets
                 .into_iter()
-                .map(|(block_addr, entry)| {
-                    // entry.key is a hashed storage key
-                    (block_addr.address(), entry.key.as_b256(), checkpoint + 1)
-                })
+                .map(|(block_addr, entry)| (block_addr.address(), entry.key, checkpoint + 1))
                 .collect();
             let indices: Vec<_> = unique_keys.into_iter().collect();
 
@@ -496,11 +493,19 @@ mod tests {
     #[test]
     fn test_check_consistency_empty_rocksdb_no_checkpoint_is_ok() {
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::TransactionHashNumbers>()
+            .with_table::<tables::StoragesHistory>()
+            .build()
+            .unwrap();
 
         // Create a test provider factory for MDBX
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1()
+                .with_transaction_hash_numbers_in_rocksdb(true)
+                .with_storages_history_in_rocksdb(true),
+        );
 
         let provider = factory.database_provider_ro().unwrap();
 
@@ -512,11 +517,16 @@ mod tests {
     #[test]
     fn test_check_consistency_empty_rocksdb_with_checkpoint_is_first_run() {
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::TransactionHashNumbers>()
+            .build()
+            .unwrap();
 
         // Create a test provider factory for MDBX
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+        );
 
         // Set a checkpoint indicating we should have processed up to block 100
         {
@@ -540,10 +550,15 @@ mod tests {
     #[test]
     fn test_check_consistency_checkpoint_zero_with_rocksdb_data_prunes_all() {
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::TransactionHashNumbers>()
+            .build()
+            .unwrap();
 
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+        );
 
         // Generate blocks with real transactions and insert them
         let mut rng = generators::rng();
@@ -571,18 +586,12 @@ mod tests {
             provider.commit().unwrap();
         }
 
-        // Explicitly clear the checkpoints to simulate crash recovery
+        // Explicitly clear the TransactionLookup checkpoint to simulate crash recovery
         {
             let provider = factory.database_provider_rw().unwrap();
             provider
                 .save_stage_checkpoint(StageId::TransactionLookup, StageCheckpoint::new(0))
                 .unwrap();
-            provider
-                .save_stage_checkpoint(StageId::IndexStorageHistory, StageCheckpoint::new(0))
-                .unwrap();
-            provider
-                .save_stage_checkpoint(StageId::IndexAccountHistory, StageCheckpoint::new(0))
-                .unwrap();
             provider.commit().unwrap();
         }
 
@@ -608,11 +617,16 @@ mod tests {
     #[test]
     fn test_check_consistency_storages_history_empty_with_checkpoint_is_first_run() {
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::StoragesHistory>()
+            .build()
+            .unwrap();
 
         // Create a test provider factory for MDBX
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_storages_history_in_rocksdb(true),
+        );
 
         // Set a checkpoint indicating we should have processed up to block 100
         {
@@ -635,7 +649,10 @@ mod tests {
     #[test]
     fn test_check_consistency_storages_history_has_data_no_checkpoint_prunes_data() {
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::StoragesHistory>()
+            .build()
+            .unwrap();
 
         // Insert data into RocksDB
         let key = StorageShardedKey::new(Address::ZERO, B256::ZERO, 50);
@@ -647,7 +664,9 @@ mod tests {
 
         // Create a test provider factory for MDBX with NO checkpoint
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_storages_history_in_rocksdb(true),
+        );
 
         let provider = factory.database_provider_ro().unwrap();
 
@@ -665,10 +684,15 @@ mod tests {
     #[test]
     fn test_check_consistency_mdbx_behind_checkpoint_needs_unwind() {
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::TransactionHashNumbers>()
+            .build()
+            .unwrap();
 
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+        );
 
         // Generate blocks with real transactions (blocks 0-2, 6 transactions total)
         let mut rng = generators::rng();
@@ -702,13 +726,6 @@ mod tests {
             provider
                 .save_stage_checkpoint(StageId::TransactionLookup, StageCheckpoint::new(10))
                 .unwrap();
-            // Reset history checkpoints so they don't interfere
-            provider
-                .save_stage_checkpoint(StageId::IndexStorageHistory, StageCheckpoint::new(0))
-                .unwrap();
-            provider
-                .save_stage_checkpoint(StageId::IndexAccountHistory, StageCheckpoint::new(0))
-                .unwrap();
             provider.commit().unwrap();
         }
 
@@ -722,11 +739,16 @@ mod tests {
     #[test]
     fn test_check_consistency_rocksdb_ahead_of_checkpoint_prunes_excess() {
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::TransactionHashNumbers>()
+            .build()
+            .unwrap();
 
         // Create a test provider factory for MDBX
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+        );
 
         // Generate blocks with real transactions:
         // Blocks 0-5, each with 2 transactions = 12 total transactions (0-11)
@@ -784,13 +806,6 @@ mod tests {
             provider
                 .save_stage_checkpoint(StageId::TransactionLookup, StageCheckpoint::new(2))
                 .unwrap();
-            // Reset history checkpoints so they don't interfere
-            provider
-                .save_stage_checkpoint(StageId::IndexStorageHistory, StageCheckpoint::new(0))
-                .unwrap();
-            provider
-                .save_stage_checkpoint(StageId::IndexAccountHistory, StageCheckpoint::new(0))
-                .unwrap();
             provider.commit().unwrap();
         }
 
@@ -825,7 +840,10 @@ mod tests {
     #[test]
     fn test_check_consistency_storages_history_sentinel_only_with_checkpoint_is_first_run() {
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::StoragesHistory>()
+            .build()
+            .unwrap();
 
         // Insert ONLY sentinel entries (highest_block_number = u64::MAX)
         // This simulates a scenario where history tracking started but no shards were completed
@@ -840,7 +858,9 @@ mod tests {
 
         // Create a test provider factory for MDBX
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_storages_history_in_rocksdb(true),
+        );
 
         // Set a checkpoint indicating we should have processed up to block 100
         {
@@ -865,7 +885,10 @@ mod tests {
         use reth_db_api::models::ShardedKey;
 
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::AccountsHistory>()
+            .build()
+            .unwrap();
 
         // Insert ONLY sentinel entries (highest_block_number = u64::MAX)
         let key_sentinel_1 = ShardedKey::new(Address::ZERO, u64::MAX);
@@ -879,7 +902,9 @@ mod tests {
 
         // Create a test provider factory for MDBX
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_account_history_in_rocksdb(true),
+        );
 
         // Set a checkpoint indicating we should have processed up to block 100
         {
@@ -912,7 +937,9 @@ mod tests {
 
         // Create a test provider factory for MDBX
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_transaction_hash_numbers_in_rocksdb(true),
+        );
 
         // Generate random blocks with unique transactions
         // Block 0 (genesis) has no transactions
@@ -1016,11 +1043,16 @@ mod tests {
     #[test]
     fn test_check_consistency_accounts_history_empty_with_checkpoint_is_first_run() {
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::AccountsHistory>()
+            .build()
+            .unwrap();
 
         // Create a test provider factory for MDBX
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_account_history_in_rocksdb(true),
+        );
 
         // Set a checkpoint indicating we should have processed up to block 100
         {
@@ -1045,7 +1077,10 @@ mod tests {
         use reth_db_api::models::ShardedKey;
 
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::AccountsHistory>()
+            .build()
+            .unwrap();
 
         // Insert data into RocksDB
         let key = ShardedKey::new(Address::ZERO, 50);
@@ -1057,7 +1092,9 @@ mod tests {
 
         // Create a test provider factory for MDBX with NO checkpoint
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_account_history_in_rocksdb(true),
+        );
 
         let provider = factory.database_provider_ro().unwrap();
 
@@ -1080,7 +1117,10 @@ mod tests {
         use reth_static_file_types::StaticFileSegment;
 
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::AccountsHistory>()
+            .build()
+            .unwrap();
 
         // Insert some AccountsHistory entries with various highest_block_numbers
         let key1 = ShardedKey::new(Address::ZERO, 50);
@@ -1100,7 +1140,9 @@ mod tests {
 
         // Create a test provider factory for MDBX
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_account_history_in_rocksdb(true),
+        );
 
         // Write account changesets to static files for blocks 0-100
         {
@@ -1179,10 +1221,17 @@ mod tests {
         const CHECKPOINT_BLOCK: u64 = 5_000;
 
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::StoragesHistory>()
+            .build()
+            .unwrap();
 
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1()
+                .with_storages_history_in_rocksdb(true)
+                .with_storage_changesets_in_static_files(true),
+        );
 
         // Helper to generate address from block number (reuses stack arrays)
         #[inline]
@@ -1296,10 +1345,17 @@ mod tests {
         const SF_TIP: u64 = 200;
 
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::StoragesHistory>()
+            .build()
+            .unwrap();
 
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1()
+                .with_storages_history_in_rocksdb(true)
+                .with_storage_changesets_in_static_files(true),
+        );
 
         let checkpoint_addr = Address::repeat_byte(0xAA);
         let checkpoint_slot = B256::repeat_byte(0xBB);
@@ -1394,11 +1450,18 @@ mod tests {
         use reth_static_file_types::StaticFileSegment;
 
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::AccountsHistory>()
+            .build()
+            .unwrap();
 
         // Create test provider factory
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1()
+                .with_account_history_in_rocksdb(true)
+                .with_account_changesets_in_static_files(true),
+        );
 
         const TOTAL_BLOCKS: u64 = 15_000;
         const CHECKPOINT_BLOCK: u64 = 5_000;
@@ -1509,10 +1572,17 @@ mod tests {
         const SF_TIP: u64 = 200;
 
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::AccountsHistory>()
+            .build()
+            .unwrap();
 
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1()
+                .with_account_history_in_rocksdb(true)
+                .with_account_changesets_in_static_files(true),
+        );
 
         let checkpoint_addr = Address::repeat_byte(0xAA);
         let stale_addr = Address::repeat_byte(0xCC);
@@ -1579,7 +1649,10 @@ mod tests {
         use reth_static_file_types::StaticFileSegment;
 
         let temp_dir = TempDir::new().unwrap();
-        let rocksdb = RocksDBBuilder::new(temp_dir.path()).with_default_tables().build().unwrap();
+        let rocksdb = RocksDBBuilder::new(temp_dir.path())
+            .with_table::<tables::StoragesHistory>()
+            .build()
+            .unwrap();
 
         // Insert StoragesHistory entries into RocksDB
         let key1 = StorageShardedKey::new(Address::ZERO, B256::ZERO, 50);
@@ -1595,7 +1668,9 @@ mod tests {
 
         // Create a test provider factory
         let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
+        factory.set_storage_settings_cache(
+            StorageSettings::v1().with_storages_history_in_rocksdb(true),
+        );
 
         // Write storage changesets to static files for blocks 0-100
         {

crates/storage/provider/src/providers/rocksdb/provider.rs

@@ -2,7 +2,6 @@ use super::metrics::{RocksDBMetrics, RocksDBOperation, ROCKSDB_TABLES};
 use crate::providers::{compute_history_rank, needs_prev_shard_check, HistoryInfo};
 use alloy_consensus::transaction::TxHashRef;
 use alloy_primitives::{
-    keccak256,
     map::{AddressMap, HashMap},
     Address, BlockNumber, TxNumber, B256,
 };
@@ -1204,7 +1203,7 @@ impl RocksDBProvider {
         ctx: RocksDBWriteCtx,
         runtime: &reth_tasks::Runtime,
     ) -> ProviderResult<()> {
-        if !ctx.storage_settings.storage_v2 {
+        if !ctx.storage_settings.any_in_rocksdb() {
             return Ok(());
         }
 
@@ -1212,10 +1211,10 @@ impl RocksDBProvider {
         let mut r_account_history = None;
         let mut r_storage_history = None;
 
-        let write_tx_hash =
-            ctx.storage_settings.storage_v2 && ctx.prune_tx_lookup.is_none_or(|m| !m.is_full());
-        let write_account_history = ctx.storage_settings.storage_v2;
-        let write_storage_history = ctx.storage_settings.storage_v2;
+        let write_tx_hash = ctx.storage_settings.transaction_hash_numbers_in_rocksdb &&
+            ctx.prune_tx_lookup.is_none_or(|m| !m.is_full());
+        let write_account_history = ctx.storage_settings.account_history_in_rocksdb;
+        let write_storage_history = ctx.storage_settings.storages_history_in_rocksdb;
 
         runtime.storage_pool().in_place_scope(|s| {
             if write_tx_hash {
@@ -1337,8 +1336,7 @@ impl RocksDBProvider {
             for storage_block_reverts in reverts.storage {
                 for revert in storage_block_reverts {
                     for (slot, _) in revert.storage_revert {
-                        let plain_key = B256::new(slot.to_be_bytes());
-                        let key = keccak256(plain_key);
+                        let key = B256::new(slot.to_be_bytes());
                         storage_history
                             .entry((revert.address, key))
                             .or_default()

crates/storage/provider/src/providers/state/historical.rs

@@ -11,7 +11,7 @@ use reth_db_api::{
     transaction::DbTx,
     BlockNumberList,
 };
-use reth_primitives_traits::{Account, Bytecode, StorageSlotKey};
+use reth_primitives_traits::{Account, Bytecode};
 use reth_storage_api::{
     BlockNumReader, BytecodeReader, DBProvider, NodePrimitivesProvider, StateProofProvider,
     StorageChangeSetReader, StorageRootProvider, StorageSettingsCache,
@@ -26,8 +26,8 @@ use reth_trie::{
     TrieInputSorted,
 };
 use reth_trie_db::{
-    hashed_storage_from_reverts_with_provider, DatabaseProof, DatabaseStateRoot,
-    DatabaseStorageProof, DatabaseStorageRoot, DatabaseTrieWitness,
+    hashed_storage_from_reverts_with_provider, DatabaseHashedPostState, DatabaseProof,
+    DatabaseStateRoot, DatabaseStorageProof, DatabaseStorageRoot, DatabaseTrieWitness,
 };
 
 use std::fmt::Debug;
@@ -150,7 +150,7 @@ impl<'b, Provider: DBProvider + ChangeSetReader + StorageChangeSetReader + Block
     pub fn storage_history_lookup(
         &self,
         address: Address,
-        storage_key: StorageSlotKey,
+        storage_key: StorageKey,
     ) -> ProviderResult<HistoryInfo>
     where
         Provider: StorageSettingsCache + RocksDBProviderFactory + NodePrimitivesProvider,
@@ -159,85 +159,17 @@ impl<'b, Provider: DBProvider + ChangeSetReader + StorageChangeSetReader + Block
             return Err(ProviderError::StateAtBlockPruned(self.block_number))
         }
 
-        let lookup_key = if self.provider.cached_storage_settings().use_hashed_state() {
-            storage_key.to_hashed()
-        } else {
-            debug_assert!(
-                storage_key.is_plain(),
-                "expected plain storage key when use_hashed_state is false"
-            );
-            storage_key.as_b256()
-        };
-
         self.provider.with_rocksdb_tx(|rocks_tx_ref| {
             let mut reader = EitherReader::new_storages_history(self.provider, rocks_tx_ref)?;
             reader.storage_history_info(
                 address,
-                lookup_key,
+                storage_key,
                 self.block_number,
                 self.lowest_available_blocks.storage_history_block_number,
             )
         })
     }
 
-    /// Resolves a storage value by looking up the given key in history, changesets, or
-    /// plain state.
-    ///
-    /// Accepts a [`StorageSlotKey`]; the correct lookup key is derived internally
-    /// based on the storage mode.
-    fn storage_by_lookup_key(
-        &self,
-        address: Address,
-        storage_key: StorageSlotKey,
-    ) -> ProviderResult<Option<StorageValue>>
-    where
-        Provider: StorageSettingsCache + RocksDBProviderFactory + NodePrimitivesProvider,
-    {
-        let lookup_key = if self.provider.cached_storage_settings().use_hashed_state() {
-            storage_key.to_hashed()
-        } else {
-            debug_assert!(
-                storage_key.is_plain(),
-                "expected plain storage key when use_hashed_state is false"
-            );
-            storage_key.as_b256()
-        };
-
-        match self.storage_history_lookup(address, storage_key)? {
-            HistoryInfo::NotYetWritten => Ok(None),
-            HistoryInfo::InChangeset(changeset_block_number) => self
-                .provider
-                .get_storage_before_block(changeset_block_number, address, lookup_key)?
-                .ok_or_else(|| ProviderError::StorageChangesetNotFound {
-                    block_number: changeset_block_number,
-                    address,
-                    storage_key: Box::new(lookup_key),
-                })
-                .map(|entry| entry.value)
-                .map(Some),
-            HistoryInfo::InPlainState | HistoryInfo::MaybeInPlainState => {
-                if self.provider.cached_storage_settings().use_hashed_state() {
-                    let hashed_address = alloy_primitives::keccak256(address);
-                    Ok(self
-                        .tx()
-                        .cursor_dup_read::<tables::HashedStorages>()?
-                        .seek_by_key_subkey(hashed_address, lookup_key)?
-                        .filter(|entry| entry.key == lookup_key)
-                        .map(|entry| entry.value)
-                        .or(Some(StorageValue::ZERO)))
-                } else {
-                    Ok(self
-                        .tx()
-                        .cursor_dup_read::<tables::PlainStorageState>()?
-                        .seek_by_key_subkey(address, lookup_key)?
-                        .filter(|entry| entry.key == lookup_key)
-                        .map(|entry| entry.value)
-                        .or(Some(StorageValue::ZERO)))
-                }
-            }
-        }
-    }
-
     /// Checks and returns `true` if distance to historical block exceeds the provided limit.
     fn check_distance_against_limit(&self, limit: u64) -> ProviderResult<bool> {
         let tip = self.provider.last_block_number()?;
@@ -246,10 +178,7 @@ impl<'b, Provider: DBProvider + ChangeSetReader + StorageChangeSetReader + Block
     }
 
     /// Retrieve revert hashed state for this history provider.
-    fn revert_state(&self) -> ProviderResult<HashedPostStateSorted>
-    where
-        Provider: StorageSettingsCache,
-    {
+    fn revert_state(&self) -> ProviderResult<HashedPostStateSorted> {
         if !self.lowest_available_blocks.is_account_history_available(self.block_number) ||
             !self.lowest_available_blocks.is_storage_history_available(self.block_number)
         {
@@ -264,14 +193,11 @@ impl<'b, Provider: DBProvider + ChangeSetReader + StorageChangeSetReader + Block
             );
         }
 
-        reth_trie_db::from_reverts_auto(self.provider, self.block_number..)
+        HashedPostStateSorted::from_reverts::<KeccakKeyHasher>(self.provider, self.block_number..)
     }
 
     /// Retrieve revert hashed storage for this history provider and target address.
-    fn revert_storage(&self, address: Address) -> ProviderResult<HashedStorage>
-    where
-        Provider: StorageSettingsCache,
-    {
+    fn revert_storage(&self, address: Address) -> ProviderResult<HashedStorage> {
         if !self.lowest_available_blocks.is_storage_history_available(self.block_number) {
             return Err(ProviderError::StateAtBlockPruned(self.block_number))
         }
@@ -337,12 +263,7 @@ impl<
                     .map(|account_before| account_before.info)
             }
             HistoryInfo::InPlainState | HistoryInfo::MaybeInPlainState => {
-                if self.provider.cached_storage_settings().use_hashed_state() {
-                    let hashed_address = alloy_primitives::keccak256(address);
-                    Ok(self.tx().get_by_encoded_key::<tables::HashedAccounts>(&hashed_address)?)
-                } else {
-                    Ok(self.tx().get_by_encoded_key::<tables::PlainAccountState>(address)?)
-                }
+                Ok(self.tx().get_by_encoded_key::<tables::PlainAccountState>(address)?)
             }
         }
     }
@@ -365,13 +286,8 @@ impl<Provider: DBProvider + BlockNumReader + BlockHashReader> BlockHashReader
     }
 }
 
-impl<
-        Provider: DBProvider
-            + ChangeSetReader
-            + StorageChangeSetReader
-            + BlockNumReader
-            + StorageSettingsCache,
-    > StateRootProvider for HistoricalStateProviderRef<'_, Provider>
+impl<Provider: DBProvider + ChangeSetReader + StorageChangeSetReader + BlockNumReader>
+    StateRootProvider for HistoricalStateProviderRef<'_, Provider>
 {
     fn state_root(&self, hashed_state: HashedPostState) -> ProviderResult<B256> {
         let mut revert_state = self.revert_state()?;
@@ -407,13 +323,8 @@ impl<
     }
 }
 
-impl<
-        Provider: DBProvider
-            + ChangeSetReader
-            + StorageChangeSetReader
-            + BlockNumReader
-            + StorageSettingsCache,
-    > StorageRootProvider for HistoricalStateProviderRef<'_, Provider>
+impl<Provider: DBProvider + ChangeSetReader + StorageChangeSetReader + BlockNumReader>
+    StorageRootProvider for HistoricalStateProviderRef<'_, Provider>
 {
     fn storage_root(
         &self,
@@ -451,13 +362,8 @@ impl<
     }
 }
 
-impl<
-        Provider: DBProvider
-            + ChangeSetReader
-            + StorageChangeSetReader
-            + BlockNumReader
-            + StorageSettingsCache,
-    > StateProofProvider for HistoricalStateProviderRef<'_, Provider>
+impl<Provider: DBProvider + ChangeSetReader + StorageChangeSetReader + BlockNumReader>
+    StateProofProvider for HistoricalStateProviderRef<'_, Provider>
 {
     /// Get account and storage proofs.
     fn proof(
@@ -506,24 +412,32 @@ impl<
             + NodePrimitivesProvider,
     > StateProvider for HistoricalStateProviderRef<'_, Provider>
 {
-    /// Expects a plain (unhashed) storage key slot.
+    /// Get storage.
     fn storage(
         &self,
         address: Address,
         storage_key: StorageKey,
     ) -> ProviderResult<Option<StorageValue>> {
-        self.storage_by_lookup_key(address, StorageSlotKey::plain(storage_key))
-    }
-
-    fn storage_by_hashed_key(
-        &self,
-        address: Address,
-        hashed_storage_key: StorageKey,
-    ) -> ProviderResult<Option<StorageValue>> {
-        if !self.provider.cached_storage_settings().use_hashed_state() {
-            return Err(ProviderError::UnsupportedProvider)
+        match self.storage_history_lookup(address, storage_key)? {
+            HistoryInfo::NotYetWritten => Ok(None),
+            HistoryInfo::InChangeset(changeset_block_number) => self
+                .provider
+                .get_storage_before_block(changeset_block_number, address, storage_key)?
+                .ok_or_else(|| ProviderError::StorageChangesetNotFound {
+                    block_number: changeset_block_number,
+                    address,
+                    storage_key: Box::new(storage_key),
+                })
+                .map(|entry| entry.value)
+                .map(Some),
+            HistoryInfo::InPlainState | HistoryInfo::MaybeInPlainState => Ok(self
+                .tx()
+                .cursor_dup_read::<tables::PlainStorageState>()?
+                .seek_by_key_subkey(address, storage_key)?
+                .filter(|entry| entry.key == storage_key)
+                .map(|entry| entry.value)
+                .or(Some(StorageValue::ZERO))),
         }
-        self.storage_by_lookup_key(address, StorageSlotKey::hashed(hashed_storage_key))
     }
 }
 
@@ -716,7 +630,7 @@ mod tests {
         transaction::{DbTx, DbTxMut},
         BlockNumberList,
     };
-    use reth_primitives_traits::{Account, StorageEntry, StorageSlotKey};
+    use reth_primitives_traits::{Account, StorageEntry};
     use reth_storage_api::{
         BlockHashReader, BlockNumReader, ChangeSetReader, DBProvider, DatabaseProviderFactory,
         NodePrimitivesProvider, StorageChangeSetReader, StorageSettingsCache,
@@ -971,7 +885,7 @@ mod tests {
             Err(ProviderError::StateAtBlockPruned(number)) if number == provider.block_number
         ));
         assert!(matches!(
-            provider.storage_history_lookup(ADDRESS, StorageSlotKey::plain(STORAGE)),
+            provider.storage_history_lookup(ADDRESS, STORAGE),
             Err(ProviderError::StateAtBlockPruned(number)) if number == provider.block_number
         ));
 
@@ -990,7 +904,7 @@ mod tests {
             Ok(HistoryInfo::MaybeInPlainState)
         ));
         assert!(matches!(
-            provider.storage_history_lookup(ADDRESS, StorageSlotKey::plain(STORAGE)),
+            provider.storage_history_lookup(ADDRESS, STORAGE),
             Ok(HistoryInfo::MaybeInPlainState)
         ));
 
@@ -1009,7 +923,7 @@ mod tests {
             Ok(HistoryInfo::MaybeInPlainState)
         ));
         assert!(matches!(
-            provider.storage_history_lookup(ADDRESS, StorageSlotKey::plain(STORAGE)),
+            provider.storage_history_lookup(ADDRESS, STORAGE),
             Ok(HistoryInfo::MaybeInPlainState)
         ));
     }
@@ -1029,242 +943,6 @@ mod tests {
         assert_eq!(HistoryInfo::from_lookup(None, false, None), HistoryInfo::InPlainState);
     }
 
-    #[test]
-    fn history_provider_get_storage_legacy() {
-        let factory = create_test_provider_factory();
-
-        assert!(!factory.provider().unwrap().cached_storage_settings().use_hashed_state());
-
-        let tx = factory.provider_rw().unwrap().into_tx();
-
-        tx.put::<tables::StoragesHistory>(
-            StorageShardedKey {
-                address: ADDRESS,
-                sharded_key: ShardedKey { key: STORAGE, highest_block_number: 7 },
-            },
-            BlockNumberList::new([3, 7]).unwrap(),
-        )
-        .unwrap();
-        tx.put::<tables::StoragesHistory>(
-            StorageShardedKey {
-                address: ADDRESS,
-                sharded_key: ShardedKey { key: STORAGE, highest_block_number: u64::MAX },
-            },
-            BlockNumberList::new([10, 15]).unwrap(),
-        )
-        .unwrap();
-        tx.put::<tables::StoragesHistory>(
-            StorageShardedKey {
-                address: HIGHER_ADDRESS,
-                sharded_key: ShardedKey { key: STORAGE, highest_block_number: u64::MAX },
-            },
-            BlockNumberList::new([4]).unwrap(),
-        )
-        .unwrap();
-
-        let higher_entry_plain = StorageEntry { key: STORAGE, value: U256::from(1000) };
-        let higher_entry_at4 = StorageEntry { key: STORAGE, value: U256::from(0) };
-        let entry_plain = StorageEntry { key: STORAGE, value: U256::from(100) };
-        let entry_at15 = StorageEntry { key: STORAGE, value: U256::from(15) };
-        let entry_at10 = StorageEntry { key: STORAGE, value: U256::from(10) };
-        let entry_at7 = StorageEntry { key: STORAGE, value: U256::from(7) };
-        let entry_at3 = StorageEntry { key: STORAGE, value: U256::from(0) };
-
-        tx.put::<tables::StorageChangeSets>((3, ADDRESS).into(), entry_at3).unwrap();
-        tx.put::<tables::StorageChangeSets>((4, HIGHER_ADDRESS).into(), higher_entry_at4).unwrap();
-        tx.put::<tables::StorageChangeSets>((7, ADDRESS).into(), entry_at7).unwrap();
-        tx.put::<tables::StorageChangeSets>((10, ADDRESS).into(), entry_at10).unwrap();
-        tx.put::<tables::StorageChangeSets>((15, ADDRESS).into(), entry_at15).unwrap();
-
-        tx.put::<tables::PlainStorageState>(ADDRESS, entry_plain).unwrap();
-        tx.put::<tables::PlainStorageState>(HIGHER_ADDRESS, higher_entry_plain).unwrap();
-        tx.commit().unwrap();
-
-        let db = factory.provider().unwrap();
-
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 0).storage(ADDRESS, STORAGE),
-            Ok(None)
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 3).storage(ADDRESS, STORAGE),
-            Ok(Some(U256::ZERO))
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 4).storage(ADDRESS, STORAGE),
-            Ok(Some(expected_value)) if expected_value == entry_at7.value
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 7).storage(ADDRESS, STORAGE),
-            Ok(Some(expected_value)) if expected_value == entry_at7.value
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 9).storage(ADDRESS, STORAGE),
-            Ok(Some(expected_value)) if expected_value == entry_at10.value
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 10).storage(ADDRESS, STORAGE),
-            Ok(Some(expected_value)) if expected_value == entry_at10.value
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 11).storage(ADDRESS, STORAGE),
-            Ok(Some(expected_value)) if expected_value == entry_at15.value
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 16).storage(ADDRESS, STORAGE),
-            Ok(Some(expected_value)) if expected_value == entry_plain.value
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 1).storage(HIGHER_ADDRESS, STORAGE),
-            Ok(None)
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 1000).storage(HIGHER_ADDRESS, STORAGE),
-            Ok(Some(expected_value)) if expected_value == higher_entry_plain.value
-        ));
-    }
-
-    #[test]
-    #[cfg(all(unix, feature = "rocksdb"))]
-    fn history_provider_get_storage_hashed_state() {
-        use crate::BlockWriter;
-        use alloy_primitives::keccak256;
-        use reth_db_api::models::StorageSettings;
-        use reth_execution_types::ExecutionOutcome;
-        use reth_testing_utils::generators::{self, random_block_range, BlockRangeParams};
-        use revm_database::BundleState;
-        use std::collections::HashMap;
-
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
-
-        let slot = U256::from_be_bytes(*STORAGE);
-        let account: revm_state::AccountInfo =
-            Account { nonce: 1, balance: U256::from(1000), bytecode_hash: None }.into();
-        let higher_account: revm_state::AccountInfo =
-            Account { nonce: 1, balance: U256::from(2000), bytecode_hash: None }.into();
-
-        let mut rng = generators::rng();
-        let blocks = random_block_range(
-            &mut rng,
-            0..=15,
-            BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..1, ..Default::default() },
-        );
-
-        let mut addr_storage = HashMap::default();
-        addr_storage.insert(slot, (U256::ZERO, U256::from(100)));
-        let mut higher_storage = HashMap::default();
-        higher_storage.insert(slot, (U256::ZERO, U256::from(1000)));
-
-        type Revert = Vec<(Address, Option<Option<revm_state::AccountInfo>>, Vec<(U256, U256)>)>;
-        let mut reverts: Vec<Revert> = vec![Vec::new(); 16];
-
-        reverts[3] = vec![(ADDRESS, Some(Some(account.clone())), vec![(slot, U256::ZERO)])];
-        reverts[4] =
-            vec![(HIGHER_ADDRESS, Some(Some(higher_account.clone())), vec![(slot, U256::ZERO)])];
-        reverts[7] = vec![(ADDRESS, Some(Some(account.clone())), vec![(slot, U256::from(7))])];
-        reverts[10] = vec![(ADDRESS, Some(Some(account.clone())), vec![(slot, U256::from(10))])];
-        reverts[15] = vec![(ADDRESS, Some(Some(account.clone())), vec![(slot, U256::from(15))])];
-
-        let bundle = BundleState::new(
-            [
-                (ADDRESS, None, Some(account), addr_storage),
-                (HIGHER_ADDRESS, None, Some(higher_account), higher_storage),
-            ],
-            reverts,
-            [],
-        );
-
-        let provider_rw = factory.provider_rw().unwrap();
-        provider_rw
-            .append_blocks_with_state(
-                blocks
-                    .into_iter()
-                    .map(|b| b.try_recover().expect("failed to seal block with senders"))
-                    .collect(),
-                &ExecutionOutcome { bundle, first_block: 0, ..Default::default() },
-                Default::default(),
-            )
-            .unwrap();
-
-        let hashed_address = keccak256(ADDRESS);
-        let hashed_higher_address = keccak256(HIGHER_ADDRESS);
-        let hashed_storage = keccak256(STORAGE);
-
-        provider_rw
-            .tx_ref()
-            .put::<tables::HashedStorages>(
-                hashed_address,
-                StorageEntry { key: hashed_storage, value: U256::from(100) },
-            )
-            .unwrap();
-        provider_rw
-            .tx_ref()
-            .put::<tables::HashedStorages>(
-                hashed_higher_address,
-                StorageEntry { key: hashed_storage, value: U256::from(1000) },
-            )
-            .unwrap();
-        provider_rw
-            .tx_ref()
-            .put::<tables::HashedAccounts>(
-                hashed_address,
-                Account { nonce: 1, balance: U256::from(1000), bytecode_hash: None },
-            )
-            .unwrap();
-        provider_rw
-            .tx_ref()
-            .put::<tables::HashedAccounts>(
-                hashed_higher_address,
-                Account { nonce: 1, balance: U256::from(2000), bytecode_hash: None },
-            )
-            .unwrap();
-        provider_rw.commit().unwrap();
-
-        let db = factory.provider().unwrap();
-
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 0).storage(ADDRESS, STORAGE),
-            Ok(None)
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 3).storage(ADDRESS, STORAGE),
-            Ok(Some(U256::ZERO))
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 4).storage(ADDRESS, STORAGE),
-            Ok(Some(v)) if v == U256::from(7)
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 7).storage(ADDRESS, STORAGE),
-            Ok(Some(v)) if v == U256::from(7)
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 9).storage(ADDRESS, STORAGE),
-            Ok(Some(v)) if v == U256::from(10)
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 10).storage(ADDRESS, STORAGE),
-            Ok(Some(v)) if v == U256::from(10)
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 11).storage(ADDRESS, STORAGE),
-            Ok(Some(v)) if v == U256::from(15)
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 16).storage(ADDRESS, STORAGE),
-            Ok(Some(v)) if v == U256::from(100)
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 1).storage(HIGHER_ADDRESS, STORAGE),
-            Ok(None)
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 1000).storage(HIGHER_ADDRESS, STORAGE),
-            Ok(Some(v)) if v == U256::from(1000)
-        ));
-    }
-
     #[test]
     fn test_needs_prev_shard_check() {
         // Only needs check when rank == 0 and found_block != block_number
@@ -1273,105 +951,4 @@ mod tests {
         assert!(!needs_prev_shard_check(0, Some(5), 5)); // found_block == block_number
         assert!(!needs_prev_shard_check(1, Some(10), 5)); // rank > 0
     }
-
-    #[test]
-    fn test_historical_storage_by_hashed_key_unsupported_in_v1() {
-        let factory = create_test_provider_factory();
-        assert!(!factory.provider().unwrap().cached_storage_settings().use_hashed_state());
-
-        let db = factory.provider().unwrap();
-        let provider = HistoricalStateProviderRef::new(&db, 1);
-
-        assert!(matches!(
-            provider.storage_by_hashed_key(ADDRESS, STORAGE),
-            Err(ProviderError::UnsupportedProvider)
-        ));
-    }
-
-    #[test]
-    #[cfg(all(unix, feature = "rocksdb"))]
-    fn test_historical_storage_by_hashed_key_v2() {
-        use crate::BlockWriter;
-        use alloy_primitives::keccak256;
-        use reth_db_api::models::StorageSettings;
-        use reth_execution_types::ExecutionOutcome;
-        use reth_testing_utils::generators::{self, random_block_range, BlockRangeParams};
-        use revm_database::BundleState;
-        use std::collections::HashMap;
-
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
-
-        let slot = U256::from_be_bytes(*STORAGE);
-        let hashed_storage = keccak256(STORAGE);
-        let account: revm_state::AccountInfo =
-            Account { nonce: 1, balance: U256::from(1000), bytecode_hash: None }.into();
-
-        let mut rng = generators::rng();
-        let blocks = random_block_range(
-            &mut rng,
-            0..=5,
-            BlockRangeParams { parent: Some(B256::ZERO), tx_count: 0..1, ..Default::default() },
-        );
-
-        let mut addr_storage = HashMap::default();
-        addr_storage.insert(slot, (U256::ZERO, U256::from(100)));
-
-        type Revert = Vec<(Address, Option<Option<revm_state::AccountInfo>>, Vec<(U256, U256)>)>;
-        let mut reverts: Vec<Revert> = vec![Vec::new(); 6];
-        reverts[3] = vec![(ADDRESS, Some(Some(account.clone())), vec![(slot, U256::ZERO)])];
-        reverts[5] = vec![(ADDRESS, Some(Some(account.clone())), vec![(slot, U256::from(50))])];
-
-        let bundle = BundleState::new([(ADDRESS, None, Some(account), addr_storage)], reverts, []);
-
-        let provider_rw = factory.provider_rw().unwrap();
-        provider_rw
-            .append_blocks_with_state(
-                blocks
-                    .into_iter()
-                    .map(|b| b.try_recover().expect("failed to seal block with senders"))
-                    .collect(),
-                &ExecutionOutcome { bundle, first_block: 0, ..Default::default() },
-                Default::default(),
-            )
-            .unwrap();
-
-        let hashed_address = keccak256(ADDRESS);
-
-        provider_rw
-            .tx_ref()
-            .put::<tables::HashedStorages>(
-                hashed_address,
-                StorageEntry { key: hashed_storage, value: U256::from(100) },
-            )
-            .unwrap();
-        provider_rw
-            .tx_ref()
-            .put::<tables::HashedAccounts>(
-                hashed_address,
-                Account { nonce: 1, balance: U256::from(1000), bytecode_hash: None },
-            )
-            .unwrap();
-        provider_rw.commit().unwrap();
-
-        let db = factory.provider().unwrap();
-
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 0).storage_by_hashed_key(ADDRESS, hashed_storage),
-            Ok(None)
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 3).storage_by_hashed_key(ADDRESS, hashed_storage),
-            Ok(Some(U256::ZERO))
-        ));
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 4).storage_by_hashed_key(ADDRESS, hashed_storage),
-            Ok(Some(v)) if v == U256::from(50)
-        ));
-
-        assert!(matches!(
-            HistoricalStateProviderRef::new(&db, 4).storage_by_hashed_key(ADDRESS, STORAGE),
-            Ok(None | Some(U256::ZERO))
-        ));
-    }
 }

crates/storage/provider/src/providers/state/latest.rs

@@ -4,9 +4,7 @@ use crate::{
 use alloy_primitives::{Address, BlockNumber, Bytes, StorageKey, StorageValue, B256};
 use reth_db_api::{cursor::DbDupCursorRO, tables, transaction::DbTx};
 use reth_primitives_traits::{Account, Bytecode};
-use reth_storage_api::{
-    BytecodeReader, DBProvider, StateProofProvider, StorageRootProvider, StorageSettingsCache,
-};
+use reth_storage_api::{BytecodeReader, DBProvider, StateProofProvider, StorageRootProvider};
 use reth_storage_errors::provider::{ProviderError, ProviderResult};
 use reth_trie::{
     proof::{Proof, StorageProof},
@@ -35,33 +33,12 @@ impl<'b, Provider: DBProvider> LatestStateProviderRef<'b, Provider> {
     fn tx(&self) -> &Provider::Tx {
         self.0.tx_ref()
     }
-
-    fn hashed_storage_lookup(
-        &self,
-        hashed_address: B256,
-        hashed_slot: StorageKey,
-    ) -> ProviderResult<Option<StorageValue>> {
-        let mut cursor = self.tx().cursor_dup_read::<tables::HashedStorages>()?;
-        Ok(cursor
-            .seek_by_key_subkey(hashed_address, hashed_slot)?
-            .filter(|e| e.key == hashed_slot)
-            .map(|e| e.value))
-    }
 }
 
-impl<Provider: DBProvider + StorageSettingsCache> AccountReader
-    for LatestStateProviderRef<'_, Provider>
-{
+impl<Provider: DBProvider> AccountReader for LatestStateProviderRef<'_, Provider> {
     /// Get basic account information.
     fn basic_account(&self, address: &Address) -> ProviderResult<Option<Account>> {
-        if self.0.cached_storage_settings().use_hashed_state() {
-            let hashed_address = alloy_primitives::keccak256(address);
-            self.tx()
-                .get_by_encoded_key::<tables::HashedAccounts>(&hashed_address)
-                .map_err(Into::into)
-        } else {
-            self.tx().get_by_encoded_key::<tables::PlainAccountState>(address).map_err(Into::into)
-        }
+        self.tx().get_by_encoded_key::<tables::PlainAccountState>(address).map_err(Into::into)
     }
 }
 
@@ -171,41 +148,22 @@ impl<Provider: DBProvider> HashedPostStateProvider for LatestStateProviderRef<'_
     }
 }
 
-impl<Provider: DBProvider + BlockHashReader + StorageSettingsCache> StateProvider
+impl<Provider: DBProvider + BlockHashReader> StateProvider
     for LatestStateProviderRef<'_, Provider>
 {
-    /// Get storage by plain (unhashed) storage key slot.
+    /// Get storage.
     fn storage(
         &self,
         account: Address,
         storage_key: StorageKey,
     ) -> ProviderResult<Option<StorageValue>> {
-        if self.0.cached_storage_settings().use_hashed_state() {
-            self.hashed_storage_lookup(
-                alloy_primitives::keccak256(account),
-                alloy_primitives::keccak256(storage_key),
-            )
-        } else {
-            let mut cursor = self.tx().cursor_dup_read::<tables::PlainStorageState>()?;
-            if let Some(entry) = cursor.seek_by_key_subkey(account, storage_key)? &&
-                entry.key == storage_key
-            {
-                return Ok(Some(entry.value));
-            }
-            Ok(None)
-        }
-    }
-
-    fn storage_by_hashed_key(
-        &self,
-        address: Address,
-        hashed_storage_key: StorageKey,
-    ) -> ProviderResult<Option<StorageValue>> {
-        if self.0.cached_storage_settings().use_hashed_state() {
-            self.hashed_storage_lookup(alloy_primitives::keccak256(address), hashed_storage_key)
-        } else {
-            Err(ProviderError::UnsupportedProvider)
+        let mut cursor = self.tx().cursor_dup_read::<tables::PlainStorageState>()?;
+        if let Some(entry) = cursor.seek_by_key_subkey(account, storage_key)? &&
+            entry.key == storage_key
+        {
+            return Ok(Some(entry.value))
         }
+        Ok(None)
     }
 }
 
@@ -236,181 +194,15 @@ impl<Provider: DBProvider> LatestStateProvider<Provider> {
 }
 
 // Delegates all provider impls to [LatestStateProviderRef]
-reth_storage_api::macros::delegate_provider_impls!(LatestStateProvider<Provider> where [Provider: DBProvider + BlockHashReader + StorageSettingsCache]);
+reth_storage_api::macros::delegate_provider_impls!(LatestStateProvider<Provider> where [Provider: DBProvider + BlockHashReader ]);
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::test_utils::create_test_provider_factory;
-    use alloy_primitives::{address, b256, keccak256, U256};
-    use reth_db_api::{
-        models::StorageSettings,
-        tables,
-        transaction::{DbTx, DbTxMut},
-    };
-    use reth_primitives_traits::StorageEntry;
-    use reth_storage_api::StorageSettingsCache;
-    use reth_storage_errors::provider::ProviderError;
 
     const fn assert_state_provider<T: StateProvider>() {}
     #[expect(dead_code)]
-    const fn assert_latest_state_provider<
-        T: DBProvider + BlockHashReader + StorageSettingsCache,
-    >() {
+    const fn assert_latest_state_provider<T: DBProvider + BlockHashReader>() {
         assert_state_provider::<LatestStateProvider<T>>();
     }
-
-    #[test]
-    fn test_latest_storage_hashed_state() {
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
-
-        let address = address!("0x0000000000000000000000000000000000000001");
-        let slot = b256!("0x0000000000000000000000000000000000000000000000000000000000000001");
-
-        let hashed_address = keccak256(address);
-        let hashed_slot = keccak256(slot);
-
-        let tx = factory.provider_rw().unwrap().into_tx();
-        tx.put::<tables::HashedStorages>(
-            hashed_address,
-            StorageEntry { key: hashed_slot, value: U256::from(42) },
-        )
-        .unwrap();
-        tx.commit().unwrap();
-
-        let db = factory.provider().unwrap();
-        let provider_ref = LatestStateProviderRef::new(&db);
-
-        assert_eq!(provider_ref.storage(address, slot).unwrap(), Some(U256::from(42)));
-
-        let other_address = address!("0x0000000000000000000000000000000000000099");
-        let other_slot =
-            b256!("0x0000000000000000000000000000000000000000000000000000000000000099");
-        assert_eq!(provider_ref.storage(other_address, other_slot).unwrap(), None);
-
-        let tx = factory.provider_rw().unwrap().into_tx();
-        let plain_address = address!("0x0000000000000000000000000000000000000002");
-        let plain_slot =
-            b256!("0x0000000000000000000000000000000000000000000000000000000000000002");
-        tx.put::<tables::PlainStorageState>(
-            plain_address,
-            StorageEntry { key: plain_slot, value: U256::from(99) },
-        )
-        .unwrap();
-        tx.commit().unwrap();
-
-        let db = factory.provider().unwrap();
-        let provider_ref = LatestStateProviderRef::new(&db);
-        assert_eq!(provider_ref.storage(plain_address, plain_slot).unwrap(), None);
-    }
-
-    #[test]
-    fn test_latest_storage_hashed_state_returns_none_for_missing() {
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
-
-        let address = address!("0x0000000000000000000000000000000000000001");
-        let slot = b256!("0x0000000000000000000000000000000000000000000000000000000000000001");
-
-        let db = factory.provider().unwrap();
-        let provider_ref = LatestStateProviderRef::new(&db);
-        assert_eq!(provider_ref.storage(address, slot).unwrap(), None);
-    }
-
-    #[test]
-    fn test_latest_storage_legacy() {
-        let factory = create_test_provider_factory();
-        assert!(!factory.provider().unwrap().cached_storage_settings().use_hashed_state());
-
-        let address = address!("0x0000000000000000000000000000000000000001");
-        let slot = b256!("0x0000000000000000000000000000000000000000000000000000000000000005");
-
-        let tx = factory.provider_rw().unwrap().into_tx();
-        tx.put::<tables::PlainStorageState>(
-            address,
-            StorageEntry { key: slot, value: U256::from(42) },
-        )
-        .unwrap();
-        tx.commit().unwrap();
-
-        let db = factory.provider().unwrap();
-        let provider_ref = LatestStateProviderRef::new(&db);
-
-        assert_eq!(provider_ref.storage(address, slot).unwrap(), Some(U256::from(42)));
-
-        let other_slot =
-            b256!("0x0000000000000000000000000000000000000000000000000000000000000099");
-        assert_eq!(provider_ref.storage(address, other_slot).unwrap(), None);
-    }
-
-    #[test]
-    fn test_latest_storage_legacy_does_not_read_hashed() {
-        let factory = create_test_provider_factory();
-        assert!(!factory.provider().unwrap().cached_storage_settings().use_hashed_state());
-
-        let address = address!("0x0000000000000000000000000000000000000001");
-        let slot = b256!("0x0000000000000000000000000000000000000000000000000000000000000005");
-        let hashed_address = keccak256(address);
-        let hashed_slot = keccak256(slot);
-
-        let tx = factory.provider_rw().unwrap().into_tx();
-        tx.put::<tables::HashedStorages>(
-            hashed_address,
-            StorageEntry { key: hashed_slot, value: U256::from(42) },
-        )
-        .unwrap();
-        tx.commit().unwrap();
-
-        let db = factory.provider().unwrap();
-        let provider_ref = LatestStateProviderRef::new(&db);
-        assert_eq!(provider_ref.storage(address, slot).unwrap(), None);
-    }
-
-    #[test]
-    fn test_latest_storage_by_hashed_key_v2() {
-        let factory = create_test_provider_factory();
-        factory.set_storage_settings_cache(StorageSettings::v2());
-
-        let address = address!("0x0000000000000000000000000000000000000001");
-        let slot = b256!("0x0000000000000000000000000000000000000000000000000000000000000001");
-
-        let hashed_address = keccak256(address);
-        let hashed_slot = keccak256(slot);
-
-        let tx = factory.provider_rw().unwrap().into_tx();
-        tx.put::<tables::HashedStorages>(
-            hashed_address,
-            StorageEntry { key: hashed_slot, value: U256::from(42) },
-        )
-        .unwrap();
-        tx.commit().unwrap();
-
-        let db = factory.provider().unwrap();
-        let provider_ref = LatestStateProviderRef::new(&db);
-
-        assert_eq!(
-            provider_ref.storage_by_hashed_key(address, hashed_slot).unwrap(),
-            Some(U256::from(42))
-        );
-
-        assert_eq!(provider_ref.storage_by_hashed_key(address, slot).unwrap(), None);
-    }
-
-    #[test]
-    fn test_latest_storage_by_hashed_key_unsupported_in_v1() {
-        let factory = create_test_provider_factory();
-        assert!(!factory.provider().unwrap().cached_storage_settings().use_hashed_state());
-
-        let address = address!("0x0000000000000000000000000000000000000001");
-        let slot = b256!("0x0000000000000000000000000000000000000000000000000000000000000001");
-
-        let db = factory.provider().unwrap();
-        let provider_ref = LatestStateProviderRef::new(&db);
-
-        assert!(matches!(
-            provider_ref.storage_by_hashed_key(address, slot),
-            Err(ProviderError::UnsupportedProvider)
-        ));
-    }
 }

crates/storage/provider/src/providers/state/overlay.rs

@@ -10,15 +10,17 @@ use reth_stages_types::StageId;
 use reth_storage_api::{
     BlockNumReader, ChangeSetReader, DBProvider, DatabaseProviderFactory,
     DatabaseProviderROFactory, PruneCheckpointReader, StageCheckpointReader,
-    StorageChangeSetReader, StorageSettingsCache,
+    StorageChangeSetReader,
 };
 use reth_trie::{
     hashed_cursor::{HashedCursorFactory, HashedPostStateCursorFactory},
     trie_cursor::{InMemoryTrieCursorFactory, TrieCursorFactory},
     updates::TrieUpdatesSorted,
-    HashedPostStateSorted,
+    HashedPostStateSorted, KeccakKeyHasher,
+};
+use reth_trie_db::{
+    ChangesetCache, DatabaseHashedCursorFactory, DatabaseHashedPostState, DatabaseTrieCursorFactory,
 };
-use reth_trie_db::{ChangesetCache, DatabaseHashedCursorFactory, DatabaseTrieCursorFactory};
 use std::{
     sync::Arc,
     time::{Duration, Instant},
@@ -196,8 +198,7 @@ where
         + ChangeSetReader
         + StorageChangeSetReader
         + DBProvider
-        + BlockNumReader
-        + StorageSettingsCache,
+        + BlockNumReader,
 {
     /// Resolves the effective overlay (trie updates, hashed state).
     ///
@@ -335,7 +336,10 @@ where
                 let _guard = debug_span!(target: "providers::state::overlay", "Retrieving hashed state reverts").entered();
 
                 let start = Instant::now();
-                let res = reth_trie_db::from_reverts_auto(provider, from_block + 1..)?;
+                let res = HashedPostStateSorted::from_reverts::<KeccakKeyHasher>(
+                    provider,
+                    from_block + 1..,
+                )?;
                 retrieve_hashed_state_reverts_duration = start.elapsed();
                 res
             };
@@ -446,8 +450,7 @@ where
         + PruneCheckpointReader
         + BlockNumReader
         + ChangeSetReader
-        + StorageChangeSetReader
-        + StorageSettingsCache,
+        + StorageChangeSetReader,
 {
     type Provider = OverlayStateProvider<F::Provider>;
 

crates/storage/provider/src/providers/static_file/manager.rs

@@ -34,7 +34,7 @@ use reth_nippy_jar::{NippyJar, NippyJarChecker, CONFIG_FILE_EXTENSION};
 use reth_node_types::NodePrimitives;
 use reth_primitives_traits::{
     dashmap::DashMap, AlloyBlockHeader as _, BlockBody as _, RecoveredBlock, SealedHeader,
-    SignedTransaction, StorageSlotKey,
+    SignedTransaction, StorageEntry,
 };
 use reth_prune_types::PruneSegment;
 use reth_stages_types::PipelineTarget;
@@ -43,7 +43,7 @@ use reth_static_file_types::{
     SegmentRangeInclusive, StaticFileMap, StaticFileSegment, DEFAULT_BLOCKS_PER_STATIC_FILE,
 };
 use reth_storage_api::{
-    BlockBodyIndicesProvider, ChangeSetReader, ChangesetEntry, DBProvider, PruneCheckpointReader,
+    BlockBodyIndicesProvider, ChangeSetReader, DBProvider, PruneCheckpointReader,
     StorageChangeSetReader, StorageSettingsCache,
 };
 use reth_storage_errors::provider::{ProviderError, ProviderResult, StaticFileWriterError};
@@ -643,7 +643,7 @@ impl<N: NodePrimitives> StaticFileProvider<N> {
                     revert.storage_revert.into_iter().map(move |(key, revert_to_slot)| {
                         StorageBeforeTx {
                             address: revert.address,
-                            key: StorageSlotKey::from_u256(key).to_hashed(),
+                            key: B256::new(key.to_be_bytes()),
                             value: revert_to_slot.to_previous_value(),
                         }
                     })
@@ -2520,7 +2520,7 @@ impl<N: NodePrimitives> StorageChangeSetReader for StaticFileProvider<N> {
     fn storage_changeset(
         &self,
         block_number: BlockNumber,
-    ) -> ProviderResult<Vec<(BlockNumberAddress, ChangesetEntry)>> {
+    ) -> ProviderResult<Vec<(BlockNumberAddress, StorageEntry)>> {
         let provider = match self.get_segment_provider_for_block(
             StaticFileSegment::StorageChangeSets,
             block_number,
@@ -2538,10 +2538,7 @@ impl<N: NodePrimitives> StorageChangeSetReader for StaticFileProvider<N> {
             for i in offset.changeset_range() {
                 if let Some(change) = cursor.get_one::<StorageChangesetMask>(i.into())? {
                     let block_address = BlockNumberAddress((block_number, change.address));
-                    let entry = ChangesetEntry {
-                        key: StorageSlotKey::hashed(change.key),
-                        value: change.value,
-                    };
+                    let entry = StorageEntry { key: change.key, value: change.value };
                     changeset.push((block_address, entry));
                 }
             }
@@ -2556,7 +2553,7 @@ impl<N: NodePrimitives> StorageChangeSetReader for StaticFileProvider<N> {
         block_number: BlockNumber,
         address: Address,
         storage_key: B256,
-    ) -> ProviderResult<Option<ChangesetEntry>> {
+    ) -> ProviderResult<Option<StorageEntry>> {
         let provider = match self.get_segment_provider_for_block(
             StaticFileSegment::StorageChangeSets,
             block_number,
@@ -2605,10 +2602,7 @@ impl<N: NodePrimitives> StorageChangeSetReader for StaticFileProvider<N> {
                 .get_one::<StorageChangesetMask>(low.into())?
                 .filter(|change| change.address == address && change.key == storage_key)
         {
-            return Ok(Some(ChangesetEntry {
-                key: StorageSlotKey::hashed(change.key),
-                value: change.value,
-            }));
+            return Ok(Some(StorageEntry { key: change.key, value: change.value }));
         }
 
         Ok(None)
@@ -2617,7 +2611,7 @@ impl<N: NodePrimitives> StorageChangeSetReader for StaticFileProvider<N> {
     fn storage_changesets_range(
         &self,
         range: impl RangeBounds<BlockNumber>,
-    ) -> ProviderResult<Vec<(BlockNumberAddress, ChangesetEntry)>> {
+    ) -> ProviderResult<Vec<(BlockNumberAddress, StorageEntry)>> {
         let range = self.bound_range(range, StaticFileSegment::StorageChangeSets);
         self.walk_storage_changeset_range(range).collect()
     }

crates/storage/provider/src/providers/static_file/mod.rs

@@ -1170,13 +1170,13 @@ mod tests {
             let result = sf_rw.get_storage_before_block(0, test_address, test_key).unwrap();
             assert!(result.is_some());
             let entry = result.unwrap();
-            assert_eq!(entry.key.as_b256(), test_key);
+            assert_eq!(entry.key, test_key);
             assert_eq!(entry.value, U256::ZERO);
 
             let result = sf_rw.get_storage_before_block(2, test_address, test_key).unwrap();
             assert!(result.is_some());
             let entry = result.unwrap();
-            assert_eq!(entry.key.as_b256(), test_key);
+            assert_eq!(entry.key, test_key);
             assert_eq!(entry.value, U256::from(9));
 
             let result = sf_rw.get_storage_before_block(1, test_address, test_key).unwrap();
@@ -1188,7 +1188,7 @@ mod tests {
             let result = sf_rw.get_storage_before_block(1, other_address, other_key).unwrap();
             assert!(result.is_some());
             let entry = result.unwrap();
-            assert_eq!(entry.key.as_b256(), other_key);
+            assert_eq!(entry.key, other_key);
         }
     }
 
@@ -1334,20 +1334,20 @@ mod tests {
             let result = sf_rw.get_storage_before_block(block_num, address, keys[0]).unwrap();
             assert!(result.is_some());
             let entry = result.unwrap();
-            assert_eq!(entry.key.as_b256(), keys[0]);
+            assert_eq!(entry.key, keys[0]);
             assert_eq!(entry.value, U256::from(0));
 
             let result =
                 sf_rw.get_storage_before_block(block_num, address, keys[num_slots - 1]).unwrap();
             assert!(result.is_some());
             let entry = result.unwrap();
-            assert_eq!(entry.key.as_b256(), keys[num_slots - 1]);
+            assert_eq!(entry.key, keys[num_slots - 1]);
 
             let mid = num_slots / 2;
             let result = sf_rw.get_storage_before_block(block_num, address, keys[mid]).unwrap();
             assert!(result.is_some());
             let entry = result.unwrap();
-            assert_eq!(entry.key.as_b256(), keys[mid]);
+            assert_eq!(entry.key, keys[mid]);
 
             let missing_key = B256::with_last_byte(255);
             let result = sf_rw.get_storage_before_block(block_num, address, missing_key).unwrap();
@@ -1356,7 +1356,7 @@ mod tests {
             for i in (0..num_slots).step_by(10) {
                 let result = sf_rw.get_storage_before_block(block_num, address, keys[i]).unwrap();
                 assert!(result.is_some());
-                assert_eq!(result.unwrap().key.as_b256(), keys[i]);
+                assert_eq!(result.unwrap().key, keys[i]);
             }
         }
     }

crates/storage/provider/src/test_utils/mock.rs

@@ -22,20 +22,20 @@ use reth_chainspec::{ChainInfo, EthChainSpec};
 use reth_db::transaction::DbTx;
 use reth_db_api::{
     mock::{DatabaseMock, TxMock},
-    models::{AccountBeforeTx, StorageSettings, StoredBlockBodyIndices},
+    models::{AccountBeforeTx, StoredBlockBodyIndices},
 };
 use reth_ethereum_primitives::EthPrimitives;
 use reth_execution_types::ExecutionOutcome;
 use reth_primitives_traits::{
     Account, Block, BlockBody, Bytecode, GotExpected, NodePrimitives, RecoveredBlock, SealedHeader,
-    SignerRecoverable,
+    SignerRecoverable, StorageEntry,
 };
 use reth_prune_types::{PruneCheckpoint, PruneModes, PruneSegment};
 use reth_stages_types::{StageCheckpoint, StageId};
 use reth_storage_api::{
-    BlockBodyIndicesProvider, BytecodeReader, ChangesetEntry, DBProvider, DatabaseProviderFactory,
+    BlockBodyIndicesProvider, BytecodeReader, DBProvider, DatabaseProviderFactory,
     HashedPostStateProvider, NodePrimitivesProvider, StageCheckpointReader, StateProofProvider,
-    StorageChangeSetReader, StorageRootProvider, StorageSettingsCache,
+    StorageChangeSetReader, StorageRootProvider,
 };
 use reth_storage_errors::provider::{ConsistentViewError, ProviderError, ProviderResult};
 use reth_trie::{
@@ -883,14 +883,6 @@ where
         let lock = self.accounts.lock();
         Ok(lock.get(&account).and_then(|account| account.storage.get(&storage_key)).copied())
     }
-
-    fn storage_by_hashed_key(
-        &self,
-        _address: Address,
-        _hashed_storage_key: StorageKey,
-    ) -> ProviderResult<Option<StorageValue>> {
-        Ok(None)
-    }
 }
 
 impl<T, ChainSpec> BytecodeReader for MockEthProvider<T, ChainSpec>
@@ -911,16 +903,6 @@ where
     }
 }
 
-impl<T: NodePrimitives, ChainSpec: Send + Sync> StorageSettingsCache
-    for MockEthProvider<T, ChainSpec>
-{
-    fn cached_storage_settings(&self) -> StorageSettings {
-        StorageSettings::default()
-    }
-
-    fn set_storage_settings_cache(&self, _settings: StorageSettings) {}
-}
-
 impl<T: NodePrimitives, ChainSpec: EthChainSpec + Send + Sync + 'static> StateProviderFactory
     for MockEthProvider<T, ChainSpec>
 {
@@ -1029,7 +1011,7 @@ impl<T: NodePrimitives, ChainSpec: Send + Sync> StorageChangeSetReader
     fn storage_changeset(
         &self,
         _block_number: BlockNumber,
-    ) -> ProviderResult<Vec<(reth_db_api::models::BlockNumberAddress, ChangesetEntry)>> {
+    ) -> ProviderResult<Vec<(reth_db_api::models::BlockNumberAddress, StorageEntry)>> {
         Ok(Vec::default())
     }
 
@@ -1038,14 +1020,14 @@ impl<T: NodePrimitives, ChainSpec: Send + Sync> StorageChangeSetReader
         _block_number: BlockNumber,
         _address: Address,
         _storage_key: B256,
-    ) -> ProviderResult<Option<ChangesetEntry>> {
+    ) -> ProviderResult<Option<StorageEntry>> {
         Ok(None)
     }
 
     fn storage_changesets_range(
         &self,
         _range: impl RangeBounds<BlockNumber>,
-    ) -> ProviderResult<Vec<(reth_db_api::models::BlockNumberAddress, ChangesetEntry)>> {
+    ) -> ProviderResult<Vec<(reth_db_api::models::BlockNumberAddress, StorageEntry)>> {
         Ok(Vec::default())
     }