[feat] adds simulation to block loop

Cargo.toml

@@ -22,11 +22,24 @@ name = "transaction-submitter"
 path = "bin/submit_transaction.rs"
 
 [dependencies]
-init4-bin-base = "0.1.0"
+init4-bin-base = { git = "https://github.com/init4tech/bin-base.git" }
 
-zenith-types = "0.13"
+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" }
 
-alloy = { version = "0.7.3", features = ["full", "json-rpc", "signer-aws", "rpc-types-mev", "rlp"] }
+trevm = { version = "0.20.10", features = ["concurrent-db", "test-utils"] }
+
+alloy = { version = "0.12.6", features = [
+    "full",
+    "json-rpc",
+    "signer-aws",
+    "rpc-types-mev",
+    "rlp",
+    "node-bindings",
+    "serde",
+] }
 
 aws-config = "1.1.7"
 aws-sdk-kms = "1.15.0"
@@ -48,3 +61,4 @@ tokio = { version = "1.36.0", features = ["full", "macros", "rt-multi-thread"] }
 
 async-trait = "0.1.80"
 oauth2 = "4.4.2"
+tracing-subscriber = "0.3.19"

bin/builder.rs

@@ -1,12 +1,14 @@
-#![allow(dead_code)]
-
-use builder::config::BuilderConfig;
-use builder::service::serve_builder_with_span;
-use builder::tasks::block::BlockBuilder;
-use builder::tasks::metrics::MetricsTask;
-use builder::tasks::oauth::Authenticator;
-use builder::tasks::submit::SubmitTask;
-
+use builder::{
+    config::BuilderConfig,
+    service::serve_builder_with_span,
+    tasks::{
+        block::Simulator, bundler, metrics::MetricsTask, oauth::Authenticator, submit::SubmitTask,
+        tx_poller,
+    },
+};
+use signet_sim::SimCache;
+use signet_types::SlotCalculator;
+use std::sync::Arc;
 use tokio::select;
 
 #[tokio::main]
@@ -16,19 +18,19 @@ 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() };
     let (tx_channel, metrics_jh) = metrics.spawn();
 
-    let builder = BlockBuilder::new(&config, authenticator.clone(), ru_provider.clone());
     let submit = SubmitTask {
         authenticator: authenticator.clone(),
         host_provider,
@@ -39,14 +41,43 @@ async fn main() -> eyre::Result<()> {
         outbound_tx_channel: tx_channel,
     };
 
+    let tx_poller = tx_poller::TxPoller::new(&config);
+    let (tx_receiver, tx_poller_jh) = tx_poller.spawn();
+
+    let bundle_poller = bundler::BundlePoller::new(&config, authenticator.clone());
+    let (bundle_receiver, bundle_poller_jh) = bundle_poller.spawn();
+
     let authenticator_jh = authenticator.spawn();
+
     let (submit_channel, submit_jh) = submit.spawn();
-    let build_jh = builder.spawn(submit_channel);
+
+    let sim_items = SimCache::new();
+    let slot_calculator =
+        SlotCalculator::new(config.start_timestamp, config.chain_offset, config.target_slot_time);
+
+    let sim = Arc::new(Simulator::new(&config, ru_provider.clone(), slot_calculator));
+
+    let (basefee_jh, sim_cache_jh) =
+        sim.clone().spawn_cache_task(tx_receiver, bundle_receiver, sim_items.clone());
+
+    let build_jh = sim.clone().spawn_simulator_task(constants, sim_items.clone(), submit_channel);
 
     let port = config.builder_port;
     let server = serve_builder_with_span(([0, 0, 0, 0], port), span);
 
     select! {
+        _ = tx_poller_jh => {
+            tracing::info!("tx_poller finished");
+        },
+        _ = bundle_poller_jh => {
+            tracing::info!("bundle_poller finished");
+        },
+        _ = sim_cache_jh => {
+            tracing::info!("sim cache task finished");
+        }
+        _ = basefee_jh => {
+            tracing::info!("basefee task finished");
+        }
         _ = submit_jh => {
             tracing::info!("submit finished");
         },

bin/submit_transaction.rs

@@ -82,9 +82,8 @@ async fn connect_from_config() -> (Provider, Address, u64) {
     let signer = AwsSigner::new(client, kms_key_id.to_string(), Some(chain_id)).await.unwrap();
 
     let provider = ProviderBuilder::new()
-        .with_recommended_fillers()
         .wallet(EthereumWallet::from(signer))
-        .on_builtin(&rpc_url)
+        .connect(&rpc_url)
         .await
         .unwrap();
 

src/config.rs

@@ -1,18 +1,19 @@
 use crate::signer::{LocalOrAws, SignerError};
 use alloy::{
     network::{Ethereum, EthereumWallet},
-    primitives::Address,
+    primitives::{Address, address},
     providers::{
         Identity, ProviderBuilder, RootProvider,
         fillers::{
             BlobGasFiller, ChainIdFiller, FillProvider, GasFiller, JoinFill, NonceFiller,
             WalletFiller,
         },
     },
-    transports::BoxTransport,
 };
+use eyre::Result;
+use signet_types::config::{HostConfig, PredeployTokens, RollupConfig, SignetSystemConstants};
+use signet_zenith::Zenith;
 use std::{borrow::Cow, env, num, str::FromStr};
-use zenith_types::Zenith;
 
 // Keys for .env variables that need to be set to configure the builder.
 const HOST_CHAIN_ID: &str = "HOST_CHAIN_ID";
@@ -38,6 +39,8 @@ 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";
+const START_TIMESTAMP: &str = "START_TIMESTAMP";
 
 /// Configuration for a builder running a specific rollup on a specific host
 /// chain.
@@ -93,6 +96,10 @@ 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,
+    /// The anchor for slot time and number calculations before adjusting for chain offset.
+    pub start_timestamp: u64,
 }
 
 /// Error loading the configuration.
@@ -116,6 +123,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 {
@@ -125,7 +135,7 @@ impl ConfigError {
     }
 }
 
-/// Provider type used to read & write.
+/// Type alias for the provider used in the builder.
 pub type Provider = FillProvider<
     JoinFill<
         JoinFill<
@@ -134,26 +144,22 @@ pub type Provider = FillProvider<
         >,
         WalletFiller<EthereumWallet>,
     >,
-    RootProvider<BoxTransport>,
-    BoxTransport,
+    RootProvider,
     Ethereum,
 >;
 
-/// Provider type used to read-only.
+/// Type alias for the provider used in the builder, without a wallet.
 pub type WalletlessProvider = FillProvider<
     JoinFill<
         Identity,
         JoinFill<GasFiller, JoinFill<BlobGasFiller, JoinFill<NonceFiller, ChainIdFiller>>>,
     >,
-    RootProvider<BoxTransport>,
-    BoxTransport,
+    RootProvider,
     Ethereum,
 >;
 
-/// A Zenith contract instance, using some provider `P` (defaults to
-/// [`Provider`]).
-pub type ZenithInstance<P = Provider> =
-    Zenith::ZenithInstance<BoxTransport, P, alloy::network::Ethereum>;
+/// A [`Zenith`] contract instance using [`Provider`] as the provider.
+pub type ZenithInstance<P = Provider> = Zenith::ZenithInstance<(), P, alloy::network::Ethereum>;
 
 impl BuilderConfig {
     /// Load the builder configuration from environment variables.
@@ -189,6 +195,8 @@ 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),
+            start_timestamp: load_u64(START_TIMESTAMP)?,
         })
     }
 
@@ -210,32 +218,36 @@ impl BuilderConfig {
 
     /// Connect to the Rollup rpc provider.
     pub async fn connect_ru_provider(&self) -> Result<WalletlessProvider, ConfigError> {
-        ProviderBuilder::new()
-            .with_recommended_fillers()
-            .on_builtin(&self.ru_rpc_url)
+        let provider = ProviderBuilder::new()
+            .connect(&self.ru_rpc_url)
             .await
-            .map_err(Into::into)
+            .map_err(ConfigError::Provider)?;
+
+        Ok(provider)
     }
 
     /// Connect to the Host rpc provider.
     pub async fn connect_host_provider(&self) -> Result<Provider, ConfigError> {
         let builder_signer = self.connect_builder_signer().await?;
-        ProviderBuilder::new()
-            .with_recommended_fillers()
+        let provider = ProviderBuilder::new()
             .wallet(EthereumWallet::from(builder_signer))
-            .on_builtin(&self.host_rpc_url)
+            .connect(&self.host_rpc_url)
             .await
-            .map_err(Into::into)
+            .map_err(ConfigError::Provider)?;
+
+        Ok(provider)
     }
 
     /// Connect additional broadcast providers.
     pub async fn connect_additional_broadcast(
         &self,
-    ) -> Result<Vec<RootProvider<BoxTransport>>, ConfigError> {
-        let mut providers = Vec::with_capacity(self.tx_broadcast_urls.len());
+    ) -> Result<Vec<WalletlessProvider>, ConfigError> {
+        let mut providers: Vec<WalletlessProvider> =
+            Vec::with_capacity(self.tx_broadcast_urls.len());
         for url in self.tx_broadcast_urls.iter() {
             let provider =
-                ProviderBuilder::new().on_builtin(url).await.map_err(Into::<ConfigError>::into)?;
+                ProviderBuilder::new().connect(url).await.map_err(ConfigError::Provider)?;
+
             providers.push(provider);
         }
         Ok(providers)
@@ -245,6 +257,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 const 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.
@@ -278,5 +320,6 @@ pub fn load_url(key: &str) -> Result<Cow<'static, str>, ConfigError> {
 /// Load an address from an environment variable.
 pub fn load_address(key: &str) -> Result<Address, ConfigError> {
     let address = load_string(key)?;
-    Address::from_str(&address).map_err(Into::into)
+    Address::from_str(&address)
+        .map_err(|_| ConfigError::Var(format!("Invalid address format for {}", key)))
 }

src/lib.rs

@@ -27,4 +27,9 @@ pub mod tasks;
 /// Utilities.
 pub mod utils;
 
+/// Test utilitites
+pub mod test_utils;
+
+// Anonymous import suppresses warnings about unused imports.
 use openssl as _;
+use tracing_subscriber as _;