Cliff/triedb

Cargo.toml

@@ -591,7 +591,8 @@ mini-moka = "0.10"
 tar-no-std = { version = "0.3.2", default-features = false }
 miniz_oxide = { version = "0.8.4", default-features = false }
 chrono = "0.4.41"
-
+fixed-cache = "0.1"
+rapidhash = "4.2.0"
 # metrics
 metrics = "0.24.0"
 metrics-derive = "0.1"
@@ -670,6 +671,7 @@ proptest = "1.7"
 proptest-derive = "0.5"
 similar-asserts = { version = "1.5.0", features = ["serde"] }
 tempfile = "3.20"
+tempdir = "0.3.7"
 test-fuzz = "7"
 rstest = "0.24.0"
 test-case = "3"
@@ -738,6 +740,8 @@ vergen-git2 = "1.0.5"
 xlayer-db = { path = "crates/xlayer/db" }
 xlayer-rpc = { path = "crates/xlayer/rpc" }
 
+triedb ={git="https://github.com/base/triedb.git"}
+
 # [patch.crates-io]
 # alloy-consensus = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }
 # alloy-contract = { git = "https://github.com/alloy-rs/alloy", rev = "3049f232fbb44d1909883e154eb38ec5962f53a3" }

crates/chain-state/Cargo.toml

@@ -28,6 +28,7 @@ alloy-primitives = { workspace = true, features = ["std"] }
 alloy-consensus.workspace = true
 revm-database.workspace = true
 revm-state = { workspace = true, optional = true }
+triedb.workspace=true
 
 # async
 tokio = { workspace = true, default-features = false, features = ["sync", "macros"] }

crates/chain-state/src/memory_overlay.rs

@@ -4,8 +4,8 @@ use alloy_primitives::{keccak256, Address, BlockNumber, Bytes, StorageKey, Stora
 use reth_errors::ProviderResult;
 use reth_primitives_traits::{Account, Bytecode, NodePrimitives};
 use reth_storage_api::{
-    AccountReader, BlockHashReader, BytecodeReader, HashedPostStateProvider, StateProofProvider,
-    StateProvider, StateRootProvider, StorageRootProvider,
+    AccountReader, BlockHashReader, BytecodeReader, HashedPostStateProvider, PlainPostState,
+    StateProofProvider, StateProvider, StateRootProvider, StorageRootProvider,
 };
 use reth_trie::{
     updates::TrieUpdates, AccountProof, HashedPostState, HashedStorage, MultiProof,
@@ -147,6 +147,45 @@ impl<N: NodePrimitives> StateRootProvider for MemoryOverlayStateProviderRef<'_,
         input.prepend_self(self.trie_input().clone());
         self.historical.state_root_from_nodes_with_updates(input)
     }
+
+    fn state_root_with_updates_triedb(
+        &self,
+        plain_state: PlainPostState,
+    ) -> ProviderResult<(B256, TrieUpdates)> {
+        use std::collections::HashMap;
+        let mut cached_plain_state = PlainPostState::default();
+
+        for block in &self.in_memory {
+            let bundle_state = &block.execution_output.bundle;
+            for (address, bundle_account) in bundle_state.state() {
+                let account = if bundle_account.was_destroyed() || bundle_account.info.is_none() {
+                    None
+                } else {
+                    bundle_account.info.as_ref().map(|info| reth_primitives_traits::Account::from(info))
+                };
+                cached_plain_state.accounts.insert(*address, account);
+
+                let storage_map = cached_plain_state.storages.entry(*address).or_insert_with(HashMap::new);
+                for (slot, storage_slot) in &bundle_account.storage {
+                    let slot_b256 = B256::from_slice(&slot.to_be_bytes::<32>());
+                    storage_map.insert(slot_b256, storage_slot.present_value);
+                }
+            }
+        }
+
+        let mut merged_state = cached_plain_state;
+
+        for (address, account) in plain_state.accounts {
+            merged_state.accounts.insert(address, account);
+        }
+
+        for (address, storage) in plain_state.storages {
+            let merged_storage = merged_state.storages.entry(address).or_insert_with(HashMap::new);
+            merged_storage.extend(storage);
+        }
+
+        self.historical.state_root_with_updates_triedb(merged_state)
+    }
 }
 
 impl<N: NodePrimitives> StorageRootProvider for MemoryOverlayStateProviderRef<'_, N> {

crates/cli/commands/src/common.rs

@@ -21,7 +21,7 @@ use reth_node_core::{
     dirs::{ChainPath, DataDirPath},
 };
 use reth_provider::{
-    providers::{BlockchainProvider, NodeTypesForProvider, StaticFileProvider},
+    providers::{BlockchainProvider, NodeTypesForProvider, StaticFileProvider, triedb::TriedbProvider},
     ProviderFactory, StaticFileProviderFactory,
 };
 use reth_stages::{sets::DefaultStages, Pipeline, PipelineTarget};
@@ -103,7 +103,8 @@ impl<C: ChainSpecParser> EnvironmentArgs<C> {
             ),
         };
 
-        let provider_factory = self.create_provider_factory(&config, db, sfp)?;
+        let triedb_provider = TriedbProvider::new(data_dir.triedb());
+        let provider_factory = self.create_provider_factory(&config, db, sfp, triedb_provider)?;
         if access.is_read_write() {
             debug!(target: "reth::cli", chain=%self.chain.chain(), genesis=?self.chain.genesis_hash(), "Initializing genesis");
             init_genesis(&provider_factory)?;
@@ -122,16 +123,19 @@ impl<C: ChainSpecParser> EnvironmentArgs<C> {
         config: &Config,
         db: Arc<DatabaseEnv>,
         static_file_provider: StaticFileProvider<N::Primitives>,
+        triedb_provider: TriedbProvider
     ) -> eyre::Result<ProviderFactory<NodeTypesWithDBAdapter<N, Arc<DatabaseEnv>>>>
     where
         C: ChainSpecParser<ChainSpec = N::ChainSpec>,
     {
         let has_receipt_pruning = config.prune.has_receipts_pruning();
         let prune_modes = config.prune.segments.clone();
+
         let factory = ProviderFactory::<NodeTypesWithDBAdapter<N, Arc<DatabaseEnv>>>::new(
             db,
             self.chain.clone(),
             static_file_provider,
+            Arc::new(triedb_provider)
         )
         .with_prune_modes(prune_modes.clone())
         .with_genesis_block_number(self.chain.genesis().number.unwrap());

crates/cli/commands/src/stage/dump/execution.rs

@@ -15,6 +15,7 @@ use reth_provider::{
 use reth_stages::{stages::ExecutionStage, Stage, StageCheckpoint, UnwindInput};
 use std::sync::Arc;
 use tracing::info;
+use reth_provider::providers::triedb::TriedbProvider;
 
 pub(crate) async fn dump_execution_stage<N, E, C>(
     db_tool: &DbTool<N>,
@@ -42,6 +43,7 @@ where
                 Arc::new(output_db),
                 db_tool.chain(),
                 StaticFileProvider::read_write(output_datadir.static_files())?,
+                Arc::new(TriedbProvider::new(output_datadir.triedb())),
             ),
             to,
             from,

crates/cli/commands/src/stage/dump/hashing_account.rs

@@ -12,6 +12,7 @@ use reth_provider::{
 use reth_stages::{stages::AccountHashingStage, Stage, StageCheckpoint, UnwindInput};
 use std::sync::Arc;
 use tracing::info;
+use reth_provider::providers::triedb::TriedbProvider;
 
 pub(crate) async fn dump_hashing_account_stage<N: ProviderNodeTypes<DB = Arc<DatabaseEnv>>>(
     db_tool: &DbTool<N>,
@@ -39,6 +40,7 @@ pub(crate) async fn dump_hashing_account_stage<N: ProviderNodeTypes<DB = Arc<Dat
                 Arc::new(output_db),
                 db_tool.chain(),
                 StaticFileProvider::read_write(output_datadir.static_files())?,
+                Arc::new(TriedbProvider::new(output_datadir.triedb())),
             ),
             to,
             from,

crates/cli/commands/src/stage/dump/hashing_storage.rs

@@ -11,6 +11,7 @@ use reth_provider::{
 use reth_stages::{stages::StorageHashingStage, Stage, StageCheckpoint, UnwindInput};
 use std::sync::Arc;
 use tracing::info;
+use reth_provider::providers::triedb::TriedbProvider;
 
 pub(crate) async fn dump_hashing_storage_stage<N: ProviderNodeTypes<DB = Arc<DatabaseEnv>>>(
     db_tool: &DbTool<N>,
@@ -29,6 +30,7 @@ pub(crate) async fn dump_hashing_storage_stage<N: ProviderNodeTypes<DB = Arc<Dat
                 Arc::new(output_db),
                 db_tool.chain(),
                 StaticFileProvider::read_write(output_datadir.static_files())?,
+                Arc::new(TriedbProvider::new(output_datadir.triedb())),
             ),
             to,
             from,

crates/cli/commands/src/stage/dump/merkle.rs

@@ -23,6 +23,7 @@ use reth_stages::{
     ExecutionStageThresholds, Stage, StageCheckpoint, UnwindInput,
 };
 use tracing::info;
+use reth_provider::providers::triedb::TriedbProvider;
 
 pub(crate) async fn dump_merkle_stage<N>(
     db_tool: &DbTool<N>,
@@ -62,6 +63,7 @@ where
                 Arc::new(output_db),
                 db_tool.chain(),
                 StaticFileProvider::read_write(output_datadir.static_files())?,
+                Arc::new(TriedbProvider::new(output_datadir.triedb())),
             ),
             to,
             from,

crates/e2e-test-utils/src/lib.rs

@@ -58,7 +58,10 @@ where
         PayloadAttributesBuilder<<<N as NodeTypes>::Payload as PayloadTypes>::PayloadAttributes>,
 {
     E2ETestSetupBuilder::new(num_nodes, chain_spec, attributes_generator)
-        .with_node_config_modifier(move |config| config.set_dev(is_dev))
+        .with_node_config_modifier(move |mut config| {
+            config.set_dev(is_dev)
+
+        })
         .build()
         .await
 }

crates/e2e-test-utils/src/setup_import.rs

@@ -10,8 +10,8 @@ use reth_node_builder::{EngineNodeLauncher, Node, NodeBuilder, NodeConfig, NodeH
 use reth_node_core::args::{DiscoveryArgs, NetworkArgs, RpcServerArgs};
 use reth_node_ethereum::EthereumNode;
 use reth_provider::{
-    providers::BlockchainProvider, DatabaseProviderFactory, ProviderFactory, StageCheckpointReader,
-    StaticFileProviderFactory,
+    providers::{BlockchainProvider, ProviderFactory, triedb::TriedbProvider},
+    DatabaseProviderFactory, StageCheckpointReader, StaticFileProviderFactory,
 };
 use reth_rpc_server_types::RpcModuleSelection;
 use reth_stages_types::StageId;
@@ -110,6 +110,7 @@ pub async fn setup_engine_with_chain_import(
         // Create database path and static files path
         let db_path = datadir.join("db");
         let static_files_path = datadir.join("static_files");
+        let triedb_dir = datadir.join("triedb");
 
         // Initialize the database using init_db (same as CLI import command)
         // Use the same database arguments as the node will use
@@ -125,6 +126,7 @@ pub async fn setup_engine_with_chain_import(
             db.clone(),
             chain_spec.clone(),
             reth_provider::providers::StaticFileProvider::read_write(static_files_path.clone())?,
+            Arc::new(TriedbProvider::new(triedb_dir)),
         );
 
         // Initialize genesis if needed
@@ -311,6 +313,7 @@ mod tests {
         std::fs::create_dir_all(&datadir).unwrap();
         let db_path = datadir.join("db");
         let static_files_path = datadir.join("static_files");
+        let triedb_dir = datadir.join("triedb");
 
         // Import the chain
         {
@@ -324,6 +327,7 @@ mod tests {
                 chain_spec.clone(),
                 reth_provider::providers::StaticFileProvider::read_write(static_files_path.clone())
                     .unwrap(),
+                Arc::new(TriedbProvider::new(triedb_dir.clone())),
             );
 
             // Initialize genesis
@@ -384,6 +388,7 @@ mod tests {
                 chain_spec.clone(),
                 reth_provider::providers::StaticFileProvider::read_only(static_files_path, false)
                     .unwrap(),
+                Arc::new(TriedbProvider::new(triedb_dir.clone())),
             );
 
             let provider = provider_factory.database_provider_ro().unwrap();
@@ -469,12 +474,14 @@ mod tests {
 
         // Create static files path
         let static_files_path = datadir.join("static_files");
+        let triedb_dir = datadir.join("triedb");
 
         // Create a provider factory
         let provider_factory: ProviderFactory<MockNodeTypesWithDB> = ProviderFactory::new(
             db.clone(),
             chain_spec.clone(),
             reth_provider::providers::StaticFileProvider::read_write(static_files_path).unwrap(),
+            Arc::new(TriedbProvider::new(triedb_dir)),
         );
 
         // Initialize genesis

crates/engine/local/Cargo.toml

@@ -17,6 +17,7 @@ reth-payload-builder.workspace = true
 reth-payload-primitives.workspace = true
 reth-storage-api.workspace = true
 reth-transaction-pool.workspace = true
+reth-payload-builder-primitives.workspace = true
 
 # alloy
 alloy-consensus.workspace = true
@@ -34,6 +35,7 @@ tracing.workspace = true
 
 op-alloy-rpc-types-engine = { workspace = true, optional = true }
 reth-optimism-chainspec = { workspace = true, optional = true }
+reth-optimism-forks = { workspace = true, optional = true }
 
 [lints]
 workspace = true
@@ -42,5 +44,6 @@ workspace = true
 op = [
     "dep:op-alloy-rpc-types-engine",
     "dep:reth-optimism-chainspec",
+    "dep:reth-optimism-forks",
     "reth-payload-primitives/op",
 ]