remove unnecessary StateProviderFactories enum

Author: mralj

crates/rbuilder/src/live_builder/base_config.rs

@@ -5,7 +5,7 @@ use crate::{
     live_builder::{order_input::OrderInputConfig, LiveBuilder},
     provider::{
         ipc_state_provider::{IpcProviderConfig, IpcStateProviderFactory},
-        StateProviderFactories, StateProviderFactory,
+        StateProviderFactory,
     },
     roothash::RootHashContext,
     telemetry::{setup_reloadable_tracing_subscriber, LoggerConfig},
@@ -309,19 +309,6 @@ impl BaseConfig {
         ))
     }
 
-    pub fn create_provider_factory_from_config(
-        &self,
-        skip_root_hash: bool,
-    ) -> eyre::Result<StateProviderFactories> {
-        if self.ipc_provider.is_some() {
-            self.create_ipc_provider_factory()
-                .map(StateProviderFactories::Ipc)
-        } else {
-            self.create_reth_provider_factory(skip_root_hash)
-                .map(StateProviderFactories::Reth)
-        }
-    }
-
     /// live_root_hash_config creates a root hash thread pool
     /// so it should be called once on the startup and cloned if needed
     pub fn live_root_hash_config(&self) -> eyre::Result<RootHashContext> {

crates/rbuilder/src/live_builder/cli.rs

@@ -107,8 +107,6 @@ where
     let config: ConfigType = load_config_toml_and_env(cli.config)?;
     config.base_config().setup_tracing_subscriber()?;
 
-    let cancel = CancellationToken::new();
-
     // Spawn redacted server that is safe for tdx builders to expose
     telemetry::servers::redacted::spawn(config.base_config().redacted_telemetry_server_address())
         .await?;
@@ -120,9 +118,25 @@ where
         config.base_config().log_enable_dynamic,
     )
     .await?;
-    let provider = config
-        .base_config()
-        .create_provider_factory_from_config(false)?;
+    if config.base_config().ipc_provider.is_some() {
+        let provider = config.base_config().create_ipc_provider_factory()?;
+        run_builder(provider, config, on_run).await
+    } else {
+        let provider = config.base_config().create_reth_provider_factory(false)?;
+        run_builder(provider, config, on_run).await
+    }
+}
+
+async fn run_builder<P, ConfigType>(
+    provider: P,
+    config: ConfigType,
+    on_run: Option<fn()>,
+) -> eyre::Result<()>
+where
+    ConfigType: LiveBuilderConfig,
+    P: StateProviderFactory + Clone + 'static,
+{
+    let cancel = CancellationToken::new();
     let builder = config.new_builder(provider, cancel.clone()).await?;
 
     let ctrlc = tokio::spawn(async move {
@@ -133,7 +147,6 @@ where
         on_run();
     }
     builder.run().await?;
-
     ctrlc.await.unwrap_or_default();
     Ok(())
 }

crates/rbuilder/src/provider/mod.rs

@@ -1,16 +1,10 @@
-use std::sync::Arc;
-
+use crate::live_builder::simulation::SimulatedOrderCommand;
 use crate::roothash::RootHashError;
-use crate::{live_builder::simulation::SimulatedOrderCommand, utils::ProviderFactoryReopener};
 use alloy_consensus::Header;
 use alloy_eips::BlockNumHash;
 use alloy_primitives::{BlockHash, BlockNumber, B256};
-use ipc_state_provider::IpcStateProviderFactory;
 use reth::providers::ExecutionOutcome;
-use reth_db::DatabaseEnv;
 use reth_errors::ProviderResult;
-use reth_node_api::NodeTypesWithDBAdapter;
-use reth_node_ethereum::EthereumNode;
 use reth_provider::StateProviderBox;
 use tokio::sync::broadcast;
 use tokio_util::sync::CancellationToken;
@@ -58,75 +52,3 @@ pub trait RootHasher: std::fmt::Debug + Send + Sync {
     /// State root for changes outcome on top of parent block.
     fn state_root(&self, outcome: &ExecutionOutcome) -> Result<B256, RootHashError>;
 }
-
-/// All supported state provider factories
-#[derive(Clone)]
-pub enum StateProviderFactories {
-    Reth(ProviderFactoryReopener<NodeTypesWithDBAdapter<EthereumNode, Arc<DatabaseEnv>>>),
-    Ipc(IpcStateProviderFactory),
-}
-
-impl StateProviderFactory for StateProviderFactories {
-    fn latest(&self) -> ProviderResult<StateProviderBox> {
-        match self {
-            StateProviderFactories::Reth(factory) => factory.latest(),
-            StateProviderFactories::Ipc(factory) => factory.latest(),
-        }
-    }
-
-    fn history_by_block_number(&self, block: BlockNumber) -> ProviderResult<StateProviderBox> {
-        match self {
-            StateProviderFactories::Reth(factory) => factory.history_by_block_number(block),
-            StateProviderFactories::Ipc(factory) => factory.history_by_block_number(block),
-        }
-    }
-
-    fn history_by_block_hash(&self, block: BlockHash) -> ProviderResult<StateProviderBox> {
-        match self {
-            StateProviderFactories::Reth(factory) => factory.history_by_block_hash(block),
-            StateProviderFactories::Ipc(factory) => factory.history_by_block_hash(block),
-        }
-    }
-
-    fn header(&self, block_hash: &BlockHash) -> ProviderResult<Option<Header>> {
-        match self {
-            StateProviderFactories::Reth(factory) => factory.header(block_hash),
-            StateProviderFactories::Ipc(factory) => factory.header(block_hash),
-        }
-    }
-
-    fn block_hash(&self, number: BlockNumber) -> ProviderResult<Option<B256>> {
-        match self {
-            StateProviderFactories::Reth(factory) => factory.block_hash(number),
-            StateProviderFactories::Ipc(factory) => factory.block_hash(number),
-        }
-    }
-
-    fn best_block_number(&self) -> ProviderResult<BlockNumber> {
-        match self {
-            StateProviderFactories::Reth(factory) => factory.best_block_number(),
-            StateProviderFactories::Ipc(factory) => factory.best_block_number(),
-        }
-    }
-
-    fn header_by_number(&self, num: u64) -> ProviderResult<Option<Header>> {
-        match self {
-            StateProviderFactories::Reth(factory) => factory.header_by_number(num),
-            StateProviderFactories::Ipc(factory) => factory.header_by_number(num),
-        }
-    }
-
-    fn last_block_number(&self) -> ProviderResult<BlockNumber> {
-        match self {
-            StateProviderFactories::Reth(factory) => factory.last_block_number(),
-            StateProviderFactories::Ipc(factory) => factory.last_block_number(),
-        }
-    }
-
-    fn root_hasher(&self, parent_num_hash: BlockNumHash) -> ProviderResult<Box<dyn RootHasher>> {
-        match self {
-            StateProviderFactories::Reth(factory) => factory.root_hasher(parent_num_hash),
-            StateProviderFactories::Ipc(factory) => factory.root_hasher(parent_num_hash),
-        }
-    }
-}