fix cfg env

Author: anna-carroll

src/config.rs

@@ -300,11 +300,16 @@ impl BuilderConfig {
         Ok(Quincey::new_remote(client, url, token))
     }
 
-    /// Create a [`SignetCfgEnv`] using this config.
-    pub const fn cfg_env(&self) -> SignetCfgEnv {
+    /// Create a rollup [`SignetCfgEnv`] using this config.
+    pub const fn ru_cfg_env(&self) -> SignetCfgEnv {
         SignetCfgEnv { chain_id: self.ru_chain_id }
     }
 
+    /// Create a host [`SignetCfgEnv`] using this config.
+    pub const fn host_cfg_env(&self) -> SignetCfgEnv {
+        SignetCfgEnv { chain_id: self.host_chain_id }
+    }
+
     /// Memoizes the concurrency limit for the current system. Uses [`std::thread::available_parallelism`] if no
     /// value is set. If that for some reason fails, it returns the default concurrency limit.
     pub fn concurrency_limit(&self) -> usize {

src/tasks/block/sim.rs

@@ -21,10 +21,13 @@ use tokio::{
     task::JoinHandle,
 };
 use tracing::{Instrument, Span, debug, instrument};
-use trevm::revm::{
-    context::BlockEnv,
-    database::{AlloyDB, WrapDatabaseAsync},
-    inspector::NoOpInspector,
+use trevm::{
+    Block,
+    revm::{
+        context::BlockEnv,
+        database::{AlloyDB, WrapDatabaseAsync},
+        inspector::NoOpInspector,
+    },
 };
 
 type HostAlloyDatabaseProvider = WrapDatabaseAsync<AlloyDB<Ethereum, HostProvider>>;
@@ -128,36 +131,43 @@ impl Simulator {
         constants: SignetSystemConstants,
         sim_items: SimCache,
         finish_by: Instant,
-        block_env: BlockEnv,
+        sim_env: SimEnv,
     ) -> eyre::Result<BuiltBlock> {
         let concurrency_limit = self.config.concurrency_limit();
-        let latest_block_number = BlockNumber::from(block_env.number.to::<u64>() - 1);
-        let host_block_number = self.config.constants.rollup_block_to_host_block_num(latest_block_number);
 
+        let host_block_number = BlockNumber::from(sim_env.prev_host.number);
         let host_db = self.create_host_db(host_block_number).await;
+        let mut host_block_env = BlockEnv::default();
+        sim_env.prev_host.fill_block_env(&mut host_block_env);
         let host_env = HostEnv::<_, NoOpInspector>::new(
             host_db,
             constants.clone(),
-            &self.config.cfg_env(),
-            &block_env,
+            &self.config.host_cfg_env(),
+            &host_block_env,
         );
 
-        let rollup_db = self.create_rollup_db(latest_block_number);
+        let rollup_block_number = BlockNumber::from(sim_env.prev_header.number);
+        let rollup_db = self.create_rollup_db(rollup_block_number);
+        let mut rollup_block_env = BlockEnv::default();
+        sim_env.prev_header.fill_block_env(&mut rollup_block_env);
         let rollup_env = RollupEnv::<_, NoOpInspector>::new(
             rollup_db,
             constants,
-            &self.config.cfg_env(),
-            &block_env,
+            &self.config.ru_cfg_env(),
+            &rollup_block_env,
         );
 
+        // TODO
+        let max_host_gas: u64 = 0;
+
         let block_build = BlockBuild::new(
             rollup_env,
             host_env,
             finish_by,
             concurrency_limit,
             sim_items,
             self.config.rollup_block_gas_limit,
-            block_env.gas_limit,
+            max_host_gas,
         );
 
         let built_block = block_build.build().in_current_span().await;
@@ -235,7 +245,7 @@ impl Simulator {
             let sim_cache = cache.clone();
 
             let Ok(block) = self
-                .handle_build(constants.clone(), sim_cache, finish_by, sim_env.block_env.clone())
+                .handle_build(constants.clone(), sim_cache, finish_by, sim_env.clone())
                 .instrument(span.clone())
                 .await
                 .inspect_err(|err| span_error!(span, %err, "error during block build"))