refactor sim envs to hold Env objects instead of Box<dyn _> (#60)

* refactor: change sim to hold envs instead of boxdyns, set block number

* lint: fmt

Author: prestwich

crates/sim/src/built.rs

@@ -38,34 +38,28 @@ impl fmt::Debug for BuiltBlock {
             .field("transactions", &self.transactions.len())
             .field("gas_used", &self.gas_used)
             .field("block_number", &self.block_number)
-            .field("hash", &self.contents_hash())
-            .finish()
+            .finish_non_exhaustive()
     }
 }
 
 impl BuiltBlock {
     /// Create a new `BuiltBlock`
-    pub const fn new() -> Self {
+    pub const fn new(block_number: u64) -> Self {
         Self {
             host_fills: Vec::new(),
             transactions: Vec::new(),
-            block_number: 0,
+            block_number,
             gas_used: 0,
             raw_encoding: OnceLock::new(),
             hash: OnceLock::new(),
         }
     }
 
     /// Gets the block number for the block.
-    pub fn block_number(&self) -> u64 {
+    pub const fn block_number(&self) -> u64 {
         self.block_number
     }
 
-    /// Sets the block number for the block.
-    pub fn set_block_number(&mut self, block_number: u64) {
-        self.block_number = block_number;
-    }
-
     /// Get the amount of gas used by the block.
     pub const fn gas_used(&self) -> u64 {
         self.gas_used

crates/sim/src/env.rs

@@ -9,13 +9,16 @@ use tokio::{
     select,
     sync::{mpsc, watch},
 };
-use tracing::{instrument, trace, trace_span};
+use tracing::{instrument, error, trace, trace_span};
 use trevm::{
     db::{cow::CacheOnWrite, TryCachingDb},
     helpers::Ctx,
     inspectors::{Layered, TimeLimit},
     revm::{
-        context::result::{EVMError, ExecutionResult},
+        context::{
+            result::{EVMError, ExecutionResult},
+            BlockEnv, CfgEnv,
+        },
         database::{Cache, CacheDB},
         inspector::NoOpInspector,
         DatabaseRef, Inspector,
@@ -63,15 +66,19 @@ where
     Insp: Inspector<Ctx<SimDb<Db>>> + Default + Sync + 'static,
 {
     /// Creates a new `SimEnv` instance.
-    pub fn new(
+    pub fn new<C, B>(
         db: Db,
         constants: SignetSystemConstants,
-        cfg: Box<dyn Cfg>,
-        block: Box<dyn Block>,
+        cfg: C,
+        block: B,
         finish_by: std::time::Instant,
         concurrency_limit: usize,
         sim_items: SimCache,
-    ) -> Self {
+    ) -> Self
+    where
+        C: Cfg,
+        B: Block,
+    {
         SimEnv::new(db, constants, cfg, block, finish_by, concurrency_limit, sim_items).into()
     }
 
@@ -125,10 +132,10 @@ pub struct SimEnv<Db, Insp = NoOpInspector> {
     constants: SignetSystemConstants,
 
     /// Chain cfg to use for the simulation.
-    cfg: Box<dyn Cfg>,
+    cfg: CfgEnv,
 
     /// Block to use for the simulation.
-    block: Box<dyn Block>,
+    block: BlockEnv,
 
     /// The instant by which the simulation should finish.
     finish_by: std::time::Instant,
@@ -151,15 +158,24 @@ impl<Db, Insp> fmt::Debug for SimEnv<Db, Insp> {
 
 impl<Db, Insp> SimEnv<Db, Insp> {
     /// Creates a new `SimFactory` instance.
-    pub fn new(
+    pub fn new<C, B>(
         db: Db,
         constants: SignetSystemConstants,
-        cfg: Box<dyn Cfg>,
-        block: Box<dyn Block>,
+        cfg_ref: C,
+        block_ref: B,
         finish_by: std::time::Instant,
         concurrency_limit: usize,
         sim_items: SimCache,
-    ) -> Self {
+    ) -> Self
+    where
+        C: Cfg,
+        B: Block,
+    {
+        let mut cfg = CfgEnv::default();
+        cfg_ref.fill_cfg_env(&mut cfg);
+        let mut block = BlockEnv::default();
+        block_ref.fill_block_env(&mut block);
+
         Self {
             db: Arc::new(CacheDB::new(db)),
             constants,
@@ -188,12 +204,12 @@ impl<Db, Insp> SimEnv<Db, Insp> {
     }
 
     /// Get a reference to the chain cfg.
-    pub fn cfg(&self) -> &dyn Cfg {
+    pub const fn cfg(&self) -> &CfgEnv {
         &self.cfg
     }
 
     /// Get a reference to the block.
-    pub fn block(&self) -> &dyn Block {
+    pub const fn block(&self) -> &BlockEnv {
         &self.block
     }
 
@@ -298,7 +314,10 @@ where
                 // Create the outcome
                 Ok(SimOutcomeWithCache { identifier, score, cache, gas_used })
             }
-            Err(e) => Err(SignetEthBundleError::from(e.into_error())),
+            Err(e) => {
+                error!(err = ?e.error(), "simulation error details");
+                Err(SignetEthBundleError::from(e.into_error()))
+            }
         }
     }
 

crates/sim/src/task.rs

@@ -42,12 +42,9 @@ where
         max_gas: u64,
     ) -> Self
     where
-        C: Cfg + 'static,
-        B: Block + 'static,
+        C: Cfg,
+        B: Block,
     {
-        let cfg: Box<dyn Cfg> = Box::new(cfg);
-        let block: Box<dyn Block> = Box::new(block);
-
         let env = SimEnv::<Db, Insp>::new(
             db,
             constants,
@@ -58,7 +55,8 @@ where
             sim_items,
         );
         let finish_by = env.finish_by();
-        Self { env: env.into(), block: BuiltBlock::new(), finish_by, max_gas }
+        let number = env.block().number;
+        Self { env: env.into(), block: BuiltBlock::new(number), finish_by, max_gas }
     }
 
     /// Run a simulation round, and accumulate the results into the block.