wip: figuring out database trait bounds

Author: dylanlott

Cargo.toml

@@ -28,7 +28,7 @@ signet-bundle = { git = "https://github.com/init4tech/signet-sdk", branch = "mai
 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.20.4", features = [ "concurrent-db" ]}
+trevm = { version = "0.20.4", features = [ "concurrent-db", "test-utils" ]}
 
 alloy = { version = "0.12.6", features = [
     "full",

src/tasks/simulator.rs

@@ -5,11 +5,11 @@ use eyre::Result;
 use std::sync::Arc;
 use tokio::{select, sync::mpsc::UnboundedReceiver, task::JoinSet};
 use trevm::{
-    db::sync::{ConcurrentState, ConcurrentStateInfo}, helpers::Ctx, revm::{
+    db::{cow::CacheOnWrite, sync::{ConcurrentState, ConcurrentStateInfo}}, helpers::Ctx, revm::{
         context::{
             result::{EVMError, ExecutionResult, ResultAndState}, CfgEnv
-        }, inspector::inspectors::GasInspector, primitives::address, state::Account, Database, DatabaseCommit, DatabaseRef, Inspector
-    }, BlockDriver, Cfg, DbConnect, EvmFactory, NoopBlock, Trevm, TrevmBuilder, TrevmBuilderError, Tx
+        }, primitives::address, state::Account, Database, DatabaseCommit, DatabaseRef, Inspector
+    }, BlockDriver, Cfg, DbConnect, EvmFactory, NoopBlock, TrevmBuilder, TrevmBuilderError, Tx
 };
 
 /// Tracks the EVM state, score, and result of an EVM execution.
@@ -25,7 +25,7 @@ pub struct Best<T, S: PartialOrd + Ord = U256> {
     pub score: S,
 }
 
-/// Binds a database and an extension together.
+/// Binds a database and an inspector together for simulation.
 #[derive(Debug, Clone)]
 pub struct SimulatorFactory<Db, Insp> {
     /// The database state the execution is carried out on.
@@ -40,10 +40,15 @@ type SimResult<Db> = Result<Option<(Best<TxEnvelope>, ConcurrentState<Arc<Concur
 
 impl<Db, Insp> SimulatorFactory<Db, Insp>
 where
-    Insp: Inspector<Ctx<ConcurrentState<Db>>> + Send + Sync + Clone + 'static,
+    Insp: Inspector<Ctx<ConcurrentState<Db>>>
+        + Inspector<Ctx<ConcurrentState<Arc<ConcurrentState<Db>>>>>
+        + Send
+        + Sync
+        + Clone
+        + 'static,
     Db: Database + DatabaseRef + DatabaseCommit + Send + Sync + Clone + 'static,
 {
-    /// Creates a new Simulator factory out of the database and extension.
+    /// Creates a new Simulator factory from the provided database and inspector.
     pub const fn new(db: Db, inspector: Insp) -> Self {
         Self { db, inspector }
     }

tests/simulator_test.rs

@@ -1,19 +1,34 @@
-use alloy::consensus::{SignableTransaction as _, TxEip1559, TxEnvelope};
-use alloy::network::Ethereum;
-use alloy::primitives::U256;
-use alloy::signers::local::PrivateKeySigner;
-use alloy::signers::SignerSync as _;
-use alloy::transports::http::{Client, Http};
-use builder::config::WalletlessProvider;
-use builder::tasks::simulator::SimulatorFactory;
-use trevm::revm::database::{AlloyDB, CacheDB};
-use trevm::revm::primitives::{address, TxKind};
+use alloy::{
+    consensus::{SignableTransaction as _, TxEip1559, TxEnvelope},
+    eips::BlockId,
+    network::Ethereum,
+    primitives::U256,
+    providers::{Provider, ProviderBuilder},
+    signers::SignerSync as _,
+    signers::local::PrivateKeySigner,
+};
+use builder::{config::WalletlessProvider, tasks::simulator::SimulatorFactory};
 use std::sync::Arc;
-use tokio::sync::mpsc;
-use tokio::time::{Duration, Instant};
-use trevm::revm::primitives::{Account, ExecutionResult, ResultAndState};
-use alloy::eips::BlockId;
-use alloy::providers::{Provider, ProviderBuilder};
+use tokio::{
+    sync::mpsc,
+    time::{Duration, Instant},
+};
+use trevm::{
+    db::{
+        cow::CacheOnWrite,
+        sync::{ConcurrentState, ConcurrentStateInfo},
+    },
+    revm::{
+        context::result::{ExecutionResult, ResultAndState},
+        database::{CacheDB, Database, DatabaseCommit, DatabaseRef, AlloyDB, WrapDatabaseAsync},
+        primitives::{TxKind, address},
+        inspector::NoOpInspector,
+        state::Account,
+    },
+};
+
+// Define a type alias for the database used with SimulatorFactory.
+type Db = WrapDatabaseAsync<AlloyDB<Ethereum, WalletlessProvider>>;
 
 #[tokio::test(flavor = "multi_thread")]
 async fn test_spawn() {
@@ -24,7 +39,7 @@ async fn test_spawn() {
 
     // Create a new anvil instance
     let anvil =
-        alloy::node_bindings::Anvil::new().block_time(1).chain_id(17003).try_spawn().unwrap();
+        alloy::node_bindings::Anvil::new().block_time(1).chain_id(14174).try_spawn().unwrap();
 
     // Create a test wallet from the anvil keys
     let keys = anvil.keys();
@@ -35,20 +50,19 @@ async fn test_spawn() {
     let latest = root_provider.get_block_number().await.unwrap();
 
     // Create an alloyDB from the provider at the latest height
-    let alloy_db: AlloyDB<Http<Client>, Ethereum, Arc<WalletlessProvider>> =
-        AlloyDB::new(Arc::new(root_provider.clone()), BlockId::Number(latest.into())).unwrap();
-    let db = CacheDB::new(Arc::new(alloy_db));
-
-    // Define trevm extension, if any
-    let ext = ();
+    let alloy_db: AlloyDB<Ethereum, WalletlessProvider> =
+        AlloyDB::new(root_provider.clone(), BlockId::from(latest));
 
+    let wrapped_db = WrapDatabaseAsync::new(alloy_db).unwrap();
+    let concurrent_db = ConcurrentState::new(wrapped_db, ConcurrentStateInfo::default());
+    
     // Define the evaluator function
     let evaluator = Arc::new(test_evaluator);
 
     // Create a simulation factory with the provided DB
-    let sim_factory = SimulatorFactory::new(db, ext);
-    let handle =
-        sim_factory.spawn::<TxEnvelope, _>(tx_receiver, evaluator, deadline);
+    let sim_factory = SimulatorFactory::new(concurrent_db, NoOpInspector);
+
+    let handle = sim_factory.spawn(tx_receiver, evaluator, deadline);
 
     // Send some transactions
     for count in 0..2 {