patched with in memory database as workaround for now

Author: dylanlott

Cargo.toml

@@ -28,7 +28,8 @@ 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", "test-utils" ]}
+# trevm = { version = "0.20.4", features = [ "concurrent-db", "test-utils" ]}
+trevm = { path = "../trevm", 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::{cow::CacheOnWrite, sync::{ConcurrentState, ConcurrentStateInfo}}, helpers::Ctx, revm::{
+    db::sync::{ConcurrentState, ConcurrentStateInfo}, helpers::Ctx, revm::{
         context::{
             result::{EVMError, ExecutionResult, ResultAndState}, CfgEnv
         }, primitives::address, state::Account, Database, DatabaseCommit, DatabaseRef, Inspector
-    }, BlockDriver, Cfg, DbConnect, EvmFactory, NoopBlock, TrevmBuilder, TrevmBuilderError, Tx
+    }, Cfg, DbConnect, EvmFactory, NoopBlock, TrevmBuilder, TrevmBuilderError, Tx
 };
 
 /// Tracks the EVM state, score, and result of an EVM execution.
@@ -210,74 +210,6 @@ where
     }
 }
 
-pub trait BlockExtractor<Insp, Db>
-where
-    Db: Database + DatabaseCommit,
-    Insp: Inspector<Ctx<Db>>,
-{
-    /// BlockDriver runs the transactions over the provided trevm instance.
-    type Driver: BlockDriver<Insp, Error<Db>: core::error::Error>;
-
-    /// Instantiate an configure a new [`trevm`] instance.
-    fn trevm(&self, db: Db) -> trevm::EvmNeedsBlock<Db, Insp>;
-
-    /// Extracts transactions from the source.
-    ///
-    /// Extraction is infallible. Worst case it should return a no-op driver.
-    fn extract(&mut self, bytes: &[u8]) -> Self::Driver;
-}
-
-impl<Insp> BlockDriver<Insp> for InProgressBlock {
-    type Block = NoopBlock;
-
-    type Error<Db: Database + DatabaseCommit> = Error<Db>;
-
-    fn block(&self) -> &Self::Block {
-        &NoopBlock
-    }
-
-    /// Loops through the transactions in the block and runs them, accepting the state at the end
-    /// if it was successful and returning and erroring out otherwise.
-    fn run_txns<Db: Database + DatabaseCommit>(
-        &mut self,
-        mut trevm: trevm::EvmNeedsTx<Db, Insp>,
-    ) -> trevm::RunTxResult<Db, Insp, Self>
-    where
-        Insp: Inspector<Ctx<Db>>,
-    {
-        for tx in self.transactions().iter() {
-            if tx.recover_signer().is_ok() {
-                let sender = tx.recover_signer().unwrap();
-                tracing::info!(sender = ?sender, tx_hash = ?tx.tx_hash(), "simulating transaction");
-
-                let t = match trevm.run_tx(tx) {
-                    Ok(t) => t,
-                    Err(e) => {
-                        if e.is_transaction_error() {
-                            return Ok(e.discard_error());
-                        } else {
-                            return Err(e.err_into());
-                        }
-                    }
-                };
-
-                (_, trevm) = t.accept();
-            }
-        }
-        Ok(trevm)
-    }
-
-    fn post_block<Db: Database + DatabaseCommit>(
-        &mut self,
-        _trevm: &trevm::EvmNeedsBlock<Db, Insp>,
-    ) -> Result<(), Self::Error<Db>>
-    where
-        Insp: Inspector<Ctx<Db>>,
-    {
-        Ok(())
-    }
-}
-
 /// Defines the CfgEnv for Pecorino Network
 #[derive(Debug, Clone, Copy)]
 pub struct PecorinoCfg;

tests/simulator_test.rs

@@ -1,70 +1,52 @@
 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 builder::tasks::simulator::SimulatorFactory;
 use std::sync::Arc;
 use tokio::{
     sync::mpsc,
     time::{Duration, Instant},
 };
 use trevm::{
-    db::{
-        cow::CacheOnWrite,
-        sync::{ConcurrentState, ConcurrentStateInfo},
-    },
+    db::cow::CacheOnWrite,
     revm::{
         context::result::{ExecutionResult, ResultAndState},
-        database::{CacheDB, Database, DatabaseCommit, DatabaseRef, AlloyDB, WrapDatabaseAsync},
-        primitives::{TxKind, address},
+        database::InMemoryDB,
         inspector::NoOpInspector,
+        primitives::{address, TxKind},
         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() {
     // Setup transaction pipeline plumbing
     let (tx_sender, tx_receiver) = mpsc::unbounded_channel::<TxEnvelope>();
-    let (_bundle_sender, bundle_receiver) = mpsc::unbounded_channel::<Vec<TxEnvelope>>();
+    let (_bundle_sender, _bundle_receiver) = mpsc::unbounded_channel::<Vec<TxEnvelope>>();
     let deadline = Instant::now() + Duration::from_secs(2);
 
-    // Create a new anvil instance
+    // Create a new anvil instance and test wallets
     let anvil =
         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();
     let test_wallet = &PrivateKeySigner::from(keys[0].clone());
 
-    // Create a root provider on that anvil instance
-    let root_provider = ProviderBuilder::new().on_http(anvil.endpoint_url());
-    let latest = root_provider.get_block_number().await.unwrap();
-
-    // Create an alloyDB from the provider at the latest height
-    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
+    // Create a evaluator
     let evaluator = Arc::new(test_evaluator);
 
-    // Create a simulation factory with the provided DB
-    let sim_factory = SimulatorFactory::new(concurrent_db, NoOpInspector);
+    // Create a database
+    let db = CacheOnWrite::new(InMemoryDB::default());
+
+    // Create a new simulator factory with the given database and inspector
+    let sim_factory = SimulatorFactory::new(db, NoOpInspector);
 
+    // Spawn the simulator actor
     let handle = sim_factory.spawn(tx_receiver, evaluator, deadline);
 
-    // Send some transactions
+    // Send transactions to the simulator
     for count in 0..2 {
         let test_tx = new_test_tx(test_wallet, count).unwrap();
         tx_sender.send(test_tx).unwrap();