feat: adds host simulation to block build

- bumps bin-base to 0.15.1
- deprecates the BuilderHelper submission call in favor of the
Zenith Block and Block Header
- removes the BuilderHelper submit task
- wires up the HostProvider into the Simulator for host simulation
- cleans up unused code

Author: dylanlott

Cargo.lock

@@ -18,15 +18,15 @@ name = "zenith-builder-example"
 path = "bin/builder.rs"
 
 [dependencies]
-init4-bin-base = { version = "0.13.1", features = ["perms", "aws" ] }
+init4-bin-base = { version = "0.15.1", features = ["perms", "aws" ] }
 
-signet-constants = { version = "0.11.2" }
-signet-sim = { version = "0.11.2" }
-signet-tx-cache = { version = "0.11.2" }
-signet-types = { version = "0.11.2" }
-signet-zenith = { version = "0.11.2" }
+signet-constants = { version = "0.13.0" }
+signet-sim = { version = "0.13.0" }
+signet-tx-cache = { version = "0.13.0" }
+signet-types = { version = "0.13.0" }
+signet-zenith = { version = "0.13.0" }
 
-trevm = { version = "0.29.0", features = ["concurrent-db", "test-utils"] }
+trevm = { version = "0.30.1", features = ["concurrent-db", "test-utils"] }
 
 alloy = { version = "1.0.37", features = [
     "full",
@@ -52,3 +52,15 @@ tracing = "0.1.41"
 tokio = { version = "1.36.0", features = ["full", "macros", "rt-multi-thread"] }
 tokio-stream = "0.1.17"
 url = "2.5.4"
+
+[patch.crates-io]
+signet-constants = { path = "../signet-sdk/crates/constants" }
+signet-types = { path = "../signet-sdk/crates/types" }
+signet-zenith = { path = "../signet-sdk/crates/zenith" }
+signet-sim = { path = "../signet-sdk/crates/sim" }
+signet-evm = { path = "../signet-sdk/crates/evm" }
+signet-extract = { path = "../signet-sdk/crates/extract" }
+signet-journal = { path = "../signet-sdk/crates/journal" }
+signet-tx-cache = { path = "../signet-sdk/crates/tx-cache" }
+signet-bundle = { path = "../signet-sdk/crates/bundle" }
+init4-bin-base = { path = "../bin-base" }

Cargo.toml

@@ -33,7 +33,7 @@ async fn main() -> eyre::Result<()> {
     let cache_system = cache_tasks.spawn();
 
     // Set up the metrics task
-    let metrics = MetricsTask { host_provider };
+    let metrics = MetricsTask { host_provider: host_provider.clone() };
     let (tx_channel, metrics_jh) = metrics.spawn();
 
     // Set up the submit task. This will be either a Flashbots task or a
@@ -42,7 +42,7 @@ async fn main() -> eyre::Result<()> {
     let (submit_channel, submit_jh) = config.spawn_submit_task(tx_channel).await?;
 
     // Set up the simulator
-    let sim = Simulator::new(&config, ru_provider.clone(), block_env);
+    let sim = Simulator::new(&config, host_provider, ru_provider, block_env);
     let build_jh =
         sim.spawn_simulator_task(config.constants.clone(), cache_system.sim_cache, submit_channel);
 

bin/builder.rs

@@ -2,15 +2,15 @@
 //! actor that handles the simulation of a stream of bundles and transactions
 //! and turns them into valid Pecorino blocks for network submission.
 use crate::{
-    config::{BuilderConfig, RuProvider},
+    config::{BuilderConfig, HostProvider, RuProvider},
     tasks::env::SimEnv,
 };
-use alloy::{eips::BlockId, network::Ethereum};
+use alloy::{eips::BlockId, network::Ethereum, primitives::BlockNumber};
 use init4_bin_base::{
     deps::metrics::{counter, histogram},
     utils::calc::SlotCalculator,
 };
-use signet_sim::{BlockBuild, BuiltBlock, SimCache};
+use signet_sim::{BlockBuild, BuiltBlock, HostEnv, RollupEnv, SimCache};
 use signet_types::constants::SignetSystemConstants;
 use std::time::{Duration, Instant};
 use tokio::{
@@ -27,7 +27,8 @@ use trevm::revm::{
     inspector::NoOpInspector,
 };
 
-type AlloyDatabaseProvider = WrapDatabaseAsync<AlloyDB<Ethereum, RuProvider>>;
+type HostAlloyDatabaseProvider = WrapDatabaseAsync<AlloyDB<Ethereum, HostProvider>>;
+type RollupAlloyDatabaseProvider = WrapDatabaseAsync<AlloyDB<Ethereum, RuProvider>>;
 
 /// `Simulator` is responsible for periodically building blocks and submitting them for
 /// signing and inclusion in the blockchain. It wraps a rollup provider and a slot
@@ -36,6 +37,8 @@ type AlloyDatabaseProvider = WrapDatabaseAsync<AlloyDB<Ethereum, RuProvider>>;
 pub struct Simulator {
     /// Configuration for the builder.
     pub config: BuilderConfig,
+    /// Host Provider to interact with the host chain.
+    pub host_provider: HostProvider,
     /// A provider that cannot sign transactions, used for interacting with the rollup.
     pub ru_provider: RuProvider,
     /// The block configuration environment on which to simulate
@@ -88,10 +91,11 @@ impl Simulator {
     /// A new `Simulator` instance.
     pub fn new(
         config: &BuilderConfig,
+        host_provider: HostProvider,
         ru_provider: RuProvider,
         sim_env: watch::Receiver<Option<SimEnv>>,
     ) -> Self {
-        Self { config: config.clone(), ru_provider, sim_env }
+        Self { config: config.clone(), host_provider, ru_provider, sim_env }
     }
 
     /// Get the slot calculator.
@@ -129,17 +133,33 @@ impl Simulator {
         let concurrency_limit = self.config.concurrency_limit();
 
         // NB: Build AlloyDB from the previous block number's state, since block_env maps to the in-progress block
-        let db = self.create_db(block_env.number.to::<u64>() - 1).unwrap();
+        let latest_block_number = BlockNumber::from(block_env.number.to::<u64>() - 1);
 
-        let block_build: BlockBuild<_, NoOpInspector> = BlockBuild::new(
-            db,
+        let max_host_gas = 45_000_000u64;
+
+        let host_db = self.create_host_db(latest_block_number).await;
+        let host_env = HostEnv::<_, NoOpInspector>::new(
+            host_db,
+            constants.clone(),
+            &self.config.cfg_env(),
+            &block_env,
+        );
+        let rollup_db = self.create_rollup_db(latest_block_number);
+        let rollup_env = RollupEnv::<_, NoOpInspector>::new(
+            rollup_db,
             constants,
-            self.config.cfg_env(),
-            block_env,
+            &self.config.cfg_env(),
+            &block_env,
+        );
+
+        let block_build = BlockBuild::new(
+            rollup_env,
+            host_env,
             finish_by,
             concurrency_limit,
             sim_items,
             self.config.rollup_block_gas_limit,
+            max_host_gas,
         );
 
         let built_block = block_build.build().in_current_span().await;
@@ -149,7 +169,7 @@ impl Simulator {
             "block simulation completed",
         );
         counter!("signet.builder.built_blocks").increment(1);
-        histogram!("signet.builder.built_blocks.tx_count").record(built_block.tx_count() as f64);
+        histogram!("signet.builder.built_blocks.tx_count").record(built_block.tx_count() as u32);
 
         Ok(built_block)
     }
@@ -251,12 +271,23 @@ impl Simulator {
         deadline.max(Instant::now())
     }
 
+    /// Creates an `AlloyDB` instnace from the host provider.
+    async fn create_host_db(&self, latest_block_number: u64) -> HostAlloyDatabaseProvider {
+        let alloy_db = AlloyDB::new(self.host_provider.clone(), BlockId::from(latest_block_number));
+
+        // Wrap the AlloyDB instance in a WrapDatabaseAsync and return it.
+        // This is safe to unwrap because the main function sets the proper runtime settings.
+        //
+        // See: https://docs.rs/tokio/latest/tokio/attr.main.html
+        WrapDatabaseAsync::new(alloy_db).unwrap()
+    }
+
     /// Creates an `AlloyDB` instance from the rollup provider.
     ///
     /// # Returns
     ///
     /// An `Option` containing the wrapped database or `None` if an error occurs.
-    fn create_db(&self, latest_block_number: u64) -> Option<AlloyDatabaseProvider> {
+    fn create_rollup_db(&self, latest_block_number: u64) -> RollupAlloyDatabaseProvider {
         // Make an AlloyDB instance from the rollup provider with that latest block number
         let alloy_db: AlloyDB<Ethereum, RuProvider> =
             AlloyDB::new(self.ru_provider.clone(), BlockId::from(latest_block_number));
@@ -265,7 +296,6 @@ impl Simulator {
         // This is safe to unwrap because the main function sets the proper runtime settings.
         //
         // See: https://docs.rs/tokio/latest/tokio/attr.main.html
-        let wrapped_db: AlloyDatabaseProvider = WrapDatabaseAsync::new(alloy_db).unwrap();
-        Some(wrapped_db)
+        WrapDatabaseAsync::new(alloy_db).unwrap()
     }
 }

src/tasks/block/sim.rs

@@ -65,7 +65,7 @@ impl EnvTask {
     pub const fn new(
         config: BuilderConfig,
         host_provider: HostProvider,
-        ru_provider: RuProvider,
+        ru_provider: RuProvider, 
     ) -> Self {
         Self { config, host_provider, ru_provider }
     }

src/tasks/env.rs

@@ -91,7 +91,7 @@ impl FlashbotsTask {
 
         let bundle_body = sim_result
             .block
-            .host_txns()
+            .host_transactions()
             .iter()
             .cloned()
             .chain(std::iter::once(tx_bytes))

src/tasks/submit/flashbots.rs

@@ -14,7 +14,7 @@ use alloy::{
 use init4_bin_base::deps::metrics::counter;
 use signet_sim::BuiltBlock;
 use signet_types::{SignRequest, SignResponse};
-use signet_zenith::BundleHelper;
+use signet_zenith::Zenith;
 use tracing::{Instrument, debug};
 
 /// Preparation logic for transactions issued to the host chain by the
@@ -92,26 +92,32 @@ impl<'a> SubmitPrep<'a> {
         self.quincey_resp().await.map(|resp| &resp.sig).map(utils::extract_signature_components)
     }
 
-    /// Converts the fills in the block to a vector of `FillPermit2`.
-    fn fills(&self) -> Vec<BundleHelper::FillPermit2> {
-        utils::convert_fills(self.block)
-    }
-
     /// Encodes the sidecar and then builds the 4844 blob transaction from the provided header and signature values.
     async fn build_blob_tx(&self) -> eyre::Result<TransactionRequest> {
         let (v, r, s) = self.quincey_signature().await?;
 
-        // Build the block header
-        let header = BundleHelper::BlockHeader {
-            hostBlockNumber: self.sig_request().host_block_number,
+        let header = Zenith::BlockHeader {
             rollupChainId: U256::from(self.config.constants.ru_chain_id()),
+            hostBlockNumber: self.sig_request().host_block_number,
             gasLimit: self.sig_request().gas_limit,
             rewardAddress: self.sig_request().ru_reward_address,
             blockDataHash: *self.block.contents_hash(),
         };
-        debug!(?header.hostBlockNumber, "built rollup block header");
-
-        let data = BundleHelper::submitCall { fills: self.fills(), header, v, r, s }.abi_encode();
+        debug!(?header.hostBlockNumber, "built zenith block header");
+
+        let data = Zenith::submitBlockCall {
+            header,
+            v,
+            r,
+            s,
+            _4: self
+                .block
+                .host_transactions()
+                .iter()
+                .flat_map(|b| b.iter().cloned())
+                .collect::<alloy::primitives::Bytes>(),
+        }
+        .abi_encode();
 
         let sidecar = self.block.encode_blob::<SimpleCoder>().build()?;
 

src/tasks/submit/prep.rs

@@ -4,13 +4,6 @@ use alloy::{
     primitives::{B256, Signature},
     rpc::types::TransactionRequest,
 };
-use signet_sim::BuiltBlock;
-use signet_zenith::BundleHelper::FillPermit2;
-
-// This function converts &[SignedFill] into [FillPermit2]
-pub(crate) fn convert_fills(block: &BuiltBlock) -> Vec<FillPermit2> {
-    block.host_fills().iter().map(FillPermit2::from).collect()
-}
 
 /// Extracts the components of a signature.
 /// Currently alloy has no function for extracting the components of a signature.

src/utils.rs

@@ -41,6 +41,7 @@ async fn test_handle_build() {
 
     // Create a rollup provider
     let ru_provider = RootProvider::<Ethereum>::new_http(anvil_instance.endpoint_url());
+    let host_provider = config.connect_host_provider().await.unwrap();
 
     let block_env = EnvTask::new(
         config.clone(),
@@ -50,7 +51,7 @@ async fn test_handle_build() {
     .spawn()
     .0;
 
-    let block_builder = Simulator::new(&config, ru_provider.clone(), block_env);
+    let block_builder = Simulator::new(&config, host_provider, ru_provider.clone(), block_env);
 
     // Setup a sim cache
     let sim_items = SimCache::new();