adds basefee checker to sim cache handling

Author: dylanlott

bin/builder.rs

@@ -57,8 +57,8 @@ async fn main() -> eyre::Result<()> {
 
     let sim = Arc::new(Simulator::new(&config, ru_provider.clone(), slot_calculator));
 
-    let sim_cache_jh =
-        sim.clone().spawn_cache_handler(tx_receiver, bundle_receiver, sim_items.clone());
+    let (basefee_jh, sim_cache_jh) =
+        sim.clone().spawn_cache_task(tx_receiver, bundle_receiver, sim_items.clone());
 
     let build_jh = sim.clone().spawn_simulator_task(constants, sim_items.clone(), submit_channel);
 
@@ -75,6 +75,9 @@ async fn main() -> eyre::Result<()> {
         _ = sim_cache_jh => {
             tracing::info!("sim cache task finished");
         }
+        _ = basefee_jh => {
+            tracing::info!("basefee task finished");
+        }
         _ = submit_jh => {
             tracing::info!("submit finished");
         },

src/tasks/block.rs

@@ -2,7 +2,11 @@ use crate::{
     config::{BuilderConfig, WalletlessProvider},
     tasks::bundler::Bundle,
 };
-use alloy::{consensus::TxEnvelope, eips::BlockId, providers::Provider};
+use alloy::{
+    consensus::TxEnvelope,
+    eips::{BlockId, BlockNumberOrTag::Latest},
+    providers::Provider,
+};
 use signet_sim::{BlockBuild, BuiltBlock, SimCache, SimItem};
 use signet_types::{SlotCalculator, config::SignetSystemConstants};
 use std::{
@@ -11,8 +15,12 @@ use std::{
 };
 use tokio::{
     select,
-    sync::mpsc::{self},
+    sync::{
+        RwLock,
+        mpsc::{self},
+    },
     task::JoinHandle,
+    time::sleep,
 };
 use trevm::{
     NoopBlock,
@@ -92,42 +100,83 @@ impl Simulator {
         Ok(block)
     }
 
-    /// Spawns a task to handle incoming transactions and bundles, adding them
-    /// to the simulation cache.
+    /// Spawns two tasks: one to handle incoming transactions and bundles,
+    /// adding them to the simulation cache, and one to track the latest basefee.
     ///
     /// # Arguments
     /// - `tx_receiver`: A channel receiver for incoming transactions.
     /// - `bundle_receiver`: A channel receiver for incoming bundles.
     /// - `cache`: The simulation cache to store the received items.
     ///
     /// # Returns
-    /// A `JoinHandle` for the spawned task.
-    pub fn spawn_cache_handler(
+    /// A `JoinHandle` for the basefee updater and a `JoinHandle` for the
+    /// cache handler.
+    pub fn spawn_cache_task(
         self: Arc<Self>,
         mut tx_receiver: mpsc::UnboundedReceiver<TxEnvelope>,
         mut bundle_receiver: mpsc::UnboundedReceiver<Bundle>,
         cache: SimCache,
-    ) -> JoinHandle<()> {
+    ) -> (JoinHandle<()>, JoinHandle<()>) {
         tracing::debug!("starting up cache handler");
 
-        tokio::spawn(async move {
+        let shared_price = Arc::new(RwLock::new(0_u64));
+        let price_updater = Arc::clone(&shared_price);
+        let price_reader = Arc::clone(&shared_price);
+
+        // Update the basefee on a per-block cadence
+        let basefee_jh = tokio::spawn(async move {
+            loop {
+                // calculate next slot position plus a small buffer to
+                let time_remaining = self.slot_calculator.slot_duration()
+                    - self.slot_calculator.current_timepoint_within_slot()
+                    + 1;
+                tracing::debug!(time_remaining = ?time_remaining, "sleeping until next slot");
+
+                // wait until that point in time
+                sleep(Duration::from_secs(time_remaining)).await;
+
+                // update the basefee with that price
+                tracing::debug!("checking latest basefee");
+                let resp = self.ru_provider.get_block_by_number(Latest).await;
+
+                if let Ok(maybe_block) = resp {
+                    match maybe_block {
+                        Some(block) => {
+                            let basefee = block.header.base_fee_per_gas.unwrap_or_default();
+                            let mut w = price_updater.write().await;
+                            *w = basefee;
+                            tracing::debug!(basefee = %basefee, "basefee updated");
+                        }
+                        None => {
+                            tracing::debug!("no block found; basefee not updated.")
+                        }
+                    }
+                }
+            }
+        });
+
+        // Update the sim cache whenever a transaction or bundle is received with respect to the basefee
+        let cache_jh = tokio::spawn(async move {
             loop {
+                let p = price_reader.read().await;
                 select! {
                     maybe_tx = tx_receiver.recv() => {
                         if let Some(tx) = maybe_tx {
                             tracing::debug!(tx = ?tx.hash(), "received transaction");
-                            cache.add_item(SimItem::Tx(tx));
+                            cache.add_item(SimItem::Tx(tx), *p);
                         }
                     }
                     maybe_bundle = bundle_receiver.recv() => {
                         if let Some(bundle) = maybe_bundle {
                             tracing::debug!(bundle = ?bundle.id, "received bundle");
-                            cache.add_item(SimItem::Bundle(bundle.bundle));
+                            cache.add_item(SimItem::Bundle(bundle.bundle), *p);
                         }
                     }
                 }
             }
-        })
+        });
+
+        (basefee_jh, cache_jh)
     }
 
     /// Spawns the simulator task, which handles the setup and sets the deadline  

tests/block_builder_test.rs

@@ -57,10 +57,10 @@ mod tests {
 
         // Add two transactions from two senders to the sim cache
         let tx_1 = new_signed_tx(&test_key_0, 0, U256::from(1_f64), 11_000).unwrap();
-        sim_items.add_item(SimItem::Tx(tx_1));
+        sim_items.add_item(SimItem::Tx(tx_1), 0);
 
         let tx_2 = new_signed_tx(&test_key_1, 0, U256::from(2_f64), 10_000).unwrap();
-        sim_items.add_item(SimItem::Tx(tx_2));
+        sim_items.add_item(SimItem::Tx(tx_2), 0);
 
         let finish_by = Instant::now() + Duration::from_secs(2);
 
@@ -113,7 +113,7 @@ mod tests {
         let sim_cache = SimCache::new();
 
         // Create a sim cache and start filling it with items
-        sim.clone().spawn_cache_handler(tx_receiver, bundle_receiver, sim_cache.clone());
+        sim.clone().spawn_cache_task(tx_receiver, bundle_receiver, sim_cache.clone());
 
         // Finally, Kick off the block builder task.
         sim.clone().spawn_simulator_task(constants, sim_cache.clone(), block_sender);