tests: add load tests to the cache ingestion and simulation loop

Author: dylanlott

Cargo.lock

@@ -61,6 +61,7 @@ url = "2.5.4"
 [dev-dependencies]
 alloy-hardforks = "0.4.0"
 alloy-chains = "0.2"
+signet-bundle = "0.16.0-rc.11"
 
 # comment / uncomment for local dev
 # [patch.crates-io]

Cargo.toml

@@ -51,7 +51,8 @@ impl CacheTask {
                         basefee = sim_env.basefee;
                         info!(
                             basefee,
-                            block_env_number = sim_env.number.to::<u64>(), block_env_timestamp = sim_env.timestamp.to::<u64>(),
+                            block_env_number = sim_env.number.to::<u64>(),
+                            block_env_timestamp = sim_env.timestamp.to::<u64>(),
                             "rollup block env changed, clearing cache"
                         );
                         cache.clean(

src/tasks/cache/task.rs

@@ -3,7 +3,7 @@
 //! for testing block simulation.
 
 use super::{
-    db::TestDb,
+    db::{TestDb, TestStateSource},
     env::{TestHostEnv, TestRollupEnv, TestSimEnvBuilder},
 };
 use signet_sim::{BlockBuild, BuiltBlock, SimCache};
@@ -12,7 +12,8 @@ use tokio::time::Instant;
 use trevm::revm::inspector::NoOpInspector;
 
 /// Test block builder type using in-memory databases.
-pub type TestBlockBuild = BlockBuild<TestDb, TestDb, NoOpInspector, NoOpInspector>;
+pub type TestBlockBuild =
+    BlockBuild<TestDb, TestDb, TestStateSource, TestStateSource, NoOpInspector, NoOpInspector>;
 
 /// Builder for creating test `BlockBuild` instances.
 /// Configures all the parameters needed for block simulation
@@ -110,12 +111,13 @@ impl TestBlockBuildBuilder {
     /// This creates a `BlockBuild` ready for simulation.
     /// Call `.build().await` on the result to execute the simulation and get a `BuiltBlock`.
     pub fn build(self) -> TestBlockBuild {
+        let builder = self.sim_env_builder.unwrap_or_default();
+        let ru_state_source = TestStateSource::new(builder.rollup_db());
+        let host_state_source = TestStateSource::new(builder.host_db());
+
         let (rollup_env, host_env) = match (self.rollup_env, self.host_env) {
             (Some(rollup), Some(host)) => (rollup, host),
-            _ => {
-                let builder = self.sim_env_builder.unwrap_or_default();
-                builder.build()
-            }
+            _ => builder.build(),
         };
 
         let finish_by = Instant::now() + self.deadline_duration;
@@ -128,6 +130,8 @@ impl TestBlockBuildBuilder {
             self.sim_cache,
             self.max_gas,
             self.max_host_gas,
+            ru_state_source,
+            host_state_source,
         )
     }
 }

src/test_utils/block.rs

@@ -3,8 +3,10 @@
 //! for testing block simulation without requiring network access.
 
 use alloy::primitives::{Address, B256, U256};
+use signet_sim::{AcctInfo, StateSource};
 use trevm::revm::{
     database::{CacheDB, EmptyDB},
+    database_interface::DatabaseRef,
     state::AccountInfo,
 };
 
@@ -14,6 +16,36 @@ use trevm::revm::{
 /// with `RollupEnv` and `HostEnv` for offline simulation testing.
 pub type TestDb = CacheDB<EmptyDB>;
 
+/// A [`StateSource`] for testing backed by an in-memory [`TestDb`].
+/// Returns actual account info (nonce, balance) from the database,
+/// which is required for preflight validity checks during simulation.
+#[derive(Debug, Clone)]
+pub struct TestStateSource {
+    db: TestDb,
+}
+
+impl TestStateSource {
+    /// Create a new `TestStateSource` backed by the given database.
+    pub const fn new(db: TestDb) -> Self {
+        Self { db }
+    }
+}
+
+impl StateSource for TestStateSource {
+    type Error = std::convert::Infallible;
+
+    async fn account_details(&self, address: &Address) -> Result<AcctInfo, Self::Error> {
+        match self.db.basic_ref(*address) {
+            Ok(Some(info)) => Ok(AcctInfo {
+                nonce: info.nonce,
+                balance: info.balance,
+                has_code: info.code_hash != trevm::revm::primitives::KECCAK_EMPTY,
+            }),
+            _ => Ok(AcctInfo { nonce: 0, balance: U256::ZERO, has_code: false }),
+        }
+    }
+}
+
 /// Builder for creating pre-populated test databases.
 /// Use this builder to set up blockchain state (accounts, contracts, storage)
 /// before running simulations.

src/test_utils/db.rs

@@ -117,6 +117,16 @@ impl TestSimEnvBuilder {
         HostEnv::new(self.host_db.clone(), self.constants.clone(), &cfg, &self.host_block_env)
     }
 
+    /// Get a clone of the rollup database.
+    pub fn rollup_db(&self) -> TestDb {
+        self.rollup_db.clone()
+    }
+
+    /// Get a clone of the host database.
+    pub fn host_db(&self) -> TestDb {
+        self.host_db.clone()
+    }
+
     /// Build both environments as a tuple.
     pub fn build(self) -> (TestRollupEnv, TestHostEnv) {
         let rollup = self.build_rollup_env();