host env and rollup env fixes

- properly builds a cfg env and block env from prev host header
- makes max host gas a configurable property
- cleans up the build prep in the sim loop

Author: dylanlott

src/config.rs

@@ -185,6 +185,15 @@ pub struct BuilderConfig {
     )]
     pub concurrency_limit: Option<usize>,
 
+    /// Optional maximum host gas coefficient to use when building blocks.
+    /// Defaults to 80% (80) if not set.
+    #[from_env(
+        var = "MAX_HOST_GAS_COEFFICIENT",
+        desc = "Optional maximum host gas coefficient, as a percentage, to use when building blocks",
+        default = 80
+    )]
+    pub max_host_gas_coefficient: Option<u8>,
+
     /// The slot calculator for the builder.
     pub slot_calculator: SlotCalculator,
 
@@ -328,6 +337,15 @@ impl BuilderConfig {
         })
     }
 
+    /// Returns the maximum host gas to use for block building based on the configured max host gas coefficient.
+    pub fn max_host_gas(&self, gas_limit: u64) -> u64 {
+        // Set max host gas to a percentage of the host block gas limit
+        let max_host_gas = ((gas_limit as u128
+            * (self.max_host_gas_coefficient.unwrap_or(80) as u128))
+            / 100u128) as u64;
+        max_host_gas
+    }
+
     /// Spawn a submit task, either Flashbots or BuilderHelper depending on
     /// configuration.
     pub async fn spawn_submit_task(

src/tasks/block/sim.rs

@@ -135,30 +135,9 @@ impl Simulator {
     ) -> eyre::Result<BuiltBlock> {
         let concurrency_limit = self.config.concurrency_limit();
 
-        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.host_cfg_env(),
-            &host_block_env,
-        );
+        let (rollup_env, host_env) = self.create_envs(constants, &sim_env).await;
 
-        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.ru_cfg_env(),
-            &rollup_block_env,
-        );
-
-        // TODO
-        let max_host_gas: u64 = 0;
+        let max_host_gas = self.config.max_host_gas(sim_env.prev_host.gas_limit);
 
         let block_build = BlockBuild::new(
             rollup_env,
@@ -182,6 +161,44 @@ impl Simulator {
         Ok(built_block)
     }
 
+    // Helper to create rollup + host envs from the sim env.
+    async fn create_envs(
+        &self,
+        constants: SignetSystemConstants,
+        sim_env: &SimEnv,
+    ) -> (
+        RollupEnv<RollupAlloyDatabaseProvider, NoOpInspector>,
+        HostEnv<HostAlloyDatabaseProvider, NoOpInspector>,
+    ) {
+        // Host DB and Env
+        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::<HostAlloyDatabaseProvider, NoOpInspector>::new(
+            host_db,
+            constants.clone(),
+            &self.config.host_cfg_env(),
+            &host_block_env,
+        );
+
+        // Rollup DB and Env
+        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::<RollupAlloyDatabaseProvider, NoOpInspector>::new(
+            rollup_db,
+            constants,
+            &self.config.ru_cfg_env(),
+            &rollup_block_env,
+        );
+
+        (rollup_env, host_env)
+    }
+
     /// Spawns the simulator task, which ticks along the simulation loop
     /// as it receives block environments.
     ///

src/test_utils.rs

@@ -58,6 +58,7 @@ pub fn setup_test_config() -> Result<BuilderConfig> {
             1740681556, // pecorino start timestamp as sane default
             0, 1,
         ),
+        max_host_gas_coefficient: Some(80),
         constants: SignetSystemConstants::pecorino(),
     };
     Ok(config)

tests/block_builder_test.rs

@@ -8,7 +8,7 @@ use alloy::{
     signers::local::PrivateKeySigner,
 };
 use builder::{
-    tasks::{block::sim::Simulator, env::EnvTask},
+    tasks::{block::sim::Simulator, env::{EnvTask, SimEnv}},
     test_utils::{new_signed_tx, setup_logging, setup_test_config, test_block_env},
 };
 use signet_sim::SimCache;
@@ -51,7 +51,7 @@ async fn test_handle_build() {
     .spawn()
     .0;
 
-    let block_builder = Simulator::new(&config, host_provider, ru_provider.clone(), block_env);
+    let block_builder = Simulator::new(&config, host_provider.clone(), ru_provider.clone(), block_env);
 
     // Setup a sim cache
     let sim_items = SimCache::new();
@@ -63,15 +63,22 @@ async fn test_handle_build() {
     let tx_2 = new_signed_tx(&test_key_1, 0, U256::from(2_f64), 10_000).unwrap();
     sim_items.add_tx(tx_2, 0);
 
-    // Setup the block env
+    // Setup the block envs
     let finish_by = Instant::now() + Duration::from_secs(2);
-    let header = ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner;
-    let number = header.number + 1;
-    let timestamp = header.timestamp + config.slot_calculator.slot_duration();
+    let host_header = host_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header;
+    let ru_header = ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner;
+    let number = ru_header.number + 1;
+    let timestamp = ru_header.timestamp + config.slot_calculator.slot_duration();
     let block_env = test_block_env(config, number, 7, timestamp);
 
     // Spawn the block builder task
-    let got = block_builder.handle_build(constants, sim_items, finish_by, block_env).await;
+    let sim_env = SimEnv {
+        block_env: block_env.clone(),
+        prev_header: ru_header.clone(),
+        prev_host: host_header.into(),
+        span: tracing::Span::none(),
+    };
+    let got = block_builder.handle_build(constants, sim_items, finish_by, sim_env).await;
 
     // Assert on the built block
     assert!(got.is_ok());