fix: continue block integration

Author: prestwich

Cargo.toml

@@ -64,5 +64,4 @@ tokio = { version = "1.36.0", features = ["full", "macros", "rt-multi-thread"] }
 
 async-trait = "0.1.80"
 oauth2 = "4.4.2"
-chrono = "0.4.41"
 tokio-stream = "0.1.17"

bin/builder.rs

@@ -26,7 +26,7 @@ async fn main() -> eyre::Result<()> {
     let (block_env, env_jh) = env_task.spawn();
 
     // Spawn the cache system
-    let cache_system = config.spawn_cache_system(block_env);
+    let cache_system = config.spawn_cache_system(block_env.clone());
 
     // Prep providers and contracts
     let (host_provider, quincey) =
@@ -46,7 +46,7 @@ async fn main() -> eyre::Result<()> {
     let (submit_channel, submit_jh) = submit.spawn();
 
     // Set up the simulator
-    let sim = Simulator::new(&config, ru_provider.clone());
+    let sim = Simulator::new(&config, ru_provider.clone(), block_env);
     let build_jh = sim.spawn_simulator_task(constants, cache_system.sim_cache, submit_channel);
 
     // Start the healthcheck server

src/config.rs

@@ -2,6 +2,7 @@ use crate::{
     quincey::Quincey,
     signer::{LocalOrAws, SignerError},
     tasks::{
+        block::cfg::SignetCfgEnv,
         cache::{BundlePoller, CacheSystem, CacheTask, TxPoller},
         env::EnvTask,
         oauth::{Authenticator, SharedToken},
@@ -278,4 +279,9 @@ impl BuilderConfig {
 
         CacheSystem { cache_task, tx_poller, bundle_poller, sim_cache }
     }
+
+    /// Create a [`SignetCfgEnv`] using this config.
+    pub const fn cfg_env(&self) -> SignetCfgEnv {
+        SignetCfgEnv { chain_id: self.ru_chain_id }
+    }
 }

src/tasks/block/cfg.rs

@@ -1,21 +1,14 @@
 //! This file implements the [`trevm::Cfg`] and [`trevm::Block`] traits for Pecorino blocks.
-use alloy::primitives::{Address, B256, FixedBytes, U256};
-use trevm::{
-    Block,
-    revm::{
-        context::{BlockEnv, CfgEnv},
-        context_interface::block::BlobExcessGasAndPrice,
-        primitives::hardfork::SpecId,
-    },
-};
-
-use crate::config::BuilderConfig;
+use trevm::revm::{context::CfgEnv, primitives::hardfork::SpecId};
 
 /// PecorinoCfg holds network-level configuration values.
 #[derive(Debug, Clone, Copy)]
-pub struct PecorinoCfg {}
+pub struct SignetCfgEnv {
+    /// The chain ID.
+    pub chain_id: u64,
+}
 
-impl trevm::Cfg for PecorinoCfg {
+impl trevm::Cfg for SignetCfgEnv {
     /// Fills the configuration environment with Pecorino-specific values.
     ///
     /// # Arguments
@@ -24,76 +17,7 @@ impl trevm::Cfg for PecorinoCfg {
     fn fill_cfg_env(&self, cfg_env: &mut CfgEnv) {
         let CfgEnv { chain_id, spec, .. } = cfg_env;
 
-        *chain_id = signet_constants::pecorino::RU_CHAIN_ID;
+        *chain_id = self.chain_id;
         *spec = SpecId::default();
     }
 }
-
-/// PecorinoBlockEnv holds block-level configurations for Pecorino blocks.
-#[derive(Debug, Clone, Copy)]
-pub struct PecorinoBlockEnv {
-    /// The block number for this block.
-    pub number: u64,
-    /// The address the block reward should be sent to.
-    pub beneficiary: Address,
-    /// Timestamp for the block.
-    pub timestamp: u64,
-    /// The gas limit for this block environment.
-    pub gas_limit: u64,
-    /// The basefee to use for calculating gas usage.
-    pub basefee: u64,
-    /// The prevrandao to use for this block.
-    pub prevrandao: Option<FixedBytes<32>>,
-}
-
-/// Implements [`trevm::Block`] for the Pecorino block.
-impl Block for PecorinoBlockEnv {
-    /// Fills the block environment with the Pecorino specific values
-    fn fill_block_env(&self, block_env: &mut BlockEnv) {
-        // Destructure the fields off of the block_env and modify them
-        let BlockEnv {
-            number,
-            beneficiary,
-            timestamp,
-            gas_limit,
-            basefee,
-            difficulty,
-            prevrandao,
-            blob_excess_gas_and_price,
-        } = block_env;
-        *number = self.number;
-        *beneficiary = self.beneficiary;
-        *timestamp = self.timestamp;
-        *gas_limit = self.gas_limit;
-        *basefee = self.basefee;
-        *prevrandao = self.prevrandao;
-
-        // NB: The following fields are set to sane defaults because they
-        // are not supported by the rollup
-        *difficulty = U256::ZERO;
-        *blob_excess_gas_and_price =
-            Some(BlobExcessGasAndPrice { excess_blob_gas: 0, blob_gasprice: 0 });
-    }
-}
-
-impl PecorinoBlockEnv {
-    /// Returns a new PecorinoBlockEnv with the specified values.
-    ///
-    /// # Arguments
-    ///
-    /// - config: The BuilderConfig for the builder.
-    /// - number: The block number of this block, usually the latest block number plus 1,
-    ///   unless simulating blocks in the past.
-    /// - timestamp: The timestamp of the block, typically set to the deadline of the
-    ///   block building task.
-    pub fn new(config: BuilderConfig, number: u64, timestamp: u64, basefee: u64) -> Self {
-        PecorinoBlockEnv {
-            number,
-            beneficiary: config.builder_rewards_address,
-            timestamp,
-            gas_limit: config.rollup_block_gas_limit,
-            basefee,
-            prevrandao: Some(B256::random()),
-        }
-    }
-}

src/tasks/block/sim.rs

@@ -1,30 +1,24 @@
 //! `block.rs` contains the Simulator and everything that wires it into an
 //! actor that handles the simulation of a stream of bundles and transactions
 //! and turns them into valid Pecorino blocks for network submission.
-use super::cfg::PecorinoBlockEnv;
-use crate::{
-    config::{BuilderConfig, RuProvider},
-    tasks::block::cfg::PecorinoCfg,
-};
-use alloy::{
-    eips::{BlockId, BlockNumberOrTag::Latest},
-    network::Ethereum,
-    providers::Provider,
-};
-use chrono::{DateTime, Utc};
-use eyre::{Context, bail};
+use crate::config::{BuilderConfig, RuProvider};
+use alloy::{eips::BlockId, network::Ethereum, providers::Provider};
 use init4_bin_base::{
-    deps::tracing::{debug, error, info, warn},
+    deps::tracing::{debug, error},
     utils::calc::SlotCalculator,
 };
 use signet_sim::{BlockBuild, BuiltBlock, SimCache};
 use signet_types::constants::SignetSystemConstants;
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
 use tokio::{
-    sync::mpsc::{self},
+    sync::{
+        mpsc::{self},
+        watch,
+    },
     task::JoinHandle,
 };
 use trevm::revm::{
+    context::BlockEnv,
     database::{AlloyDB, WrapDatabaseAsync},
     inspector::NoOpInspector,
 };
@@ -38,6 +32,9 @@ pub struct Simulator {
     pub config: BuilderConfig,
     /// A provider that cannot sign transactions, used for interacting with the rollup.
     pub ru_provider: RuProvider,
+
+    /// The block configuration environment on which to simulate
+    pub block_env: watch::Receiver<Option<BlockEnv>>,
 }
 
 type AlloyDatabaseProvider = WrapDatabaseAsync<AlloyDB<Ethereum, RuProvider>>;
@@ -53,8 +50,12 @@ impl Simulator {
     /// # Returns
     ///
     /// A new `Simulator` instance.
-    pub fn new(config: &BuilderConfig, ru_provider: RuProvider) -> Self {
-        Self { config: config.clone(), ru_provider }
+    pub fn new(
+        config: &BuilderConfig,
+        ru_provider: RuProvider,
+        block_env: watch::Receiver<Option<BlockEnv>>,
+    ) -> Self {
+        Self { config: config.clone(), ru_provider, block_env }
     }
 
     /// Get the slot calculator.
@@ -78,14 +79,14 @@ impl Simulator {
         constants: SignetSystemConstants,
         sim_items: SimCache,
         finish_by: Instant,
-        block: PecorinoBlockEnv,
+        block: BlockEnv,
     ) -> eyre::Result<BuiltBlock> {
         let db = self.create_db().await.unwrap();
 
         let block_build: BlockBuild<_, NoOpInspector> = BlockBuild::new(
             db,
             constants,
-            PecorinoCfg {},
+            self.config.cfg_env(),
             block,
             finish_by,
             self.config.concurrency_limit,
@@ -146,14 +147,10 @@ impl Simulator {
             let sim_cache = cache.clone();
             let finish_by = self.calculate_deadline();
 
-            let block_env = match self.next_block_env(finish_by).await {
-                Ok(block) => block,
-                Err(err) => {
-                    error!(err = %err, "failed to configure next block");
-                    break;
-                }
-            };
-            info!(block_env = ?block_env, "created block");
+            // If no env, skip this run
+            let Some(block_env) = self.block_env.borrow().clone() else { return };
+
+            debug!(block_env = ?block_env, "building on block");
 
             match self.handle_build(constants, sim_cache, finish_by, block_env).await {
                 Ok(block) => {
@@ -210,68 +207,4 @@ impl Simulator {
         let wrapped_db: AlloyDatabaseProvider = WrapDatabaseAsync::new(alloy_db).unwrap();
         Some(wrapped_db)
     }
-
-    /// Prepares the next block environment.
-    ///
-    /// Prepares the next block environment to load into the simulator by fetching the latest block number,
-    /// assigning the correct next block number, checking the basefee, and setting the timestamp,
-    /// reward address, and gas configuration for the block environment based on builder configuration.
-    ///
-    /// # Arguments
-    ///
-    /// - finish_by: The deadline at which block simulation will end.
-    async fn next_block_env(&self, finish_by: Instant) -> eyre::Result<PecorinoBlockEnv> {
-        let remaining = finish_by.duration_since(Instant::now());
-        let finish_time = SystemTime::now() + remaining;
-        let deadline: DateTime<Utc> = finish_time.into();
-        debug!(deadline = %deadline, "preparing block env");
-
-        // Fetch the latest block number and increment it by 1
-        let latest_block_number = match self.ru_provider.get_block_number().await {
-            Ok(num) => num,
-            Err(err) => {
-                error!(%err, "RPC error during block build");
-                bail!(err)
-            }
-        };
-        debug!(next_block_num = latest_block_number + 1, "preparing block env");
-
-        // Fetch the basefee from previous block to calculate gas for this block
-        let basefee = match self.get_basefee().await? {
-            Some(basefee) => basefee,
-            None => {
-                warn!("get basefee failed - RPC error likely occurred");
-                todo!()
-            }
-        };
-        debug!(basefee = basefee, "setting basefee");
-
-        // Craft the Block environment to pass to the simulator
-        let block_env = PecorinoBlockEnv::new(
-            self.config.clone(),
-            latest_block_number + 1,
-            deadline.timestamp() as u64,
-            basefee,
-        );
-        debug!(block_env = ?block_env, "prepared block env");
-
-        Ok(block_env)
-    }
-
-    /// Returns the basefee of the latest block.
-    ///
-    /// # Returns
-    ///
-    /// The basefee of the previous (latest) block if the request was successful,
-    /// or a sane default if the RPC failed.
-    async fn get_basefee(&self) -> eyre::Result<Option<u64>> {
-        let Some(block) =
-            self.ru_provider.get_block_by_number(Latest).await.wrap_err("basefee error")?
-        else {
-            return Ok(None);
-        };
-
-        debug!(basefee = ?block.header.base_fee_per_gas, "basefee found");
-        Ok(block.header.base_fee_per_gas)
-    }
 }

src/test_utils.rs

@@ -1,22 +1,19 @@
 //! Test utilities for testing builder tasks
-use crate::{config::BuilderConfig, tasks::block::cfg::PecorinoBlockEnv};
+use crate::config::BuilderConfig;
 use alloy::{
     consensus::{SignableTransaction, TxEip1559, TxEnvelope},
-    primitives::{Address, FixedBytes, TxKind, U256},
+    primitives::{Address, B256, TxKind, U256},
     signers::{SignerSync, local::PrivateKeySigner},
 };
-use chrono::{DateTime, Utc};
 use eyre::Result;
 use init4_bin_base::{
     deps::tracing_subscriber::{
         EnvFilter, Layer, fmt, layer::SubscriberExt, registry, util::SubscriberInitExt,
     },
     utils::calc::SlotCalculator,
 };
-use std::{
-    str::FromStr,
-    time::{Instant, SystemTime},
-};
+use std::str::FromStr;
+use trevm::revm::{context::BlockEnv, context_interface::block::BlobExcessGasAndPrice};
 
 /// Sets up a block builder with test values
 pub fn setup_test_config() -> Result<BuilderConfig> {
@@ -87,18 +84,19 @@ pub fn test_block_env(
     config: BuilderConfig,
     number: u64,
     basefee: u64,
-    finish_by: Instant,
-) -> PecorinoBlockEnv {
-    let remaining = finish_by.duration_since(Instant::now());
-    let finish_time = SystemTime::now() + remaining;
-    let deadline: DateTime<Utc> = finish_time.into();
-
-    PecorinoBlockEnv {
+    timestamp: u64,
+) -> BlockEnv {
+    BlockEnv {
         number,
-        beneficiary: Address::repeat_byte(0),
-        timestamp: deadline.timestamp() as u64,
+        beneficiary: Address::repeat_byte(1),
+        timestamp,
         gas_limit: config.rollup_block_gas_limit,
         basefee,
-        prevrandao: Some(FixedBytes::random()),
+        difficulty: U256::ZERO,
+        prevrandao: Some(B256::random()),
+        blob_excess_gas_and_price: Some(BlobExcessGasAndPrice {
+            excess_blob_gas: 0,
+            blob_gasprice: 0,
+        }),
     }
 }