chore(cache): move cache system out of config (#118)

There's no reason for this to be contained here, and feels wrong when every other task has its own file / spawn pattern.

Author: Evalir

bin/builder.rs

@@ -1,7 +1,7 @@
 use builder::{
     config::BuilderConfig,
     service::serve_builder,
-    tasks::{block::sim::Simulator, metrics::MetricsTask, submit::SubmitTask},
+    tasks::{block::sim::Simulator, cache::CacheTasks, metrics::MetricsTask, submit::SubmitTask},
 };
 use init4_bin_base::{
     deps::tracing::{info, info_span},
@@ -26,7 +26,8 @@ async fn main() -> eyre::Result<()> {
     let (block_env, env_jh) = env_task.spawn();
 
     // Spawn the cache system
-    let cache_system = config.spawn_cache_system(block_env.clone());
+    let cache_tasks = CacheTasks::new(config.clone(), block_env.clone());
+    let cache_system = cache_tasks.spawn();
 
     // Prep providers and contracts
     let (host_provider, quincey) =

src/config.rs

@@ -1,10 +1,6 @@
 use crate::{
     quincey::Quincey,
-    tasks::{
-        block::cfg::SignetCfgEnv,
-        cache::{BundlePoller, CacheSystem, CacheTask, TxPoller},
-        env::{EnvTask, SimEnv},
-    },
+    tasks::{block::cfg::SignetCfgEnv, env::EnvTask},
 };
 use alloy::{
     network::{Ethereum, EthereumWallet},
@@ -28,7 +24,6 @@ use init4_bin_base::{
 };
 use signet_zenith::Zenith;
 use std::borrow::Cow;
-use tokio::sync::watch;
 
 /// Type alias for the provider used to simulate against rollup state.
 pub type RuProvider = RootProvider<Ethereum>;
@@ -255,27 +250,6 @@ impl BuilderConfig {
         EnvTask::new(self.clone(), ru_provider)
     }
 
-    /// Spawn a new [`CacheSystem`] using this config. This contains the
-    /// joinhandles for [`TxPoller`] and [`BundlePoller`] and [`CacheTask`], as
-    /// well as the [`SimCache`] and the block env watcher.
-    ///
-    /// [`SimCache`]: signet_sim::SimCache
-    pub fn spawn_cache_system(&self, block_env: watch::Receiver<Option<SimEnv>>) -> CacheSystem {
-        // Tx Poller pulls transactions from the cache
-        let tx_poller = TxPoller::new(self);
-        let (tx_receiver, tx_poller) = tx_poller.spawn();
-
-        // Bundle Poller pulls bundles from the cache
-        let bundle_poller = BundlePoller::new(self, self.oauth_token());
-        let (bundle_receiver, bundle_poller) = bundle_poller.spawn();
-
-        // Set up the cache task
-        let cache_task = CacheTask::new(block_env.clone(), bundle_receiver, tx_receiver);
-        let (sim_cache, cache_task) = cache_task.spawn();
-
-        CacheSystem { cache_task, tx_poller, bundle_poller, sim_cache }
-    }
-
     /// Create a [`SignetCfgEnv`] using this config.
     pub const fn cfg_env(&self) -> SignetCfgEnv {
         SignetCfgEnv { chain_id: self.ru_chain_id }

src/tasks/cache/mod.rs

@@ -7,21 +7,5 @@ pub use tx::TxPoller;
 mod bundle;
 pub use bundle::BundlePoller;
 
-use signet_sim::SimCache;
-use tokio::task::JoinHandle;
-
-/// Cache tasks for the block builder.
-#[derive(Debug)]
-pub struct CacheSystem {
-    /// The cache task.
-    pub cache_task: JoinHandle<()>,
-
-    /// The transaction poller task.
-    pub tx_poller: JoinHandle<()>,
-
-    /// The bundle poller task.
-    pub bundle_poller: JoinHandle<()>,
-
-    /// The sim cache.
-    pub sim_cache: SimCache,
-}
+mod system;
+pub use system::CacheTasks;

src/tasks/cache/system.rs

@@ -0,0 +1,71 @@
+use signet_sim::SimCache;
+use tokio::{sync::watch, task::JoinHandle};
+
+use crate::{
+    config::BuilderConfig,
+    tasks::{
+        cache::{BundlePoller, CacheTask, TxPoller},
+        env::SimEnv,
+    },
+};
+
+/// The block builder's cache system.
+#[derive(Debug)]
+pub struct CacheTasks {
+    /// The builder config.
+    pub config: BuilderConfig,
+    /// The block environment receiver.
+    pub block_env: watch::Receiver<Option<SimEnv>>,
+}
+
+impl CacheTasks {
+    /// Create a new [`CacheSystem`] with the given components.
+    pub const fn new(config: BuilderConfig, block_env: watch::Receiver<Option<SimEnv>>) -> Self {
+        Self { config, block_env }
+    }
+
+    /// Spawn a new [`CacheSystem`], which starts the
+    /// [`CacheTask`], [`TxPoller`], and [`BundlePoller`] internally and yields their [`JoinHandle`]s.
+    pub fn spawn(&self) -> CacheSystem {
+        // Tx Poller pulls transactions from the cache
+        let tx_poller = TxPoller::new(&self.config);
+        let (tx_receiver, tx_poller) = tx_poller.spawn();
+
+        // Bundle Poller pulls bundles from the cache
+        let bundle_poller = BundlePoller::new(&self.config, self.config.oauth_token());
+        let (bundle_receiver, bundle_poller) = bundle_poller.spawn();
+
+        // Set up the cache task
+        let cache_task = CacheTask::new(self.block_env.clone(), bundle_receiver, tx_receiver);
+        let (sim_cache, cache_task) = cache_task.spawn();
+
+        CacheSystem::new(sim_cache, tx_poller, bundle_poller, cache_task)
+    }
+}
+
+/// The tasks that the cache system spawns.
+////// This struct contains the cache and the task handles for the
+/// [`CacheTask`], [`TxPoller`], and [`BundlePoller`].
+#[derive(Debug)]
+pub struct CacheSystem {
+    /// The cache for the block builder.
+    pub sim_cache: SimCache,
+    /// The task handle for the transaction poller.
+    pub tx_poller: JoinHandle<()>,
+    /// The task handle for the bundle poller.
+    pub bundle_poller: JoinHandle<()>,
+    /// The task handle for the cache task.
+    pub cache_task: JoinHandle<()>,
+}
+
+impl CacheSystem {
+    /// Create a new [`CacheTasks`] instance.
+    pub const fn new(
+        sim_cache: SimCache,
+        tx_poller: JoinHandle<()>,
+        bundle_poller: JoinHandle<()>,
+        cache_task: JoinHandle<()>,
+    ) -> Self {
+        Self { sim_cache, tx_poller, bundle_poller, cache_task }
+    }
+}

tests/cache.rs

@@ -1,4 +1,7 @@
-use builder::test_utils::{setup_logging, setup_test_config};
+use builder::{
+    tasks::cache::CacheTasks,
+    test_utils::{setup_logging, setup_test_config},
+};
 use init4_bin_base::deps::tracing::warn;
 use std::time::Duration;
 
@@ -10,11 +13,12 @@ async fn test_bundle_poller_roundtrip() -> eyre::Result<()> {
     let config = setup_test_config().unwrap();
 
     let (block_env, _jh) = config.env_task().spawn();
-    let cache = config.spawn_cache_system(block_env);
+    let cache_tasks = CacheTasks::new(config.clone(), block_env);
+    let cache_system = cache_tasks.spawn();
 
     tokio::time::sleep(Duration::from_secs(12)).await;
 
-    warn!(txns = ?cache.sim_cache.read_best(5));
+    warn!(txns = ?cache_system.sim_cache.read_best(5));
 
     Ok(())
 }