WIP: adding a block builder loop test

Author: dylanlott

Cargo.toml

@@ -24,10 +24,10 @@ path = "bin/submit_transaction.rs"
 [dependencies]
 init4-bin-base = { git = "https://github.com/init4tech/bin-base.git" }
 
-signet-zenith = { git = "https://github.com/init4tech/signet-sdk", branch = "prestwich/sim-crate" }
-signet-types = { git = "https://github.com/init4tech/signet-sdk", branch = "prestwich/sim-crate" }
-signet-bundle = { git = "https://github.com/init4tech/signet-sdk", branch = "prestwich/sim-crate" }
-signet-sim = { git = "https://github.com/init4tech/signet-sdk", branch = "prestwich/sim-crate" }
+signet-zenith = { path = "../signet-sdk/crates/zenith" }
+signet-types = { path = "../signet-sdk/crates/types" }
+signet-bundle = { path = "../signet-sdk/crates/bundle" }
+signet-sim = { path = "../signet-sdk/crates/sim" }
 
 trevm = { version = "0.20.10", features = ["concurrent-db", "test-utils"] }
 

bin/builder.rs

@@ -15,13 +15,14 @@ async fn main() -> eyre::Result<()> {
     let span = tracing::info_span!("zenith-builder");
 
     let config = BuilderConfig::load_from_env()?.clone();
-    let host_provider = config.connect_host_provider().await?;
-    let ru_provider = config.connect_ru_provider().await?;
+    let constants = config.load_pecorino_constants();
     let authenticator = Authenticator::new(&config);
 
-    tracing::debug!(rpc_url = config.host_rpc_url.as_ref(), "instantiated provider");
+    let host_provider = config.connect_host_provider().await?;
+    let ru_provider = config.connect_ru_provider().await?;
 
     let sequencer_signer = config.connect_sequencer_signer().await?;
+
     let zenith = config.connect_zenith(host_provider.clone());
 
     let metrics = MetricsTask { host_provider: host_provider.clone() };
@@ -48,7 +49,8 @@ async fn main() -> eyre::Result<()> {
 
     let (submit_channel, submit_jh) = submit.spawn();
 
-    let build_jh = builder.spawn(ru_provider, tx_receiver, bundle_receiver, submit_channel);
+    let build_jh =
+        builder.spawn(constants, ru_provider, tx_receiver, bundle_receiver, submit_channel);
 
     let port = config.builder_port;
     let server = serve_builder_with_span(([0, 0, 0, 0], port), span);

src/config.rs

@@ -1,7 +1,7 @@
 use crate::signer::{LocalOrAws, SignerError};
 use alloy::{
     network::{Ethereum, EthereumWallet},
-    primitives::Address,
+    primitives::{Address, address},
     providers::{
         Identity, ProviderBuilder, RootProvider,
         fillers::{
@@ -10,6 +10,8 @@ use alloy::{
         },
     },
 };
+use eyre::Result;
+use signet_types::config::{HostConfig, PredeployTokens, RollupConfig, SignetSystemConstants};
 use signet_zenith::Zenith;
 use std::{borrow::Cow, env, num, str::FromStr};
 
@@ -37,6 +39,7 @@ const OAUTH_CLIENT_ID: &str = "OAUTH_CLIENT_ID";
 const OAUTH_CLIENT_SECRET: &str = "OAUTH_CLIENT_SECRET";
 const OAUTH_AUTHENTICATE_URL: &str = "OAUTH_AUTHENTICATE_URL";
 const OAUTH_TOKEN_URL: &str = "OAUTH_TOKEN_URL";
+const CONCURRENCY_LIMIT: &str = "CONCURRENCY_LIMIT";
 
 /// Configuration for a builder running a specific rollup on a specific host
 /// chain.
@@ -92,6 +95,8 @@ pub struct BuilderConfig {
     pub oauth_token_url: String,
     /// The oauth token refresh interval in seconds.
     pub oauth_token_refresh_interval: u64,
+    /// The max number of simultaneous block simulations to run.
+    pub concurrency_limit: usize,
 }
 
 /// Error loading the configuration.
@@ -115,6 +120,9 @@ pub enum ConfigError {
     /// Error connecting to the signer
     #[error("failed to connect to signer: {0}")]
     Signer(#[from] SignerError),
+    /// Error parsing the provided genesis file
+    #[error("failed")]
+    Genesis(String),
 }
 
 impl ConfigError {
@@ -184,6 +192,7 @@ impl BuilderConfig {
             oauth_authenticate_url: load_string(OAUTH_AUTHENTICATE_URL)?,
             oauth_token_url: load_string(OAUTH_TOKEN_URL)?,
             oauth_token_refresh_interval: load_u64(AUTH_TOKEN_REFRESH_INTERVAL)?,
+            concurrency_limit: load_u64(CONCURRENCY_LIMIT).map(|v| v as usize).unwrap_or(1000),
         })
     }
 
@@ -244,6 +253,36 @@ impl BuilderConfig {
     pub const fn connect_zenith(&self, provider: Provider) -> ZenithInstance {
         Zenith::new(self.zenith_address, provider)
     }
+
+    /// Loads the Signet system constants for Pecorino.
+    pub fn load_pecorino_constants(&self) -> SignetSystemConstants {
+        let host = HostConfig::new(
+            self.host_chain_id,
+            149984,
+            self.zenith_address,
+            address!("0x4E8cC181805aFC307C83298242271142b8e2f249"),
+            address!("0xd553C4CA4792Af71F4B61231409eaB321c1Dd2Ce"),
+            address!("0x1af3A16857C28917Ab2C4c78Be099fF251669200"),
+            PredeployTokens::new(
+                address!("0x885F8DB528dC8a38aA3DDad9D3F619746B4a6A81"),
+                address!("0x7970D259D4a96764Fa9B23FF0715A35f06f52D1A"),
+                address!("0x7970D259D4a96764Fa9B23FF0715A35f06f52D1A"),
+            ),
+        );
+        let rollup = RollupConfig::new(
+            self.ru_chain_id,
+            address!("0x4E8cC181805aFC307C83298242271142b8e2f249"),
+            address!("0xd553C4CA4792Af71F4B61231409eaB321c1Dd2Ce"),
+            address!("0xe0eDA3701D44511ce419344A4CeD30B52c9Ba231"),
+            PredeployTokens::new(
+                address!("0x0B8BC5e60EE10957E0d1A0d95598fA63E65605e2"),
+                address!("0xF34326d3521F1b07d1aa63729cB14A372f8A737C"),
+                address!("0xE3d7066115f7d6b65F88Dff86288dB4756a7D733"),
+            ),
+        );
+
+        SignetSystemConstants::new(host, rollup)
+    }
 }
 
 /// Load a string from an environment variable.

src/tasks/block.rs

@@ -6,16 +6,20 @@ use crate::{
         tx_poller::TxPoller,
     },
 };
-use alloy::{consensus::TxEnvelope, eips::BlockId, genesis::Genesis};
-use signet_sim::{BlockBuild, BuiltBlock, SimCache};
+use alloy::{consensus::TxEnvelope, eips::BlockId, providers::Provider};
+use signet_sim::{BlockBuild, BuiltBlock, SimCache, SimItem};
 use signet_types::config::SignetSystemConstants;
 use std::time::{Duration, Instant, SystemTime, UNIX_EPOCH};
-use tokio::{select, sync::mpsc, task::JoinHandle};
+use tokio::{
+    select,
+    sync::mpsc::{self, UnboundedReceiver},
+    task::JoinHandle,
+};
 use tracing::{Instrument, info};
 use trevm::{
     NoopBlock, NoopCfg,
     revm::{
-        database::{AlloyDB, CacheDB, WrapDatabaseAsync},
+        database::{AlloyDB, WrapDatabaseAsync},
         inspector::NoOpInspector,
     },
 };
@@ -54,7 +58,6 @@ impl BlockBuilder {
 
     // calculate the duration in seconds until the beginning of the next block slot.
     fn secs_to_next_slot(&self) -> u64 {
-        // TODO: Account for multiple builders and return the time to our next _assigned_ slot here.
         let curr_timestamp: u64 = SystemTime::now().duration_since(UNIX_EPOCH).unwrap().as_secs();
         let current_slot_time = (curr_timestamp - self.config.chain_offset) % ETHEREUM_SLOT_TIME;
         (ETHEREUM_SLOT_TIME - current_slot_time) % ETHEREUM_SLOT_TIME
@@ -69,49 +72,83 @@ impl BlockBuilder {
     /// a handle to the running task.
     pub fn spawn(
         self,
+        constants: SignetSystemConstants,
         ru_provider: WalletlessProvider,
-        mut tx_receiver: mpsc::UnboundedReceiver<TxEnvelope>,
+        mut tx_receiver: UnboundedReceiver<TxEnvelope>,
         mut bundle_receiver: mpsc::UnboundedReceiver<Bundle>,
-        outbound: mpsc::UnboundedSender<BuiltBlock>,
+        block_sender: mpsc::UnboundedSender<BuiltBlock>,
     ) -> JoinHandle<()> {
-        let genesis = Genesis::default();
-        let constants = SignetSystemConstants::try_from_genesis(&genesis).unwrap(); // TODO: get from actual genesis file.
-        let concurrency_limit = 1000;
-        let max_gas = 30_000_000;
-
+        println!("GOT HERE 0");
         tokio::spawn(
             async move {
+                // Create a sim item handler
+                let sim_items = SimCache::new();
+                println!("got here 1");
+
+                tokio::spawn({
+                    let sim_items = sim_items.clone();
+                    async move {
+                        println!("starting up the receiver");
+                        loop {
+                            select! {
+                                tx = tx_receiver.recv() => {
+                                    if let Some(tx) = tx {
+                                        println!("received transaction {}", tx.hash());
+                                        sim_items.add_item(signet_sim::SimItem::Tx(tx.into()));
+                                    }
+                                }
+                                bundle = bundle_receiver.recv() => {
+                                    if let Some(bundle) = bundle {
+                                        println!("received bundle {}", bundle.id);
+                                        sim_items.add_item(SimItem::Bundle(bundle.bundle));
+                                    }
+                                }
+                            }
+                        }
+                    }
+                });
+
+                println!("starting the block builder loop");
+
                 loop {
-                    // setup during slot time dead zone
-                    let alloy_db = AlloyDB::new(ru_provider.clone(), BlockId::from(1));
-                    let wrapped_db = WrapDatabaseAsync::new(alloy_db).unwrap();
-                    let cached_db = CacheDB::new(wrapped_db);
-
-                    let sim_items = SimCache::new();
-
-                    let deadline = Instant::now()
-                        .checked_add(Duration::from_secs(self.secs_to_next_target()))
-                        .unwrap();
-
-                    let block_builder: BlockBuild<_, NoOpInspector> = BlockBuild::new(
-                        cached_db,
-                        constants,
-                        NoopCfg,
-                        NoopBlock,
-                        deadline,
-                        concurrency_limit,
-                        sim_items.clone(),
-                        max_gas,
-                    );
-
-                    // sleep until next buffer time
-                    tokio::time::sleep(Duration::from_secs(self.secs_to_next_target())).await;
-                    info!("beginning block build cycle");
+                    println!("STARTING 1");
+                    // Calculate the next wake up
+                    let buffer = self.secs_to_next_target();
+                    let deadline = Instant::now().checked_add(Duration::from_secs(buffer)).unwrap();
+                    println!("DEADLINE {:?}", deadline.clone());
+
+                    tokio::time::sleep(Duration::from_secs(buffer)).await;
+
+                    // Fetch latest block number from the rollup
+                    let db = match create_db(&ru_provider).await {
+                        Some(value) => value,
+                        None => {
+                            println!("failed to get a database - check runtime type");
+                            continue;
+                        }
+                    };
+
+                    println!("SIM ITEMS LEN {}", sim_items.len());
 
                     tokio::spawn({
-                        let outbound = outbound.clone();
+                        let outbound = block_sender.clone();
+                        let sim_items = sim_items.clone();
+
                         async move {
+                            let block_builder: BlockBuild<_, NoOpInspector> = BlockBuild::new(
+                                db,
+                                constants,
+                                NoopCfg,
+                                NoopBlock,
+                                deadline,
+                                self.config.concurrency_limit.clone(),
+                                sim_items.clone(),
+                                self.config.rollup_block_gas_limit.clone(),
+                            );
+
                             let block = block_builder.build().await;
+                            println!("GOT BLOCK {}", block.contents_hash());
+
                             if let Err(e) = outbound.send(block) {
                                 println!("failed to send built block: {}", e);
                                 tracing::error!(error = %e, "failed to send built block");
@@ -120,28 +157,66 @@ impl BlockBuilder {
                             }
                         }
                     });
-
-                    // Feed it transactions and bundles until deadline
-                    loop {
-                        select! {
-                            tx = tx_receiver.recv() => {
-                                if let Some(tx) = tx {
-                                    sim_items.add_item(tx);
-                                }
-                            }
-                            bundle = bundle_receiver.recv() => {
-                                if let Some(bundle) = bundle {
-                                    sim_items.add_item(bundle.bundle);
-                                }
-                            }
-                            _ = tokio::time::sleep_until(deadline.into()) => {
-                                break;
-                            }
-                        }
-                    }
                 }
             }
             .in_current_span(),
         )
     }
 }
+
+/// Creates an AlloyDB from a rollup provider
+async fn create_db(
+    ru_provider: &alloy::providers::fillers::FillProvider<
+        alloy::providers::fillers::JoinFill<
+            alloy::providers::Identity,
+            alloy::providers::fillers::JoinFill<
+                alloy::providers::fillers::GasFiller,
+                alloy::providers::fillers::JoinFill<
+                    alloy::providers::fillers::BlobGasFiller,
+                    alloy::providers::fillers::JoinFill<
+                        alloy::providers::fillers::NonceFiller,
+                        alloy::providers::fillers::ChainIdFiller,
+                    >,
+                >,
+            >,
+        >,
+        alloy::providers::RootProvider,
+    >,
+) -> Option<
+    WrapDatabaseAsync<
+        AlloyDB<
+            alloy::network::Ethereum,
+            alloy::providers::fillers::FillProvider<
+                alloy::providers::fillers::JoinFill<
+                    alloy::providers::Identity,
+                    alloy::providers::fillers::JoinFill<
+                        alloy::providers::fillers::GasFiller,
+                        alloy::providers::fillers::JoinFill<
+                            alloy::providers::fillers::BlobGasFiller,
+                            alloy::providers::fillers::JoinFill<
+                                alloy::providers::fillers::NonceFiller,
+                                alloy::providers::fillers::ChainIdFiller,
+                            >,
+                        >,
+                    >,
+                >,
+                alloy::providers::RootProvider,
+            >,
+        >,
+    >,
+> {
+    let latest = match ru_provider.get_block_number().await {
+        Ok(block_number) => block_number,
+        Err(e) => {
+            tracing::error!(error = %e, "failed to get latest block number");
+            println!("failed to get latest block number");
+            // Should this do anything else?
+            return None;
+        }
+    };
+    let alloy_db = AlloyDB::new(ru_provider.clone(), BlockId::from(latest));
+    let wrapped_db = WrapDatabaseAsync::new(alloy_db).unwrap_or_else(|| {
+        panic!("failed to acquire async alloy_db; check which runtime you're using")
+    });
+    Some(wrapped_db)
+}

src/tasks/oauth.rs

@@ -168,6 +168,7 @@ mod tests {
             tx_broadcast_urls: vec!["http://localhost:9000".into()],
             oauth_token_refresh_interval: 300, // 5 minutes
             builder_helper_address: Address::default(),
+            concurrency_limit: 1000,
         };
         Ok(config)
     }