fix: env behavior and test env

Author: prestwich

src/tasks/block/sim.rs

@@ -138,7 +138,7 @@ impl Simulator {
     /// - `cache`: The simulation cache containing transactions and bundles.
     /// - `submit_sender`: A channel sender used to submit built blocks.
     async fn run_simulator(
-        self,
+        mut self,
         constants: SignetSystemConstants,
         cache: SimCache,
         submit_sender: mpsc::UnboundedSender<BuiltBlock>,
@@ -147,8 +147,14 @@ impl Simulator {
             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");
+                return;
+            }
+
             // If no env, skip this run
-            let Some(block_env) = self.block_env.borrow().clone() else { return };
+            let Some(block_env) = self.block_env.borrow_and_update().clone() else { return };
 
             debug!(block_env = ?block_env, "building on block");
 

src/tasks/env.rs

@@ -96,11 +96,13 @@ impl EnvTask {
                 }
             };
             span.record("number", previous.number);
+            debug!("retrieved latest block");
 
             let env = self.construct_block_env(&previous);
             debug!(?env, "constructed block env");
             if sender.send(Some(env)).is_err() {
                 // The receiver has been dropped, so we can stop the task.
+                debug!("receiver dropped, stopping task");
                 break;
             }
         }

tests/block_builder_test.rs

@@ -1,132 +1,130 @@
 //! Tests for the block building task.
-#[cfg(test)]
-mod tests {
-    use alloy::{
-        network::Ethereum,
-        node_bindings::Anvil,
-        primitives::U256,
-        providers::{Provider, RootProvider},
-        signers::local::PrivateKeySigner,
-    };
-    use builder::{
-        tasks::{block::sim::Simulator, cache::CacheTask},
-        test_utils::{new_signed_tx, setup_logging, setup_test_config, test_block_env},
-    };
-    use signet_sim::{SimCache, SimItem};
-    use signet_types::constants::SignetSystemConstants;
-    use std::time::{Duration, Instant};
-    use tokio::{sync::mpsc::unbounded_channel, time::timeout};
-
-    /// Tests the `handle_build` method of the `Simulator`.
-    ///
-    /// This test sets up a simulated environment using Anvil, creates a block builder,
-    /// and verifies that the block builder can successfully build a block containing
-    /// transactions from multiple senders.
-    #[cfg(feature = "integration")]
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_handle_build() {
-        use alloy::eips::BlockId;
-
-        setup_logging();
-
-        // Make a test config
-        let config = setup_test_config().unwrap();
-        let constants = SignetSystemConstants::pecorino();
-
-        // Create an anvil instance for testing
-        let anvil_instance = Anvil::new().chain_id(signet_constants::pecorino::RU_CHAIN_ID).spawn();
-
-        // Create a wallet
-        let keys = anvil_instance.keys();
-        let test_key_0 = PrivateKeySigner::from_signing_key(keys[0].clone().into());
-        let test_key_1 = PrivateKeySigner::from_signing_key(keys[1].clone().into());
-
-        // Create a rollup provider
-        let ru_provider = RootProvider::<Ethereum>::new_http(anvil_instance.endpoint_url());
-
-        let block_env = config.env_task().spawn().0;
-
-        let block_builder = Simulator::new(&config, ru_provider.clone(), block_env);
-
-        // Setup a sim cache
-        let sim_items = SimCache::new();
-
-        // 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), 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), 0);
-
-        // Setup the block env
-        let finish_by = Instant::now() + Duration::from_secs(2);
-        let header = ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner;
-        let number = header.number + 1;
-        let timestamp = header.timestamp + config.slot_calculator.slot_duration();
-        let block_env = test_block_env(config, number, 7, timestamp);
-
-        // Spawn the block builder task
-        let got = block_builder.handle_build(constants, sim_items, finish_by, block_env).await;
-
-        // Assert on the built block
-        assert!(got.is_ok());
-        assert!(got.unwrap().tx_count() == 2);
-    }
-
-    /// Tests the full block builder loop, including transaction ingestion and block simulation.
-    ///
-    /// This test sets up a simulated environment using Anvil, creates a block builder,
-    /// and verifies that the builder can process incoming transactions and produce a block
-    /// within a specified timeout.
-    #[ignore = "integration test"]
-    #[tokio::test(flavor = "multi_thread", worker_threads = 2)]
-    async fn test_spawn() {
-        setup_logging();
-
-        // Make a test config
-        let config = setup_test_config().unwrap();
-        let constants = SignetSystemConstants::pecorino();
-
-        // Create an anvil instance for testing
-        let anvil_instance = Anvil::new().chain_id(signet_constants::pecorino::RU_CHAIN_ID).spawn();
-
-        // Create a wallet
-        let keys = anvil_instance.keys();
-        let test_key_0 = PrivateKeySigner::from_signing_key(keys[0].clone().into());
-        let test_key_1 = PrivateKeySigner::from_signing_key(keys[1].clone().into());
-
-        // Plumb inputs for the test setup
-        let (tx_sender, tx_receiver) = unbounded_channel();
-        let (_, bundle_receiver) = unbounded_channel();
-        let (block_sender, mut block_receiver) = unbounded_channel();
-
-        let env_task = config.env_task();
-        let (block_env, _env_jh) = env_task.spawn();
-
-        let cache_task = CacheTask::new(block_env.clone(), bundle_receiver, tx_receiver);
-        let (sim_cache, _cache_jh) = cache_task.spawn();
-
-        // Create a rollup provider
-        let ru_provider = RootProvider::<Ethereum>::new_http(anvil_instance.endpoint_url());
-
-        let sim = Simulator::new(&config, ru_provider.clone(), block_env);
-
-        // Finally, Kick off the block builder task.
-        sim.spawn_simulator_task(constants, sim_cache.clone(), block_sender);
-
-        // Feed in transactions to the tx_sender and wait for the block to be simulated
-        let tx_1 = new_signed_tx(&test_key_0, 0, U256::from(1_f64), 11_000).unwrap();
-        let tx_2 = new_signed_tx(&test_key_1, 0, U256::from(2_f64), 10_000).unwrap();
-        tx_sender.send(tx_1).unwrap();
-        tx_sender.send(tx_2).unwrap();
-
-        // Wait for a block with timeout
-        let result = timeout(Duration::from_secs(5), block_receiver.recv()).await;
-        assert!(result.is_ok(), "Did not receive block within 5 seconds");
 
-        // Assert on the block
-        let block = result.unwrap();
-        assert!(block.is_some(), "Block channel closed without receiving a block");
-        assert!(block.unwrap().tx_count() == 2); // TODO: Why is this failing? I'm seeing EVM errors but haven't tracked them down yet.
-    }
+use alloy::{
+    network::Ethereum,
+    node_bindings::Anvil,
+    primitives::U256,
+    providers::{Provider, RootProvider},
+    signers::local::PrivateKeySigner,
+};
+use builder::{
+    tasks::{block::sim::Simulator, cache::CacheTask},
+    test_utils::{new_signed_tx, setup_logging, setup_test_config, test_block_env},
+};
+use signet_sim::{SimCache, SimItem};
+use signet_types::constants::SignetSystemConstants;
+use std::time::{Duration, Instant};
+use tokio::{sync::mpsc::unbounded_channel, time::timeout};
+
+/// Tests the `handle_build` method of the `Simulator`.
+///
+/// This test sets up a simulated environment using Anvil, creates a block builder,
+/// and verifies that the block builder can successfully build a block containing
+/// transactions from multiple senders.
+#[cfg(feature = "integration")]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_handle_build() {
+    use alloy::eips::BlockId;
+
+    setup_logging();
+
+    // Make a test config
+    let config = setup_test_config().unwrap();
+    let constants = SignetSystemConstants::pecorino();
+
+    // Create an anvil instance for testing
+    let anvil_instance = Anvil::new().chain_id(signet_constants::pecorino::RU_CHAIN_ID).spawn();
+
+    // Create a wallet
+    let keys = anvil_instance.keys();
+    let test_key_0 = PrivateKeySigner::from_signing_key(keys[0].clone().into());
+    let test_key_1 = PrivateKeySigner::from_signing_key(keys[1].clone().into());
+
+    // Create a rollup provider
+    let ru_provider = RootProvider::<Ethereum>::new_http(anvil_instance.endpoint_url());
+
+    let block_env = config.env_task().spawn().0;
+
+    let block_builder = Simulator::new(&config, ru_provider.clone(), block_env);
+
+    // Setup a sim cache
+    let sim_items = SimCache::new();
+
+    // 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), 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), 0);
+
+    // Setup the block env
+    let finish_by = Instant::now() + Duration::from_secs(2);
+    let header = ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner;
+    let number = header.number + 1;
+    let timestamp = header.timestamp + config.slot_calculator.slot_duration();
+    let block_env = test_block_env(config, number, 7, timestamp);
+
+    // Spawn the block builder task
+    let got = block_builder.handle_build(constants, sim_items, finish_by, block_env).await;
+
+    // Assert on the built block
+    assert!(got.is_ok());
+    assert!(got.unwrap().tx_count() == 2);
+}
+
+/// Tests the full block builder loop, including transaction ingestion and block simulation.
+///
+/// This test sets up a simulated environment using Anvil, creates a block builder,
+/// and verifies that the builder can process incoming transactions and produce a block
+/// within a specified timeout.
+#[ignore = "integration test"]
+#[tokio::test(flavor = "multi_thread", worker_threads = 2)]
+async fn test_spawn() {
+    setup_logging();
+
+    // Make a test config
+    let config = setup_test_config().unwrap();
+    let constants = SignetSystemConstants::pecorino();
+
+    // Create an anvil instance for testing
+    let anvil_instance = Anvil::new().chain_id(signet_constants::pecorino::RU_CHAIN_ID).spawn();
+
+    // Create a wallet
+    let keys = anvil_instance.keys();
+    let test_key_0 = PrivateKeySigner::from_signing_key(keys[0].clone().into());
+    let test_key_1 = PrivateKeySigner::from_signing_key(keys[1].clone().into());
+
+    // Plumb inputs for the test setup
+    let (tx_sender, tx_receiver) = unbounded_channel();
+    let (_, bundle_receiver) = unbounded_channel();
+    let (block_sender, mut block_receiver) = unbounded_channel();
+
+    let env_task = config.env_task();
+    let (block_env, _env_jh) = env_task.spawn();
+
+    let cache_task = CacheTask::new(block_env.clone(), bundle_receiver, tx_receiver);
+    let (sim_cache, _cache_jh) = cache_task.spawn();
+
+    // Create a rollup provider
+    let ru_provider = RootProvider::<Ethereum>::new_http(anvil_instance.endpoint_url());
+
+    let sim = Simulator::new(&config, ru_provider.clone(), block_env);
+
+    // Finally, Kick off the block builder task.
+    sim.spawn_simulator_task(constants, sim_cache.clone(), block_sender);
+
+    // Feed in transactions to the tx_sender and wait for the block to be simulated
+    let tx_1 = new_signed_tx(&test_key_0, 0, U256::from(1_f64), 11_000).unwrap();
+    let tx_2 = new_signed_tx(&test_key_1, 0, U256::from(2_f64), 10_000).unwrap();
+    tx_sender.send(tx_1).unwrap();
+    tx_sender.send(tx_2).unwrap();
+
+    // Wait for a block with timeout
+    let result = timeout(Duration::from_secs(5), block_receiver.recv()).await;
+    assert!(result.is_ok(), "Did not receive block within 5 seconds");
+
+    // Assert on the block
+    let block = result.unwrap();
+    assert!(block.is_some(), "Block channel closed without receiving a block");
+    assert!(block.unwrap().tx_count() == 2); // TODO: Why is this failing? I'm seeing EVM errors but haven't tracked them down yet.
 }

tests/bundle_poller_test.rs

@@ -1,17 +1,15 @@
-mod tests {
-    use builder::{tasks::oauth::Authenticator, test_utils};
-    use eyre::Result;
+use builder::{tasks::oauth::Authenticator, test_utils};
+use eyre::Result;
 
-    #[ignore = "integration test"]
-    #[tokio::test]
-    async fn test_bundle_poller_roundtrip() -> Result<()> {
-        let config = test_utils::setup_test_config().unwrap();
-        let auth = Authenticator::new(&config)?;
+#[ignore = "integration test"]
+#[tokio::test]
+async fn test_bundle_poller_roundtrip() -> Result<()> {
+    let config = test_utils::setup_test_config().unwrap();
+    let auth = Authenticator::new(&config)?;
 
-        let mut bundle_poller = builder::tasks::cache::BundlePoller::new(&config, auth.token());
+    let mut bundle_poller = builder::tasks::cache::BundlePoller::new(&config, auth.token());
 
-        let _ = bundle_poller.check_bundle_cache().await?;
+    let _ = bundle_poller.check_bundle_cache().await?;
 
-        Ok(())
-    }
+    Ok(())
 }

tests/env.rs

@@ -0,0 +1,15 @@
+use builder::test_utils::{setup_logging, setup_test_config};
+
+#[ignore = "integration test. This test will take between 0 and 12 seconds to run."]
+#[tokio::test]
+async fn test_bundle_poller_roundtrip() {
+    setup_logging();
+
+    let config = setup_test_config().unwrap();
+    let env_task = config.env_task();
+    let (mut env_watcher, _jh) = env_task.spawn();
+
+    env_watcher.changed().await.unwrap();
+    let env = env_watcher.borrow_and_update();
+    assert!(env.as_ref().is_some(), "Env should be Some");
+}