backtesting fix.

roothash not used in backtesting.

crates/rbuilder/src/backtest/backtest_build_range.rs

@@ -111,7 +111,7 @@ where
         result
     };
 
-    let provider_factory = config.base_config().create_provider_factory()?;
+    let provider_factory = config.base_config().create_provider_factory(true)?;
     let chain_spec = config.base_config().chain_spec()?;
 
     let mut profits = Vec::new();

crates/rbuilder/src/backtest/build_block/backtest_build_block.rs

@@ -7,8 +7,6 @@
 
 use ahash::HashMap;
 use alloy_primitives::utils::format_ether;
-use reth_db::Database;
-use reth_provider::{BlockReader, DatabaseProviderFactory, StateProviderFactory};
 
 use crate::{
     backtest::{
@@ -18,6 +16,7 @@ use crate::{
     building::{builders::BacktestSimulateBlockInput, BlockBuildingContext},
     live_builder::cli::LiveBuilderConfig,
     primitives::{Order, OrderId, SimulatedOrder},
+    provider::StateProviderFactory,
 };
 use clap::Parser;
 use std::path::PathBuf;
@@ -42,14 +41,10 @@ pub struct BuildBlockCfg {
 
 /// Provides all the orders needed to simulate the construction of a block.
 /// It also provides the needed context to execute those orders.
-pub trait OrdersSource<ConfigType, DBType, ProviderType>
+pub trait OrdersSource<ConfigType, ProviderType>
 where
     ConfigType: LiveBuilderConfig,
-    DBType: Database + Clone + 'static,
-    ProviderType: DatabaseProviderFactory<DB = DBType, Provider: BlockReader>
-        + StateProviderFactory
-        + Clone
-        + 'static,
+    ProviderType: StateProviderFactory + Clone + 'static,
 {
     fn config(&self) -> &ConfigType;
     /// Orders available to build blocks with their time of arrival.
@@ -67,18 +62,14 @@ where
     fn print_custom_stats(&self, provider: ProviderType) -> eyre::Result<()>;
 }
 
-pub async fn run_backtest_build_block<ConfigType, OrdersSourceType, DBType, ProviderType>(
+pub async fn run_backtest_build_block<ConfigType, OrdersSourceType, ProviderType>(
     build_block_cfg: BuildBlockCfg,
     orders_source: OrdersSourceType,
 ) -> eyre::Result<()>
 where
     ConfigType: LiveBuilderConfig,
-    DBType: Database + Clone + 'static,
-    ProviderType: DatabaseProviderFactory<DB = DBType, Provider: BlockReader>
-        + StateProviderFactory
-        + Clone
-        + 'static,
-    OrdersSourceType: OrdersSource<ConfigType, DBType, ProviderType>,
+    ProviderType: StateProviderFactory + Clone + 'static,
+    OrdersSourceType: OrdersSource<ConfigType, ProviderType>,
 {
     let config = orders_source.config();
     config.base_config().setup_tracing_subscriber()?;

crates/rbuilder/src/backtest/build_block/landed_block_from_db.rs

@@ -20,7 +20,7 @@ use crate::{
         },
         BlockData, HistoricalDataStorage, OrdersWithTimestamp,
     },
-    building::BlockBuildingContext,
+    building::{builders::mock_block_building_helper::MockRootHasher, BlockBuildingContext},
     live_builder::{base_config::load_config_toml_and_env, cli::LiveBuilderConfig},
     utils::{timestamp_as_u64, ProviderFactoryReopener},
 };
@@ -84,7 +84,6 @@ impl<ConfigType: LiveBuilderConfig> LandedBlockFromDBOrdersSource<ConfigType> {
 impl<ConfigType: LiveBuilderConfig>
     OrdersSource<
         ConfigType,
-        Arc<DatabaseEnv>,
         ProviderFactoryReopener<NodeTypesWithDBAdapter<EthereumNode, Arc<DatabaseEnv>>>,
     > for LandedBlockFromDBOrdersSource<ConfigType>
 {
@@ -100,7 +99,7 @@ impl<ConfigType: LiveBuilderConfig>
         &self,
     ) -> eyre::Result<ProviderFactoryReopener<NodeTypesWithDBAdapter<EthereumNode, Arc<DatabaseEnv>>>>
     {
-        self.config.base_config().create_provider_factory()
+        self.config.base_config().create_provider_factory(true)
     }
 
     fn create_block_building_context(&self) -> eyre::Result<BlockBuildingContext> {
@@ -113,6 +112,7 @@ impl<ConfigType: LiveBuilderConfig>
             signer.address,
             self.block_data.winning_bid_trace.proposer_fee_recipient,
             Some(signer),
+            Arc::new(MockRootHasher {}),
         ))
     }
 

crates/rbuilder/src/backtest/build_block/synthetic_orders.rs

@@ -1,8 +1,5 @@
-use std::sync::Arc;
-
 use clap::{command, Parser};
-use reth_db::{test_utils::TempDatabase, DatabaseEnv};
-use reth_provider::{providers::BlockchainProvider2, test_utils::MockNodeTypesWithDB};
+use reth_provider::test_utils::MockNodeTypesWithDB;
 use revm_primitives::B256;
 use uuid::Uuid;
 
@@ -14,6 +11,7 @@ use crate::{
     },
     live_builder::{base_config::load_config_toml_and_env, cli::LiveBuilderConfig},
     primitives::{Bundle, MempoolTx, Metadata, Order, TransactionSignedEcRecoveredWithBlobs},
+    provider::state_provider_factory_from_provider_factory::StateProviderFactoryFromProviderFactory,
 };
 
 use super::backtest_build_block::{run_backtest_build_block, BuildBlockCfg, OrdersSource};
@@ -112,11 +110,8 @@ impl<ConfigType: LiveBuilderConfig> SyntheticOrdersSource<ConfigType> {
 }
 
 impl<ConfigType: LiveBuilderConfig>
-    OrdersSource<
-        ConfigType,
-        Arc<TempDatabase<DatabaseEnv>>,
-        BlockchainProvider2<MockNodeTypesWithDB>,
-    > for SyntheticOrdersSource<ConfigType>
+    OrdersSource<ConfigType, StateProviderFactoryFromProviderFactory<MockNodeTypesWithDB>>
+    for SyntheticOrdersSource<ConfigType>
 {
     fn available_orders(&self) -> Vec<OrdersWithTimestamp> {
         self.orders.clone()
@@ -126,10 +121,13 @@ impl<ConfigType: LiveBuilderConfig>
         0
     }
 
-    fn create_provider_factory(&self) -> eyre::Result<BlockchainProvider2<MockNodeTypesWithDB>> {
-        Ok(BlockchainProvider2::new(
+    fn create_provider_factory(
+        &self,
+    ) -> eyre::Result<StateProviderFactoryFromProviderFactory<MockNodeTypesWithDB>> {
+        Ok(StateProviderFactoryFromProviderFactory::new(
             self.test_chain_state.provider_factory().clone(),
-        )?)
+            None,
+        ))
     }
 
     fn create_block_building_context(&self) -> eyre::Result<BlockBuildingContext> {
@@ -138,7 +136,7 @@ impl<ConfigType: LiveBuilderConfig>
 
     fn print_custom_stats(
         &self,
-        _provider: BlockchainProvider2<MockNodeTypesWithDB>,
+        _provider: StateProviderFactoryFromProviderFactory<MockNodeTypesWithDB>,
     ) -> eyre::Result<()> {
         Ok(())
     }

crates/rbuilder/src/backtest/redistribute/cli/mod.rs

@@ -56,7 +56,7 @@ where
     let mut historical_data_storage =
         HistoricalDataStorage::new_from_path(&config.base_config().backtest_fetch_output_file)
             .await?;
-    let provider = config.base_config().create_provider_factory()?;
+    let provider = config.base_config().create_provider_factory(true)?;
     let mut csv_writer = cli
         .csv
         .map(|path| -> io::Result<_> { CSVResultWriter::new(path) })

crates/rbuilder/src/bin/debug-bench-machine.rs

@@ -43,7 +43,7 @@ async fn main() -> eyre::Result<()> {
 
     let chain_spec = config.base_config().chain_spec()?;
 
-    let provider_factory = config.base_config().create_provider_factory()?;
+    let provider_factory = config.base_config().create_provider_factory(false)?;
 
     let last_block = provider_factory.last_block_number()?;
 

crates/rbuilder/src/live_builder/base_config.rs

@@ -230,8 +230,10 @@ impl BaseConfig {
     }
 
     /// Open reth db and DB should be opened once per process but it can be cloned and moved to different threads.
+    /// skip_root_hash -> will create a mock roothasher. Used on backtesting since reth can't compute roothashes on the past.
     pub fn create_provider_factory(
         &self,
+        skip_root_hash: bool,
     ) -> eyre::Result<ProviderFactoryReopener<NodeTypesWithDBAdapter<EthereumNode, Arc<DatabaseEnv>>>>
     {
         create_provider_factory(
@@ -240,7 +242,11 @@ impl BaseConfig {
             self.reth_static_files_path.as_deref(),
             self.chain_spec()?,
             false,
-            Some(self.live_root_hash_config()?),
+            if skip_root_hash {
+                None
+            } else {
+                Some(self.live_root_hash_config()?)
+            },
         )
     }
 

crates/rbuilder/src/live_builder/cli.rs

@@ -120,7 +120,7 @@ where
         config.base_config().log_enable_dynamic,
     )
     .await?;
-    let provider = config.base_config().create_provider_factory()?;
+    let provider = config.base_config().create_provider_factory(false)?;
     let builder = config.new_builder(provider, cancel.clone()).await?;
 
     let ctrlc = tokio::spawn(async move {

crates/rbuilder/src/provider/mod.rs

@@ -9,6 +9,7 @@ use tokio::sync::broadcast;
 use tokio_util::sync::CancellationToken;
 
 pub mod reth_prov;
+pub mod state_provider_factory_from_provider_factory;
 
 /// Main trait to interact with the chain data.
 /// Allows to create different backends for chain data access without implementing lots of interfaces as would happen with reth_provider::StateProviderFactory

crates/rbuilder/src/provider/state_provider_factory_from_provider_factory.rs

@@ -0,0 +1,81 @@
+use alloy_consensus::Header;
+use alloy_primitives::{BlockHash, BlockNumber};
+use reth_errors::ProviderResult;
+use reth_node_api::NodeTypesWithDB;
+use reth_provider::{
+    providers::ProviderNodeTypes, BlockHashReader, BlockNumReader, HeaderProvider, ProviderFactory,
+    StateProviderBox,
+};
+use revm_primitives::B256;
+
+use crate::{
+    building::builders::mock_block_building_helper::MockRootHasher, roothash::RootHashConfig,
+    utils::RootHasherImpl,
+};
+
+use super::{RootHasher, StateProviderFactory};
+
+/// StateProviderFactory based on a ProviderFactory.
+#[derive(Clone)]
+pub struct StateProviderFactoryFromProviderFactory<N: NodeTypesWithDB> {
+    provider: ProviderFactory<N>,
+    root_hash_config: Option<RootHashConfig>,
+}
+
+impl<N: NodeTypesWithDB> StateProviderFactoryFromProviderFactory<N> {
+    /// root_hash_config None -> no roothash (MockRootHasher)
+    pub fn new(provider: ProviderFactory<N>, root_hash_config: Option<RootHashConfig>) -> Self {
+        Self {
+            provider,
+            root_hash_config,
+        }
+    }
+}
+
+impl<N: NodeTypesWithDB + ProviderNodeTypes + Clone> StateProviderFactory
+    for StateProviderFactoryFromProviderFactory<N>
+{
+    fn latest(&self) -> ProviderResult<StateProviderBox> {
+        self.provider.latest()
+    }
+
+    fn history_by_block_number(&self, block: BlockNumber) -> ProviderResult<StateProviderBox> {
+        self.provider.history_by_block_number(block)
+    }
+
+    fn history_by_block_hash(&self, block: BlockHash) -> ProviderResult<StateProviderBox> {
+        self.provider.history_by_block_hash(block)
+    }
+
+    fn header(&self, block_hash: &BlockHash) -> ProviderResult<Option<Header>> {
+        self.provider.header(block_hash)
+    }
+
+    fn block_hash(&self, number: BlockNumber) -> ProviderResult<Option<B256>> {
+        self.provider.block_hash(number)
+    }
+
+    fn best_block_number(&self) -> ProviderResult<BlockNumber> {
+        self.provider.best_block_number()
+    }
+
+    fn header_by_number(&self, num: u64) -> ProviderResult<Option<Header>> {
+        self.provider.header_by_number(num)
+    }
+
+    fn last_block_number(&self) -> ProviderResult<BlockNumber> {
+        self.provider.last_block_number()
+    }
+
+    fn root_hasher(&self, parent_hash: B256) -> Box<dyn RootHasher> {
+        if let Some(root_hash_config) = &self.root_hash_config {
+            Box::new(RootHasherImpl::new(
+                parent_hash,
+                root_hash_config.clone(),
+                self.provider.clone(),
+            ))
+        } else {
+            Box::new(MockRootHasher {})
+        }
+    }
+}