refactor: move some utils to utils, remove an rpc call

Cargo.toml

@@ -33,7 +33,7 @@ signet-tx-cache = { git = "https://github.com/init4tech/signet-sdk", branch = "m
 signet-types = { git = "https://github.com/init4tech/signet-sdk", branch = "main" }
 signet-zenith = { git = "https://github.com/init4tech/signet-sdk", branch = "main" }
 
-trevm = { version = "0.23.4", features = ["concurrent-db", "test-utils"] }
+trevm = { version = "0.23.6", features = ["concurrent-db", "test-utils"] }
 
 alloy = { version = "1.0.5", features = [
     "full",

bin/builder.rs

@@ -35,12 +35,18 @@ async fn main() -> eyre::Result<()> {
     let zenith = config.connect_zenith(host_provider.clone());
 
     // Set up the metrics task
-    let metrics = MetricsTask { host_provider };
+    let metrics = MetricsTask { host_provider: host_provider.clone() };
     let (tx_channel, metrics_jh) = metrics.spawn();
 
     // Make a Tx submission task
-    let submit =
-        SubmitTask { zenith, quincey, config: config.clone(), outbound_tx_channel: tx_channel };
+    let submit = SubmitTask {
+        zenith,
+        quincey,
+        config: config.clone(),
+        constants,
+        outbound_tx_channel: tx_channel,
+        host_provider: host_provider.clone(),
+    };
 
     // Set up tx submission
     let (submit_channel, submit_jh) = submit.spawn();

bin/submit_transaction.rs

@@ -1,3 +1,5 @@
+//! A simple transaction submitter that sends a transaction to a recipient address
+//! on a regular interval for the purposes of roughly testing rollup mining.
 use alloy::{
     network::{EthereumWallet, TransactionBuilder},
     primitives::{Address, U256},
@@ -67,18 +69,29 @@ async fn main() {
     }
 }
 
+/// Sends a transaction to the specified recipient address
 async fn send_transaction(provider: &HostProvider, recipient_address: Address) {
     // construct simple transaction to send ETH to a recipient
+    let nonce = match provider.get_transaction_count(provider.default_signer_address()).await {
+        Ok(count) => count,
+        Err(e) => {
+            error!(error = ?e, "failed to get transaction count");
+            return;
+        }
+    };
+
     let tx = TransactionRequest::default()
         .with_from(provider.default_signer_address())
         .with_to(recipient_address)
         .with_value(U256::from(1))
+        .with_nonce(nonce)
         .with_gas_limit(30_000);
 
     // start timer to measure how long it takes to mine the transaction
     let dispatch_start_time: Instant = Instant::now();
 
     // dispatch the transaction
+    debug!(?tx.nonce, "sending transaction with nonce");
     let result = provider.send_transaction(tx).await.unwrap();
 
     // wait for the transaction to mine
@@ -95,10 +108,13 @@ async fn send_transaction(provider: &HostProvider, recipient_address: Address) {
         }
     };
 
-    let hash = receipt.transaction_hash.to_string();
+    record_metrics(dispatch_start_time, receipt);
+}
 
-    // record metrics for how long it took to mine the transaction
+/// Record metrics for how long it took to mine the transaction
+fn record_metrics(dispatch_start_time: Instant, receipt: alloy::rpc::types::TransactionReceipt) {
     let mine_time = dispatch_start_time.elapsed().as_secs();
+    let hash = receipt.transaction_hash.to_string();
     debug!(success = receipt.status(), mine_time, hash, "transaction mined");
     histogram!("txn_submitter.tx_mine_time").record(mine_time as f64);
 }

src/config.rs

@@ -3,7 +3,7 @@ use crate::{
     tasks::{
         block::cfg::SignetCfgEnv,
         cache::{BundlePoller, CacheSystem, CacheTask, TxPoller},
-        env::EnvTask,
+        env::{EnvTask, SimEnv},
     },
 };
 use alloy::{
@@ -29,7 +29,6 @@ use init4_bin_base::{
 use signet_zenith::Zenith;
 use std::borrow::Cow;
 use tokio::sync::watch;
-use trevm::revm::context::BlockEnv;
 
 /// Type alias for the provider used to simulate against rollup state.
 pub type RuProvider = RootProvider<Ethereum>;
@@ -247,16 +246,16 @@ impl BuilderConfig {
 
     /// Create an [`EnvTask`] using this config.
     pub fn env_task(&self) -> EnvTask {
-        let provider = self.connect_ru_provider();
-        EnvTask::new(self.clone(), provider)
+        let ru_provider = self.connect_ru_provider();
+        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<BlockEnv>>) -> CacheSystem {
+    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();

src/tasks/block/sim.rs

@@ -1,7 +1,10 @@
 //! `block.rs` contains the Simulator and everything that wires it into an
 //! actor that handles the simulation of a stream of bundles and transactions
 //! and turns them into valid Pecorino blocks for network submission.
-use crate::config::{BuilderConfig, RuProvider};
+use crate::{
+    config::{BuilderConfig, RuProvider},
+    tasks::env::SimEnv,
+};
 use alloy::{eips::BlockId, network::Ethereum, providers::Provider};
 use init4_bin_base::{
     deps::tracing::{debug, error},
@@ -17,6 +20,7 @@ use tokio::{
     },
     task::JoinHandle,
 };
+use tracing::info;
 use trevm::revm::{
     context::BlockEnv,
     database::{AlloyDB, WrapDatabaseAsync},
@@ -34,9 +38,17 @@ pub struct Simulator {
     pub config: BuilderConfig,
     /// A provider that cannot sign transactions, used for interacting with the rollup.
     pub ru_provider: RuProvider,
-
     /// The block configuration environment on which to simulate
-    pub block_env: watch::Receiver<Option<BlockEnv>>,
+    pub sim_env: watch::Receiver<Option<SimEnv>>,
+}
+
+/// SimResult bundles a BuiltBlock to the BlockEnv it was simulated against.
+#[derive(Debug, Clone)]
+pub struct SimResult {
+    /// The block built with the successfully simulated transactions
+    pub block: BuiltBlock,
+    /// The block environment the transactions were simulated against.
+    pub env: SimEnv,
 }
 
 impl Simulator {
@@ -46,16 +58,17 @@ impl Simulator {
     ///
     /// - `config`: The configuration for the builder.
     /// - `ru_provider`: A provider for interacting with the rollup.
+    /// - `block_env`: A receiver for the block environment to simulate against.
     ///
     /// # Returns
     ///
     /// A new `Simulator` instance.
     pub fn new(
         config: &BuilderConfig,
         ru_provider: RuProvider,
-        block_env: watch::Receiver<Option<BlockEnv>>,
+        sim_env: watch::Receiver<Option<SimEnv>>,
     ) -> Self {
-        Self { config: config.clone(), ru_provider, block_env }
+        Self { config: config.clone(), ru_provider, sim_env }
     }
 
     /// Get the slot calculator.
@@ -65,11 +78,16 @@ impl Simulator {
 
     /// Handles building a single block.
     ///
+    /// Builds a block in the block environment with items from the simulation cache
+    /// against the database state. When the `finish_by` deadline is reached, it
+    /// stops simulating and returns the block.
+    ///
     /// # Arguments
     ///
     /// - `constants`: The system constants for the rollup.
     /// - `sim_items`: The simulation cache containing transactions and bundles.
     /// - `finish_by`: The deadline by which the block must be built.
+    /// - `block_env`: The block environment to simulate against.
     ///
     /// # Returns
     ///
@@ -79,28 +97,35 @@ impl Simulator {
         constants: SignetSystemConstants,
         sim_items: SimCache,
         finish_by: Instant,
-        block: BlockEnv,
+        block_env: BlockEnv,
     ) -> eyre::Result<BuiltBlock> {
+        debug!(block_number = block_env.number, tx_count = sim_items.len(), "starting block build",);
+
         let db = self.create_db().await.unwrap();
+
         let block_build: BlockBuild<_, NoOpInspector> = BlockBuild::new(
             db,
             constants,
             self.config.cfg_env(),
-            block,
+            block_env,
             finish_by,
             self.config.concurrency_limit,
             sim_items,
             self.config.rollup_block_gas_limit,
         );
 
         let built_block = block_build.build().await;
-        debug!(block_number = ?built_block.block_number(), "finished building block");
+        debug!(
+            tx_count = built_block.tx_count(),
+            block_number = built_block.block_number(),
+            "block simulation completed",
+        );
 
         Ok(built_block)
     }
 
-    /// Spawns the simulator task, which handles the setup and sets the deadline
-    /// for the each round of simulation.
+    /// Spawns the simulator task, which ticks along the simulation loop
+    /// as it receives block environments.
     ///
     /// # Arguments
     ///
@@ -115,21 +140,23 @@ impl Simulator {
         self,
         constants: SignetSystemConstants,
         cache: SimCache,
-        submit_sender: mpsc::UnboundedSender<BuiltBlock>,
+        submit_sender: mpsc::UnboundedSender<SimResult>,
     ) -> JoinHandle<()> {
         debug!("starting simulator task");
 
         tokio::spawn(async move { self.run_simulator(constants, cache, submit_sender).await })
     }
 
-    /// Continuously runs the block simulation and submission loop.
+    /// This function runs indefinitely, waiting for the block environment to be set and checking
+    /// if the current slot is valid before building a block and sending it along for to the submit channel.
     ///
-    /// This function clones the simulation cache, calculates a deadline for block building,
-    /// attempts to build a block using the latest cache and constants, and submits the built
-    /// block through the provided channel. If an error occurs during block building or submission,
-    /// it logs the error and continues the loop.
+    /// If it is authorized for the current slot, then the simulator task
+    /// - clones the simulation cache,
+    /// - calculates a deadline for block building,
+    /// - attempts to build a block using the latest cache and constants,
+    /// - then submits the built block through the provided channel.
     ///
-    /// This function runs indefinitely and never returns.
+    /// If an error occurs during block building or submission, it logs the error and continues the loop.
     ///
     /// # Arguments
     ///
@@ -140,26 +167,29 @@ impl Simulator {
         mut self,
         constants: SignetSystemConstants,
         cache: SimCache,
-        submit_sender: mpsc::UnboundedSender<BuiltBlock>,
+        submit_sender: mpsc::UnboundedSender<SimResult>,
     ) {
         loop {
-            let sim_cache = cache.clone();
-            let finish_by = self.calculate_deadline();
-
             // Wait for the block environment to be set
-            if self.block_env.changed().await.is_err() {
-                error!("block_env channel closed");
+            if self.sim_env.changed().await.is_err() {
+                error!("block_env channel closed - shutting down simulator task");
                 return;
             }
+            let Some(sim_env) = self.sim_env.borrow_and_update().clone() else { return };
+            info!(sim_env.block_env.number, "new block environment received");
 
-            // If no env, skip this run
-            let Some(block_env) = self.block_env.borrow_and_update().clone() else { return };
-            debug!(block_env = ?block_env, "building on block env");
-
-            match self.handle_build(constants, sim_cache, finish_by, block_env).await {
+            // Calculate the deadline for this block simulation.
+            // NB: This must happen _after_ taking a reference to the sim cache,
+            // waiting for a new block, and checking current slot authorization.
+            let finish_by = self.calculate_deadline();
+            let sim_cache = cache.clone();
+            match self
+                .handle_build(constants, sim_cache, finish_by, sim_env.block_env.clone())
+                .await
+            {
                 Ok(block) => {
-                    debug!(block = ?block, "built block");
-                    let _ = submit_sender.send(block);
+                    debug!(block = ?block.block_number(), tx_count = block.transactions().len(), "built simulated block");
+                    let _ = submit_sender.send(SimResult { block, env: sim_env });
                 }
                 Err(e) => {
                     error!(err = %e, "failed to build block");
@@ -184,11 +214,10 @@ impl Simulator {
         let remaining = self.slot_calculator().slot_duration() - timepoint;
 
         // We add a 1500 ms buffer to account for sequencer stopping signing.
-
-        let candidate =
+        let deadline =
             Instant::now() + Duration::from_secs(remaining) - Duration::from_millis(1500);
 
-        candidate.max(Instant::now())
+        deadline.max(Instant::now())
     }
 
     /// Creates an `AlloyDB` instance from the rollup provider.

src/tasks/cache/task.rs

@@ -1,3 +1,4 @@
+use crate::tasks::env::SimEnv;
 use alloy::consensus::TxEnvelope;
 use init4_bin_base::deps::tracing::{debug, info};
 use signet_sim::SimCache;
@@ -6,7 +7,6 @@ use tokio::{
     sync::{mpsc, watch},
     task::JoinHandle,
 };
-use trevm::revm::context::BlockEnv;
 
 /// Cache task for the block builder.
 ///
@@ -16,8 +16,7 @@ use trevm::revm::context::BlockEnv;
 #[derive(Debug)]
 pub struct CacheTask {
     /// The channel to receive the block environment.
-    env: watch::Receiver<Option<BlockEnv>>,
-
+    env: watch::Receiver<Option<SimEnv>>,
     /// The channel to receive the transaction bundles.
     bundles: mpsc::UnboundedReceiver<TxCacheBundle>,
     /// The channel to receive the transactions.
@@ -27,7 +26,7 @@ pub struct CacheTask {
 impl CacheTask {
     /// Create a new cache task with the given cache and channels.
     pub const fn new(
-        env: watch::Receiver<Option<BlockEnv>>,
+        env: watch::Receiver<Option<SimEnv>>,
         bundles: mpsc::UnboundedReceiver<TxCacheBundle>,
         txns: mpsc::UnboundedReceiver<TxEnvelope>,
     ) -> Self {
@@ -45,10 +44,10 @@ impl CacheTask {
                         break;
                     }
                     if let Some(env) = self.env.borrow_and_update().as_ref() {
-                        basefee = env.basefee;
-                        info!(basefee, number = env.number, timestamp = env.timestamp, "block env changed, clearing cache");
+                        basefee = env.block_env.basefee;
+                        info!(basefee, env.block_env.number, env.block_env.timestamp, "rollup block env changed, clearing cache");
                         cache.clean(
-                            env.number, env.timestamp
+                            env.block_env.number, env.block_env.timestamp
                         );
                     }
                 }