wires up the block and submit task to use simulation

- adds the simulator task to the block building loop
- feeds the submit channel to the simulator after in-progress block creation

Author: dylanlott

bin/builder.rs

@@ -7,6 +7,7 @@ use builder::tasks::metrics::MetricsTask;
 use builder::tasks::oauth::Authenticator;
 use builder::tasks::submit::SubmitTask;
 
+use builder::tasks::tx_poller;
 use tokio::select;
 
 #[tokio::main]

src/tasks/block.rs

@@ -2,13 +2,16 @@ use super::bundler::{Bundle, BundlePoller};
 use super::oauth::Authenticator;
 use super::tx_poller::TxPoller;
 use crate::config::{BuilderConfig, WalletlessProvider};
+use crate::tasks::simulator::SimulatorFactory;
 use alloy::{
     consensus::{SidecarBuilder, SidecarCoder, TxEnvelope},
     eips::eip2718::Decodable2718,
     primitives::{keccak256, Bytes, B256},
     providers::Provider as _,
     rlp::Buf,
 };
+use revm::db::{AlloyDB, CacheDB};
+use std::sync::Arc;
 use std::time::{SystemTime, UNIX_EPOCH};
 use std::{sync::OnceLock, time::Duration};
 use tokio::{sync::mpsc, task::JoinHandle};
@@ -238,13 +241,29 @@ impl BlockBuilder {
                     tokio::time::sleep(Duration::from_secs(self.secs_to_next_target())).await;
                     info!("beginning block build cycle");
 
-                    // Build a block
-                    let mut in_progress = InProgressBlock::default();
-                    self.get_transactions(&mut in_progress).await;
-                    self.get_bundles(&mut in_progress).await;
-
-                    // Filter confirmed transactions from the block
-                    self.filter_transactions(&mut in_progress).await;
+                    // Setup a simulator factory
+                    let ru_provider = self.ru_provider.clone();
+                    let latest = ru_provider.get_block_number().await.unwrap();
+                    let db = AlloyDB::new(
+                        ru_provider.into(),
+                        alloy_eips::BlockId::Number(latest.into()),
+                    );
+
+                    // Calculate the simulation deadline
+                    let deadline = self.secs_to_next_target();
+
+                    // Create a simulator instance
+                    if let Some(db) = db {
+                        let cache_db = CacheDB::new(Arc::new(db));
+                        let sim = SimulatorFactory::new(cache_db, ());
+
+                        // TODO: Plumb the
+                        let in_progress =
+                            sim.spawn(inbound_tx, inbound_bundle, evaluator, deadline).await;
+                        outbound.send(in_progress);
+                    } else {
+                        todo!("handle failure to get a db")
+                    }
 
                     // submit the block if it has transactions
                     if !in_progress.is_empty() {

src/tasks/simulator.rs

@@ -4,7 +4,7 @@ use alloy::primitives::U256;
 use eyre::Result;
 use revm::{db::CacheDB, primitives::CfgEnv, DatabaseRef};
 use std::{convert::Infallible, sync::Arc};
-use tokio::{select, sync::mpsc::UnboundedReceiver, task::JoinSet};
+use tokio::{select, sync::mpsc::{Receiver, UnboundedReceiver}, task::JoinSet};
 use trevm::{
     db::sync::{ConcurrentState, ConcurrentStateInfo},
     revm::{
@@ -56,8 +56,8 @@ where
     /// * This function always returns whatever the latest finished in progress block is.
     pub fn spawn<T, F>(
         self,
-        mut inbound_tx: UnboundedReceiver<Arc<TxEnvelope>>,
-        _inbound_bundle: UnboundedReceiver<Arc<Vec<TxEnvelope>>>,
+        mut inbound_tx: Receiver<Arc<TxEnvelope>>,
+        _inbound_bundle: Receiver<Arc<Vec<TxEnvelope>>>,
         evaluator: Arc<F>,
         deadline: tokio::time::Instant,
     ) -> tokio::task::JoinHandle<InProgressBlock>