From 077005763a41271c6307e16382031889d81a7cdd Mon Sep 17 00:00:00 2001 From: dylan Date: Wed, 26 Nov 2025 23:38:37 -0700 Subject: [PATCH 1/6] wip: working on getting bundle integration tests working --- Cargo.lock | 1 + Cargo.toml | 2 + src/tasks/block/sim.rs | 1 - src/test_utils.rs | 6 +- tests/block_builder_test.rs | 153 +++++++++++++++++++++++++++++++++++- tests/tx_poller_test.rs | 3 +- 6 files changed, 157 insertions(+), 9 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 9db8e318..9a5d8a21 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1929,6 +1929,7 @@ dependencies = [ "reqwest", "serde", "serde_json", + "signet-bundle", "signet-constants", "signet-sim", "signet-tx-cache", diff --git a/Cargo.toml b/Cargo.toml index 42aed8f8..6ea96301 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -26,12 +26,14 @@ init4-bin-base = { git = "https://github.com/init4tech/bin-base.git", branch = " # signet-constants = { version = "0.15.0" } # signet-sim = { version = "0.15.0" } # signet-tx-cache = { version = "0.15.0" } +# signet-bundle = { version = "0.15.0" } # signet-types = { version = "0.15.0" } # signet-zenith = { version = "0.15.0" } signet-constants = { git = "https://github.com/init4tech/signet-sdk.git", branch = "dylan/logs-sim-env-errors" } signet-sim = { git = "https://github.com/init4tech/signet-sdk.git", branch = "dylan/logs-sim-env-errors" } signet-tx-cache = { git = "https://github.com/init4tech/signet-sdk.git", branch = "dylan/logs-sim-env-errors" } +signet-bundle = { git = "https://github.com/init4tech/signet-sdk.git", branch = "dylan/logs-sim-env-errors" } signet-types = { git = "https://github.com/init4tech/signet-sdk.git", branch = "dylan/logs-sim-env-errors" } signet-zenith = { git = "https://github.com/init4tech/signet-sdk.git", branch = "dylan/logs-sim-env-errors" } diff --git a/src/tasks/block/sim.rs b/src/tasks/block/sim.rs index 1674de42..9fa4c774 100644 --- a/src/tasks/block/sim.rs +++ b/src/tasks/block/sim.rs @@ -220,7 +220,6 @@ impl SimulatorTask { else { continue; }; - span_debug!(span, tx_count = block.transactions().len(), "built simulated block"); let _ = submit_sender.send(SimResult { block, sim_env }); } diff --git a/src/test_utils.rs b/src/test_utils.rs index 143d1991..55aa2a3d 100644 --- a/src/test_utils.rs +++ b/src/test_utils.rs @@ -64,12 +64,13 @@ pub fn setup_test_config() -> &'static BuilderConfig { /// Returns a new signed test transaction with the provided nonce, value, and mpfpg. pub fn new_signed_tx( wallet: &PrivateKeySigner, + chain_id: u64, nonce: u64, value: U256, mpfpg: u128, ) -> Result { let tx = TxEip1559 { - chain_id: 11155111, + chain_id, nonce, max_fee_per_gas: 10_000_000, max_priority_fee_per_gas: mpfpg, @@ -91,8 +92,7 @@ pub fn setup_logging() { let _ = registry.try_init(); } -/// Returns a Pecorino block environment for simulation with the timestamp set to `finish_by`, -/// the block number set to latest + 1, system gas configs, and a beneficiary address. +/// Create a test BlockEnv with the provided parameters pub fn test_block_env(number: u64, basefee: u64, timestamp: u64) -> BlockEnv { let config = setup_test_config(); BlockEnv { diff --git a/tests/block_builder_test.rs b/tests/block_builder_test.rs index d972cc13..e23ce13c 100644 --- a/tests/block_builder_test.rs +++ b/tests/block_builder_test.rs @@ -1,7 +1,13 @@ //! Tests for the block building task. use alloy::{ - eips::BlockId, node_bindings::Anvil, primitives::U256, providers::Provider, + consensus::BlockHeader, + eips::{BlockId, Encodable2718}, + network::EthereumWallet, + node_bindings::Anvil, + primitives::{Address, B256, Bytes, U256}, + providers::{Provider, ProviderBuilder}, + rpc::types::mev::EthSendBundle, signers::local::PrivateKeySigner, }; use builder::{ @@ -11,8 +17,17 @@ use builder::{ }, test_utils::{new_signed_tx, setup_logging, setup_test_config, test_block_env}, }; + +use signet_bundle::SignetEthBundle; +use signet_constants::pecorino::RU_CHAIN_ID; use signet_sim::SimCache; -use std::time::{Duration, Instant}; +use tokio::sync::{mpsc::unbounded_channel, watch::channel}; +use trevm::revm::{context::BlockEnv, context_interface::block::BlobExcessGasAndPrice}; + +use std::{ + str::FromStr, + time::{Duration, Instant}, +}; /// Tests the `handle_build` method of the `SimulatorTask`. /// @@ -43,10 +58,10 @@ async fn test_handle_build() { let sim_items = SimCache::new(); // Add two transactions from two senders to the sim cache - let tx_1 = new_signed_tx(&test_key_0, 0, U256::from(1_f64), 11_000).unwrap(); + let tx_1 = new_signed_tx(&test_key_0, RU_CHAIN_ID, 0, U256::from(1_f64), 11_000).unwrap(); sim_items.add_tx(tx_1, 0); - let tx_2 = new_signed_tx(&test_key_1, 0, U256::from(2_f64), 10_000).unwrap(); + let tx_2 = new_signed_tx(&test_key_1, RU_CHAIN_ID, 0, U256::from(2_f64), 10_000).unwrap(); sim_items.add_tx(tx_2, 0); // Setup the block envs @@ -70,3 +85,133 @@ async fn test_handle_build() { assert!(got.is_ok()); assert!(got.unwrap().tx_count() == 2); } + +#[tokio::test(flavor = "multi_thread", worker_threads = 2)] +async fn test_bundle_host_txns() { + setup_logging(); + + let _config = setup_test_config(); + + let host_anvil_instance = Anvil::new().fork("ws://host-rpc.pecorino.signet.sh").spawn(); + let host_provider = + ProviderBuilder::new().connect_http(host_anvil_instance.endpoint().parse().unwrap()); + let host_chain_id = host_anvil_instance.chain_id(); + + // TODO: Send the built block to Flashbots and then assert on what comes out of it - a MEV Send Bundle type + // All of those values need to match up correctly + // And the bundle is currently using the rollup block number, not the host block number, that's showing up in my + // tests right now, and my setup logic is sound as far as I can tell. + // + // SOOOOOOO I think the issue is in the Flashbots task conversion logic or the simulation setup logic. + let (flashbots_tx, flashbots_rx) = unbounded_channel(); + let flashbots_task = + builder::tasks::submit::flashbots::FlashbotsTask::new(flashbots_tx).await.unwrap(); + + let ru_provider = builder::config().connect_ru_provider().await.unwrap(); + let ru_chain_id = ru_provider.get_chain_id().await.expect("gets ru chain id"); + dbg!(&host_anvil_instance.endpoint()); + + // let keys = host_anvil_instance.keys(); + + let priv_key = + std::env::var("SIGNET_WALLET_TEST_PK").expect("SIGNET_WALLET_TEST_PK env var to be set"); + + let test_key = PrivateKeySigner::from_str(&priv_key).expect("valid private key"); + + let host_test_key_0 = + PrivateKeySigner::from_bytes(&test_key.clone().to_bytes()).expect("test key 0 to be set"); + let host_test_key_1 = + PrivateKeySigner::from_bytes(&test_key.clone().to_bytes()).expect("test key 1 to be set"); + + let host_header = + host_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; + + let ru_header = ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; + + let (sim_env_tx, sim_env_rx) = channel::>(None); + let simulator_task = SimulatorTask::new(sim_env_rx).await.unwrap(); + + let (submit_channel, submit_jh) = flashbots_task.spawn(); + + let sim_items = SimCache::new(); + + let simulator_task = simulator_task.spawn_simulator_task(sim_items, submit_channel); + + let host_block_env = { + let number = host_header.number(); + let timestamp = host_header.timestamp; + let config = setup_test_config(); + + BlockEnv { + number: U256::from(number), + beneficiary: Address::repeat_byte(1), + timestamp: U256::from(timestamp), + gas_limit: config.rollup_block_gas_limit, + basefee: 7, + difficulty: U256::ZERO, + prevrandao: Some(B256::random()), + blob_excess_gas_and_price: Some(BlobExcessGasAndPrice { + excess_blob_gas: 0, + blob_gasprice: 0, + }), + } + }; + + let ru_block_env = { + let number = ru_header.number(); + let timestamp = ru_header.timestamp; + let config = setup_test_config(); + + BlockEnv { + number: U256::from(number), + beneficiary: Address::repeat_byte(1), + timestamp: U256::from(timestamp), + gas_limit: config.rollup_block_gas_limit, + basefee: 7, + difficulty: U256::ZERO, + prevrandao: Some(B256::random()), + blob_excess_gas_and_price: Some(BlobExcessGasAndPrice { + excess_blob_gas: 0, + blob_gasprice: 0, + }), + } + }; + + let sim_env = SimEnv { + host: Environment::new(host_block_env.clone(), host_header.clone()), + rollup: Environment::new(ru_block_env.clone(), ru_header), + span: tracing::Span::none(), + }; + + sim_env_tx.send(Some(sim_env.clone())).unwrap(); + + let ru_tx = new_signed_tx(&host_test_key_1, ru_chain_id, 1, U256::from(1), 10_000).unwrap(); + let ru_txn_buf: Bytes = ru_tx.encoded_2718().into(); + + let host_txn = + new_signed_tx(&host_test_key_0, host_chain_id, 1, U256::from(1), 10_000).unwrap(); + let host_txn_buf: Bytes = host_txn.encoded_2718().into(); + + // Target rollup block number + let block_number = sim_env.rollup_block_number(); + + assert!(block_number == host_header.number() + 1); + dbg!("BUILDING FOR HOST BLOCK NUMBER: ", &block_number); + + let bundle = SignetEthBundle { + bundle: EthSendBundle { + replacement_uuid: Some("test-replacement-uuid".to_string()), + txs: vec![ru_txn_buf], + block_number, + ..Default::default() + }, + host_txs: vec![host_txn_buf], + }; + + sim_items.add_bundle(bundle, 7).expect("adds bundle to the sim cache"); + + let finish_by = Instant::now() + Duration::from_secs(3); + + dbg!(built.clone()); + let got_block_number = built.block_number(); +} diff --git a/tests/tx_poller_test.rs b/tests/tx_poller_test.rs index 075433ae..3de79439 100644 --- a/tests/tx_poller_test.rs +++ b/tests/tx_poller_test.rs @@ -5,6 +5,7 @@ use builder::{ }; // Import the refactored function use eyre::{Ok, Result}; +use signet_constants::pecorino::RU_CHAIN_ID; #[ignore = "integration test"] #[tokio::test] @@ -31,7 +32,7 @@ async fn post_tx() -> Result<()> { let client = reqwest::Client::new(); let wallet = PrivateKeySigner::random(); - let tx_envelope = new_signed_tx(&wallet, 1, U256::from(1), 10_000)?; + let tx_envelope = new_signed_tx(&wallet, RU_CHAIN_ID, 1, U256::from(1), 10_000)?; let url = format!("{}/transactions", builder::config().tx_pool_url); let response = client.post(&url).json(&tx_envelope).send().await?; From d275429f360ea674ed988bca9f7f84cb6f14ac6a Mon Sep 17 00:00:00 2001 From: dylan Date: Tue, 2 Dec 2025 15:41:44 -0700 Subject: [PATCH 2/6] wip: integration test with pecorino is failing as expected --- src/tasks/env.rs | 8 +- src/test_utils.rs | 4 +- tests/block_builder_test.rs | 159 ++++++++++++------------------------ 3 files changed, 60 insertions(+), 111 deletions(-) diff --git a/src/tasks/env.rs b/src/tasks/env.rs index 91014e11..3ffce685 100644 --- a/src/tasks/env.rs +++ b/src/tasks/env.rs @@ -14,7 +14,7 @@ use signet_constants::SignetSystemConstants; use signet_sim::{HostEnv, RollupEnv}; use tokio::{sync::watch, task::JoinHandle}; use tokio_stream::StreamExt; -use tracing::{Instrument, Span, info_span}; +use tracing::{Instrument, Span, info_span, instrument}; use trevm::revm::{ context::BlockEnv, context_interface::block::BlobExcessGasAndPrice, @@ -215,7 +215,8 @@ impl EnvTask { } /// Construct a [`BlockEnv`] for the next host block from the previous host header. - fn construct_host_env(&self, previous: Header) -> Environment { + #[instrument(skip(self, previous), fields(previous_number = %previous.number))] + pub fn construct_host_env(&self, previous: Header) -> Environment { let env = BlockEnv { number: U256::from(previous.number + 1), beneficiary: self.config.builder_rewards_address, @@ -236,7 +237,8 @@ impl EnvTask { } /// Construct a [`BlockEnv`] for the next rollup block from the previous block header. - fn construct_rollup_env(&self, previous: Header) -> Environment { + #[instrument(skip(self, previous), fields(previous_number = %previous.number))] + pub fn construct_rollup_env(&self, previous: Header) -> Environment { let env = BlockEnv { number: U256::from(previous.number + 1), beneficiary: self.config.builder_rewards_address, diff --git a/src/test_utils.rs b/src/test_utils.rs index 55aa2a3d..bd99baf3 100644 --- a/src/test_utils.rs +++ b/src/test_utils.rs @@ -36,7 +36,7 @@ pub fn setup_test_config() -> &'static BuilderConfig { flashbots_endpoint: "https://relay-sepolia.flashbots.net:443".parse().unwrap(), quincey_url: "http://localhost:8080".into(), sequencer_key: None, - builder_key: env::var("SEPOLIA_ETH_PRIV_KEY") + builder_key: env::var("BUILDER_KEY") .unwrap_or_else(|_| B256::repeat_byte(0x42).to_string()), builder_port: 8080, builder_rewards_address: Address::default(), @@ -52,7 +52,7 @@ pub fn setup_test_config() -> &'static BuilderConfig { concurrency_limit: None, // NB: Defaults to available parallelism slot_calculator: SlotCalculator::new( 1740681556, // pecorino start timestamp as sane default - 0, 1, + 0, 12, ), block_query_cutoff_buffer: 3000, max_host_gas_coefficient: Some(80), diff --git a/tests/block_builder_test.rs b/tests/block_builder_test.rs index e23ce13c..5477c436 100644 --- a/tests/block_builder_test.rs +++ b/tests/block_builder_test.rs @@ -1,12 +1,10 @@ //! Tests for the block building task. use alloy::{ - consensus::BlockHeader, eips::{BlockId, Encodable2718}, - network::EthereumWallet, node_bindings::Anvil, - primitives::{Address, B256, Bytes, U256}, - providers::{Provider, ProviderBuilder}, + primitives::U256, + providers::Provider, rpc::types::mev::EthSendBundle, signers::local::PrivateKeySigner, }; @@ -22,7 +20,6 @@ use signet_bundle::SignetEthBundle; use signet_constants::pecorino::RU_CHAIN_ID; use signet_sim::SimCache; use tokio::sync::{mpsc::unbounded_channel, watch::channel}; -use trevm::revm::{context::BlockEnv, context_interface::block::BlobExcessGasAndPrice}; use std::{ str::FromStr, @@ -89,129 +86,79 @@ async fn test_handle_build() { #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn test_bundle_host_txns() { setup_logging(); + setup_test_config(); + + let constants = builder::config().constants.clone(); - let _config = setup_test_config(); - - let host_anvil_instance = Anvil::new().fork("ws://host-rpc.pecorino.signet.sh").spawn(); - let host_provider = - ProviderBuilder::new().connect_http(host_anvil_instance.endpoint().parse().unwrap()); - let host_chain_id = host_anvil_instance.chain_id(); - - // TODO: Send the built block to Flashbots and then assert on what comes out of it - a MEV Send Bundle type - // All of those values need to match up correctly - // And the bundle is currently using the rollup block number, not the host block number, that's showing up in my - // tests right now, and my setup logic is sound as far as I can tell. - // - // SOOOOOOO I think the issue is in the Flashbots task conversion logic or the simulation setup logic. - let (flashbots_tx, flashbots_rx) = unbounded_channel(); - let flashbots_task = - builder::tasks::submit::flashbots::FlashbotsTask::new(flashbots_tx).await.unwrap(); + // Setup a host and rollup provider from the test config + let host_provider = builder::config().connect_host_provider().await.unwrap(); + let host_chain_id = host_provider.get_chain_id().await.expect("gets host chain id"); + assert!(host_chain_id == constants.host_chain_id()); + let ru_provider = builder::config().connect_ru_provider().await.unwrap(); let ru_chain_id = ru_provider.get_chain_id().await.expect("gets ru chain id"); - dbg!(&host_anvil_instance.endpoint()); - - // let keys = host_anvil_instance.keys(); + assert!(ru_chain_id == constants.ru_chain_id()); let priv_key = std::env::var("SIGNET_WALLET_TEST_PK").expect("SIGNET_WALLET_TEST_PK env var to be set"); - let test_key = PrivateKeySigner::from_str(&priv_key).expect("valid private key"); - let host_test_key_0 = - PrivateKeySigner::from_bytes(&test_key.clone().to_bytes()).expect("test key 0 to be set"); - let host_test_key_1 = - PrivateKeySigner::from_bytes(&test_key.clone().to_bytes()).expect("test key 1 to be set"); + // NB: Test uses the same key for both host and rollup for simplicity. + let test_key = + PrivateKeySigner::from_bytes(&test_key.to_bytes()).expect("test key 0 to be set"); - let host_header = + // Setup the simulation environments + let env = EnvTask::new().await.unwrap(); + let host_previous = host_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; + let ru_previous = ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; + let host_env = env.construct_host_env(host_previous); + let ru_env = env.construct_rollup_env(ru_previous); - let ru_header = ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; - - let (sim_env_tx, sim_env_rx) = channel::>(None); - let simulator_task = SimulatorTask::new(sim_env_rx).await.unwrap(); + let sim_env = SimEnv { host: host_env, rollup: ru_env, span: tracing::Span::none() }; + let (sim_tx, sim_rx) = channel::>(None); - let (submit_channel, submit_jh) = flashbots_task.spawn(); + // Create a host and rollup transaction + let ru_txn = new_signed_tx(&test_key, ru_chain_id, 0, U256::from(1), 10_000) + .unwrap() + .encoded_2718() + .into(); - let sim_items = SimCache::new(); - - let simulator_task = simulator_task.spawn_simulator_task(sim_items, submit_channel); - - let host_block_env = { - let number = host_header.number(); - let timestamp = host_header.timestamp; - let config = setup_test_config(); - - BlockEnv { - number: U256::from(number), - beneficiary: Address::repeat_byte(1), - timestamp: U256::from(timestamp), - gas_limit: config.rollup_block_gas_limit, - basefee: 7, - difficulty: U256::ZERO, - prevrandao: Some(B256::random()), - blob_excess_gas_and_price: Some(BlobExcessGasAndPrice { - excess_blob_gas: 0, - blob_gasprice: 0, - }), - } - }; - - let ru_block_env = { - let number = ru_header.number(); - let timestamp = ru_header.timestamp; - let config = setup_test_config(); - - BlockEnv { - number: U256::from(number), - beneficiary: Address::repeat_byte(1), - timestamp: U256::from(timestamp), - gas_limit: config.rollup_block_gas_limit, - basefee: 7, - difficulty: U256::ZERO, - prevrandao: Some(B256::random()), - blob_excess_gas_and_price: Some(BlobExcessGasAndPrice { - excess_blob_gas: 0, - blob_gasprice: 0, - }), - } - }; - - let sim_env = SimEnv { - host: Environment::new(host_block_env.clone(), host_header.clone()), - rollup: Environment::new(ru_block_env.clone(), ru_header), - span: tracing::Span::none(), - }; - - sim_env_tx.send(Some(sim_env.clone())).unwrap(); - - let ru_tx = new_signed_tx(&host_test_key_1, ru_chain_id, 1, U256::from(1), 10_000).unwrap(); - let ru_txn_buf: Bytes = ru_tx.encoded_2718().into(); - - let host_txn = - new_signed_tx(&host_test_key_0, host_chain_id, 1, U256::from(1), 10_000).unwrap(); - let host_txn_buf: Bytes = host_txn.encoded_2718().into(); - - // Target rollup block number - let block_number = sim_env.rollup_block_number(); - - assert!(block_number == host_header.number() + 1); - dbg!("BUILDING FOR HOST BLOCK NUMBER: ", &block_number); + let host_txn = new_signed_tx(&test_key, host_chain_id, 1, U256::from(1), 10_000) + .unwrap() + .encoded_2718() + .into(); + // Make a bundle out of them let bundle = SignetEthBundle { bundle: EthSendBundle { replacement_uuid: Some("test-replacement-uuid".to_string()), - txs: vec![ru_txn_buf], - block_number, + txs: vec![ru_txn], + block_number: sim_env.rollup_block_number(), ..Default::default() }, - host_txs: vec![host_txn_buf], + host_txs: vec![host_txn], }; - sim_items.add_bundle(bundle, 7).expect("adds bundle to the sim cache"); + // Add it to the sim cache + let sim_items = SimCache::new(); + sim_items.add_bundle(bundle, 7).expect("adds bundle"); + + // Setup the simulator environment + let (submit_channel, mut submit_receiver) = unbounded_channel(); + let simulator_task = SimulatorTask::new(sim_rx).await.unwrap(); + let simulator_jh = simulator_task.spawn_simulator_task(sim_items, submit_channel); + + // Send a new environment to tick the block builder simulation loop off + sim_tx.send(Some(sim_env)).unwrap(); - let finish_by = Instant::now() + Duration::from_secs(3); + // Wait for a result and assert on it + let got = submit_receiver.recv().await.expect("built block"); + dbg!(&got.block); + assert_eq!(got.block.transactions().len(), 1); + assert_eq!(got.block.host_transactions().len(), 1); - dbg!(built.clone()); - let got_block_number = built.block_number(); + // Cleanup + simulator_jh.abort(); } From 60a8df766918a39fab355cdc74b469563597be13 Mon Sep 17 00:00:00 2001 From: dylan Date: Wed, 3 Dec 2025 00:22:21 -0700 Subject: [PATCH 3/6] refactor: pass in providers at construction time - this commit refactors the constructor functions of a the Simulator and Env tasks to use a provider that is passed in instead of connected internally for easier testing. --- bin/builder.rs | 19 ++++- src/tasks/block/sim.rs | 12 +-- src/tasks/env.rs | 13 ++- src/test_utils.rs | 2 +- tests/block_builder_test.rs | 153 +++++++++++++++++++++--------------- tests/cache.rs | 10 ++- tests/env.rs | 7 +- 7 files changed, 130 insertions(+), 86 deletions(-) diff --git a/bin/builder.rs b/bin/builder.rs index f8378d58..e7bfccea 100644 --- a/bin/builder.rs +++ b/bin/builder.rs @@ -14,10 +14,21 @@ use tokio::select; async fn main() -> eyre::Result<()> { let _guard = init4_bin_base::init4(); let init_span_guard = info_span!("builder initialization"); - builder::config_from_env(); + let config = builder::config_from_env(); + + let (env_host_provider, sim_host_provider, env_ru_provider, sim_ru_provider, quincey) = tokio::try_join!( + config.connect_host_provider(), + config.connect_host_provider(), + config.connect_ru_provider(), + config.connect_ru_provider(), + config.connect_quincey(), + )?; // Set up env and metrics tasks - let (env_task, metrics_task) = tokio::try_join!(EnvTask::new(), MetricsTask::new())?; + let (env_task, metrics_task) = tokio::try_join!( + EnvTask::new(env_host_provider, env_ru_provider, quincey), + MetricsTask::new() + )?; // Spawn the env and metrics tasks let (block_env, env_jh) = env_task.spawn(); @@ -25,8 +36,8 @@ async fn main() -> eyre::Result<()> { // Set up the cache, submit, and simulator tasks let cache_tasks = CacheTasks::new(block_env.clone()); - let (submit_task, simulator_task) = - tokio::try_join!(FlashbotsTask::new(tx_channel.clone()), SimulatorTask::new(block_env),)?; + let submit_task = FlashbotsTask::new(tx_channel.clone()).await?; + let simulator_task = SimulatorTask::new(block_env, sim_host_provider, sim_ru_provider); // Spawn the cache, submit, and simulator tasks let cache_system = cache_tasks.spawn(); diff --git a/src/tasks/block/sim.rs b/src/tasks/block/sim.rs index 9fa4c774..61a7b169 100644 --- a/src/tasks/block/sim.rs +++ b/src/tasks/block/sim.rs @@ -81,13 +81,13 @@ pub struct SimulatorTask { impl SimulatorTask { /// Create a new `SimulatorTask` instance. This task must be spawned to /// begin processing incoming block environments. - pub async fn new(envs: watch::Receiver>) -> eyre::Result { + pub fn new( + envs: watch::Receiver>, + host_provider: HostProvider, + ru_provider: RuProvider, + ) -> Self { let config = crate::config(); - - let (host_provider, ru_provider) = - tokio::try_join!(config.connect_host_provider(), config.connect_ru_provider())?; - - Ok(Self { config, host_provider, ru_provider, envs }) + Self { config, host_provider, ru_provider, envs } } /// Get the slot calculator. diff --git a/src/tasks/env.rs b/src/tasks/env.rs index 3ffce685..feb5c567 100644 --- a/src/tasks/env.rs +++ b/src/tasks/env.rs @@ -202,15 +202,12 @@ pub struct EnvTask { impl EnvTask { /// Create a new [`EnvTask`] with the given config and providers. - pub async fn new() -> eyre::Result { + pub async fn new( + host_provider: HostProvider, + ru_provider: RuProvider, + quincey: Quincey, + ) -> eyre::Result { let config = crate::config(); - - let (host_provider, quincey, ru_provider) = tokio::try_join!( - config.connect_host_provider(), - config.connect_quincey(), - config.connect_ru_provider(), - )?; - Ok(Self { config, host_provider, quincey, ru_provider }) } diff --git a/src/test_utils.rs b/src/test_utils.rs index bd99baf3..36e22378 100644 --- a/src/test_utils.rs +++ b/src/test_utils.rs @@ -72,7 +72,7 @@ pub fn new_signed_tx( let tx = TxEip1559 { chain_id, nonce, - max_fee_per_gas: 10_000_000, + max_fee_per_gas: 50_000_000_000, max_priority_fee_per_gas: mpfpg, to: TxKind::Call(Address::from_str("0x0000000000000000000000000000000000000000").unwrap()), value, diff --git a/tests/block_builder_test.rs b/tests/block_builder_test.rs index 5477c436..bc2ee0e4 100644 --- a/tests/block_builder_test.rs +++ b/tests/block_builder_test.rs @@ -3,79 +3,94 @@ use alloy::{ eips::{BlockId, Encodable2718}, node_bindings::Anvil, - primitives::U256, - providers::Provider, + primitives::{B256, U256}, + providers::{ + Provider, ProviderBuilder, RootProvider, + fillers::{BlobGasFiller, SimpleNonceManager}, + }, rpc::types::mev::EthSendBundle, signers::local::PrivateKeySigner, }; use builder::{ + constants, tasks::{ block::sim::SimulatorTask, - env::{EnvTask, Environment, SimEnv}, + env::{EnvTask, SimEnv}, }, - test_utils::{new_signed_tx, setup_logging, setup_test_config, test_block_env}, + test_utils::{new_signed_tx, setup_logging, setup_test_config}, }; use signet_bundle::SignetEthBundle; -use signet_constants::pecorino::RU_CHAIN_ID; use signet_sim::SimCache; use tokio::sync::{mpsc::unbounded_channel, watch::channel}; -use std::{ - str::FromStr, - time::{Duration, Instant}, -}; +use std::time::{Duration, Instant}; /// Tests the `handle_build` method of the `SimulatorTask`. /// /// This test sets up a simulated environment using Anvil, creates a block builder, /// and verifies that the block builder can successfully build a block containing /// transactions from multiple senders. -#[ignore = "integration test"] +// #[ignore = "integration test"] #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn test_handle_build() { setup_logging(); + setup_test_config(); - // Make a test config - let config = setup_test_config(); - - // Create an anvil instance for testing - let anvil_instance = Anvil::new().chain_id(signet_constants::pecorino::RU_CHAIN_ID).spawn(); - - // Create a wallet - let keys = anvil_instance.keys(); - let test_key_0 = PrivateKeySigner::from_signing_key(keys[0].clone().into()); - let test_key_1 = PrivateKeySigner::from_signing_key(keys[1].clone().into()); - - let block_env = EnvTask::new().await.unwrap().spawn().0; - - let block_builder = SimulatorTask::new(block_env).await.unwrap(); + // Setup quincey + let quincey = builder::config().connect_quincey().await.unwrap(); + + // Setup host provider + let host_anvil = Anvil::new().chain_id(constants().host_chain_id()).spawn(); + let host_anvil_key = host_anvil.keys()[0].clone(); + PrivateKeySigner::from_bytes(&B256::from_slice(&host_anvil_key.to_bytes())).unwrap(); + let host_wallet = host_anvil.wallet().expect("anvil wallet"); + let host_provider = ProviderBuilder::new_with_network() + .disable_recommended_fillers() + .filler(BlobGasFiller) + .with_gas_estimation() + .with_nonce_management(SimpleNonceManager::default()) + .fetch_chain_id() + .wallet(host_wallet) + .connect_http(host_anvil.endpoint_url()); + + // Setup rollup provider + let ru_anvil = Anvil::new().chain_id(constants().ru_chain_id()).spawn(); + let ru_anvil_key = ru_anvil.keys()[0].clone(); + let ru_anvil_key_two = ru_anvil.keys()[1].clone(); + let rollup_key = + PrivateKeySigner::from_bytes(&B256::from_slice(&ru_anvil_key.to_bytes())).unwrap(); + let rollup_key_two = + PrivateKeySigner::from_bytes(&B256::from_slice(&ru_anvil_key_two.to_bytes())).unwrap(); + let ru_provider = RootProvider::new_http(ru_anvil.endpoint_url()); + + // Setup the env task and environments + let env_task = EnvTask::new(host_provider.clone(), ru_provider.clone(), quincey).await.unwrap(); + + let prev_host = host_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; + let host_env = env_task.construct_host_env(prev_host); + let prev_ru = ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; + let rollup_env = env_task.construct_rollup_env(prev_ru); + + let (block_env, _jh) = env_task.spawn(); + let block_builder = SimulatorTask::new(block_env, host_provider, ru_provider); // Setup a sim cache let sim_items = SimCache::new(); // Add two transactions from two senders to the sim cache - let tx_1 = new_signed_tx(&test_key_0, RU_CHAIN_ID, 0, U256::from(1_f64), 11_000).unwrap(); + let tx_1 = new_signed_tx(&rollup_key, constants().ru_chain_id(), 0, U256::from(1_f64), 11_000) + .unwrap(); sim_items.add_tx(tx_1, 0); - let tx_2 = new_signed_tx(&test_key_1, RU_CHAIN_ID, 0, U256::from(2_f64), 10_000).unwrap(); + let tx_2 = + new_signed_tx(&rollup_key_two, constants().ru_chain_id(), 0, U256::from(2_f64), 10_000) + .unwrap(); sim_items.add_tx(tx_2, 0); - // Setup the block envs - let finish_by = Instant::now() + Duration::from_secs(2); - - let ru_provider = builder::config().connect_ru_provider().await.unwrap(); - 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(number, 7, timestamp); - // Spawn the block builder task - let sim_env = SimEnv { - host: Environment::for_testing(), - rollup: Environment::new(block_env, ru_header), - span: tracing::Span::none(), - }; + let sim_env = SimEnv { host: host_env, rollup: rollup_env, span: tracing::Span::none() }; + let finish_by = Instant::now() + Duration::from_secs(2); let got = block_builder.handle_build(sim_items, finish_by, &sim_env).await; // Assert on the built block @@ -87,45 +102,55 @@ async fn test_handle_build() { async fn test_bundle_host_txns() { setup_logging(); setup_test_config(); - - let constants = builder::config().constants.clone(); - // Setup a host and rollup provider from the test config - let host_provider = builder::config().connect_host_provider().await.unwrap(); + // Setup host provider + let host_anvil = Anvil::new().chain_id(constants().host_chain_id()).spawn(); + let host_anvil_key = host_anvil.keys()[0].clone(); + let host_signer = + PrivateKeySigner::from_bytes(&B256::from_slice(&host_anvil_key.to_bytes())).unwrap(); + let host_wallet = host_anvil.wallet().expect("anvil wallet"); + let host_provider = ProviderBuilder::new_with_network() + .disable_recommended_fillers() + .filler(BlobGasFiller) + .with_gas_estimation() + .with_nonce_management(SimpleNonceManager::default()) + .fetch_chain_id() + .wallet(host_wallet) + .connect_http(host_anvil.endpoint_url()); let host_chain_id = host_provider.get_chain_id().await.expect("gets host chain id"); - assert!(host_chain_id == constants.host_chain_id()); - - - let ru_provider = builder::config().connect_ru_provider().await.unwrap(); + assert_eq!(host_chain_id, constants().host_chain_id()); + + // Setup rollup provider + let ru_anvil = Anvil::new().chain_id(constants().ru_chain_id()).spawn(); + let ru_anvil_key = ru_anvil.keys()[0].clone(); + let rollup_signer = + PrivateKeySigner::from_bytes(&B256::from_slice(&ru_anvil_key.to_bytes())).unwrap(); + let ru_provider = RootProvider::new_http(ru_anvil.endpoint_url()); let ru_chain_id = ru_provider.get_chain_id().await.expect("gets ru chain id"); - assert!(ru_chain_id == constants.ru_chain_id()); - - let priv_key = - std::env::var("SIGNET_WALLET_TEST_PK").expect("SIGNET_WALLET_TEST_PK env var to be set"); - let test_key = PrivateKeySigner::from_str(&priv_key).expect("valid private key"); + assert_eq!(ru_chain_id, constants().ru_chain_id()); - // NB: Test uses the same key for both host and rollup for simplicity. - let test_key = - PrivateKeySigner::from_bytes(&test_key.to_bytes()).expect("test key 0 to be set"); + let quincey = builder::config().connect_quincey().await.unwrap(); // Setup the simulation environments - let env = EnvTask::new().await.unwrap(); + let env = EnvTask::new(host_provider.clone(), ru_provider.clone(), quincey).await.unwrap(); let host_previous = host_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; - let ru_previous = ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; + let ru_previous = + ru_provider.clone().get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; let host_env = env.construct_host_env(host_previous); let ru_env = env.construct_rollup_env(ru_previous); + // Create a simulation environment and plumbing let sim_env = SimEnv { host: host_env, rollup: ru_env, span: tracing::Span::none() }; let (sim_tx, sim_rx) = channel::>(None); // Create a host and rollup transaction - let ru_txn = new_signed_tx(&test_key, ru_chain_id, 0, U256::from(1), 10_000) + let ru_txn = new_signed_tx(&rollup_signer, ru_chain_id, 0, U256::from(1), 10_000) .unwrap() .encoded_2718() .into(); - let host_txn = new_signed_tx(&test_key, host_chain_id, 1, U256::from(1), 10_000) + let host_txn = new_signed_tx(&host_signer, host_chain_id, 0, U256::from(1), 10_000) .unwrap() .encoded_2718() .into(); @@ -146,15 +171,15 @@ async fn test_bundle_host_txns() { sim_items.add_bundle(bundle, 7).expect("adds bundle"); // Setup the simulator environment - let (submit_channel, mut submit_receiver) = unbounded_channel(); - let simulator_task = SimulatorTask::new(sim_rx).await.unwrap(); - let simulator_jh = simulator_task.spawn_simulator_task(sim_items, submit_channel); + let (submit_tx, mut submit_rx) = unbounded_channel(); + let simulator_task = SimulatorTask::new(sim_rx, host_provider, ru_provider); + let simulator_jh = simulator_task.spawn_simulator_task(sim_items, submit_tx); // Send a new environment to tick the block builder simulation loop off sim_tx.send(Some(sim_env)).unwrap(); // Wait for a result and assert on it - let got = submit_receiver.recv().await.expect("built block"); + let got = submit_rx.recv().await.expect("built block"); dbg!(&got.block); assert_eq!(got.block.transactions().len(), 1); assert_eq!(got.block.host_transactions().len(), 1); diff --git a/tests/cache.rs b/tests/cache.rs index 5e9e7967..62e96804 100644 --- a/tests/cache.rs +++ b/tests/cache.rs @@ -9,9 +9,15 @@ use std::time::Duration; #[tokio::test] async fn test_bundle_poller_roundtrip() -> eyre::Result<()> { setup_logging(); - setup_test_config(); + let config = setup_test_config(); - let (block_env, _jh) = EnvTask::new().await?.spawn(); + let (host, rollup, quincey) = tokio::try_join!( + config.connect_host_provider(), + config.connect_ru_provider(), + config.connect_quincey(), + )?; + + let (block_env, _jh) = EnvTask::new(host, rollup, quincey).await?.spawn(); let cache_tasks = CacheTasks::new(block_env); let cache_system = cache_tasks.spawn(); diff --git a/tests/env.rs b/tests/env.rs index c11c7de3..769ea36b 100644 --- a/tests/env.rs +++ b/tests/env.rs @@ -9,7 +9,12 @@ async fn test_bundle_poller_roundtrip() -> eyre::Result<()> { setup_logging(); let _ = setup_test_config(); - let (mut env_watcher, _jh) = EnvTask::new().await?.spawn(); + let (host, rollup, quincey) = tokio::try_join!( + builder::config().connect_host_provider(), + builder::config().connect_ru_provider(), + builder::config().connect_quincey(), + )?; + let (mut env_watcher, _jh) = EnvTask::new(host, rollup, quincey).await?.spawn(); env_watcher.changed().await.unwrap(); let env = env_watcher.borrow_and_update(); From d15f314b23bdc422fbfe01968e7174c5d62f12df Mon Sep 17 00:00:00 2001 From: dylan Date: Wed, 3 Dec 2025 01:06:32 -0700 Subject: [PATCH 4/6] refactors: helper functions --- tests/block_builder_test.rs | 114 +++++++++++++++++++----------------- 1 file changed, 60 insertions(+), 54 deletions(-) diff --git a/tests/block_builder_test.rs b/tests/block_builder_test.rs index bc2ee0e4..17c722aa 100644 --- a/tests/block_builder_test.rs +++ b/tests/block_builder_test.rs @@ -2,7 +2,7 @@ use alloy::{ eips::{BlockId, Encodable2718}, - node_bindings::Anvil, + node_bindings::{Anvil, AnvilInstance}, primitives::{B256, U256}, providers::{ Provider, ProviderBuilder, RootProvider, @@ -12,6 +12,7 @@ use alloy::{ signers::local::PrivateKeySigner, }; use builder::{ + config::{HostProvider, RuProvider}, constants, tasks::{ block::sim::SimulatorTask, @@ -31,7 +32,6 @@ use std::time::{Duration, Instant}; /// This test sets up a simulated environment using Anvil, creates a block builder, /// and verifies that the block builder can successfully build a block containing /// transactions from multiple senders. -// #[ignore = "integration test"] #[tokio::test(flavor = "multi_thread", worker_threads = 2)] async fn test_handle_build() { setup_logging(); @@ -41,36 +41,17 @@ async fn test_handle_build() { let quincey = builder::config().connect_quincey().await.unwrap(); // Setup host provider - let host_anvil = Anvil::new().chain_id(constants().host_chain_id()).spawn(); - let host_anvil_key = host_anvil.keys()[0].clone(); - PrivateKeySigner::from_bytes(&B256::from_slice(&host_anvil_key.to_bytes())).unwrap(); - let host_wallet = host_anvil.wallet().expect("anvil wallet"); - let host_provider = ProviderBuilder::new_with_network() - .disable_recommended_fillers() - .filler(BlobGasFiller) - .with_gas_estimation() - .with_nonce_management(SimpleNonceManager::default()) - .fetch_chain_id() - .wallet(host_wallet) - .connect_http(host_anvil.endpoint_url()); + let (_host_anvil, host_provider, _host_signer) = spawn_host_anvil(); // Setup rollup provider - let ru_anvil = Anvil::new().chain_id(constants().ru_chain_id()).spawn(); - let ru_anvil_key = ru_anvil.keys()[0].clone(); - let ru_anvil_key_two = ru_anvil.keys()[1].clone(); - let rollup_key = - PrivateKeySigner::from_bytes(&B256::from_slice(&ru_anvil_key.to_bytes())).unwrap(); - let rollup_key_two = - PrivateKeySigner::from_bytes(&B256::from_slice(&ru_anvil_key_two.to_bytes())).unwrap(); - let ru_provider = RootProvider::new_http(ru_anvil.endpoint_url()); + let (_ru_anvil, ru_provider, rollup_signers) = spawn_rollup_anvil(); + let mut rollup_signers = rollup_signers.into_iter(); + let rollup_key = rollup_signers.next().unwrap(); + let rollup_key_two = rollup_signers.next().unwrap(); // Setup the env task and environments let env_task = EnvTask::new(host_provider.clone(), ru_provider.clone(), quincey).await.unwrap(); - - let prev_host = host_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; - let host_env = env_task.construct_host_env(prev_host); - let prev_ru = ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; - let rollup_env = env_task.construct_rollup_env(prev_ru); + let sim_env = latest_sim_env(&env_task, &host_provider, &ru_provider).await; let (block_env, _jh) = env_task.spawn(); let block_builder = SimulatorTask::new(block_env, host_provider, ru_provider); @@ -89,7 +70,6 @@ async fn test_handle_build() { sim_items.add_tx(tx_2, 0); // Spawn the block builder task - let sim_env = SimEnv { host: host_env, rollup: rollup_env, span: tracing::Span::none() }; let finish_by = Instant::now() + Duration::from_secs(2); let got = block_builder.handle_build(sim_items, finish_by, &sim_env).await; @@ -104,44 +84,23 @@ async fn test_bundle_host_txns() { setup_test_config(); // Setup host provider - let host_anvil = Anvil::new().chain_id(constants().host_chain_id()).spawn(); - let host_anvil_key = host_anvil.keys()[0].clone(); - let host_signer = - PrivateKeySigner::from_bytes(&B256::from_slice(&host_anvil_key.to_bytes())).unwrap(); - let host_wallet = host_anvil.wallet().expect("anvil wallet"); - let host_provider = ProviderBuilder::new_with_network() - .disable_recommended_fillers() - .filler(BlobGasFiller) - .with_gas_estimation() - .with_nonce_management(SimpleNonceManager::default()) - .fetch_chain_id() - .wallet(host_wallet) - .connect_http(host_anvil.endpoint_url()); + let (_host_anvil, host_provider, host_signer) = spawn_host_anvil(); let host_chain_id = host_provider.get_chain_id().await.expect("gets host chain id"); assert_eq!(host_chain_id, constants().host_chain_id()); // Setup rollup provider - let ru_anvil = Anvil::new().chain_id(constants().ru_chain_id()).spawn(); - let ru_anvil_key = ru_anvil.keys()[0].clone(); - let rollup_signer = - PrivateKeySigner::from_bytes(&B256::from_slice(&ru_anvil_key.to_bytes())).unwrap(); - let ru_provider = RootProvider::new_http(ru_anvil.endpoint_url()); + let (_ru_anvil, ru_provider, rollup_signers) = spawn_rollup_anvil(); + let rollup_signer = rollup_signers.into_iter().next().unwrap(); let ru_chain_id = ru_provider.get_chain_id().await.expect("gets ru chain id"); assert_eq!(ru_chain_id, constants().ru_chain_id()); let quincey = builder::config().connect_quincey().await.unwrap(); // Setup the simulation environments - let env = EnvTask::new(host_provider.clone(), ru_provider.clone(), quincey).await.unwrap(); - let host_previous = - host_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; - let ru_previous = - ru_provider.clone().get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; - let host_env = env.construct_host_env(host_previous); - let ru_env = env.construct_rollup_env(ru_previous); + let env_task = EnvTask::new(host_provider.clone(), ru_provider.clone(), quincey).await.unwrap(); + let sim_env = latest_sim_env(&env_task, &host_provider, &ru_provider).await; // Create a simulation environment and plumbing - let sim_env = SimEnv { host: host_env, rollup: ru_env, span: tracing::Span::none() }; let (sim_tx, sim_rx) = channel::>(None); // Create a host and rollup transaction @@ -187,3 +146,50 @@ async fn test_bundle_host_txns() { // Cleanup simulator_jh.abort(); } + +async fn latest_sim_env( + env_task: &EnvTask, + host_provider: &HostProvider, + ru_provider: &RuProvider, +) -> SimEnv { + let host_previous = + host_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; + let ru_previous = + ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; + + let host_env = env_task.construct_host_env(host_previous); + let ru_env = env_task.construct_rollup_env(ru_previous); + + SimEnv { host: host_env, rollup: ru_env, span: tracing::Span::none() } +} + +fn spawn_host_anvil() -> (AnvilInstance, HostProvider, PrivateKeySigner) { + let anvil = Anvil::new().chain_id(constants().host_chain_id()).spawn(); + let key = anvil.keys()[0].clone(); + let signer = PrivateKeySigner::from_bytes(&B256::from_slice(&key.to_bytes())).unwrap(); + let wallet = anvil.wallet().expect("anvil wallet"); + let provider = ProviderBuilder::new_with_network() + .disable_recommended_fillers() + .filler(BlobGasFiller) + .with_gas_estimation() + .with_nonce_management(SimpleNonceManager::default()) + .fetch_chain_id() + .wallet(wallet) + .connect_http(anvil.endpoint_url()); + + (anvil, provider, signer) +} + +fn spawn_rollup_anvil() -> (AnvilInstance, RuProvider, Vec) { + let anvil = Anvil::new().chain_id(constants().ru_chain_id()).spawn(); + let signers: Vec<_> = anvil + .keys() + .iter() + .take(2) + .map(|key| PrivateKeySigner::from_bytes(&B256::from_slice(&key.to_bytes())).unwrap()) + .collect(); + assert!(signers.len() >= 2, "rollup anvil must provide at least two accounts"); + let provider = RootProvider::new_http(anvil.endpoint_url()); + + (anvil, provider, signers) +} From b7af0e3b31b032142865e578e1083056e5bee645 Mon Sep 17 00:00:00 2001 From: dylan Date: Wed, 3 Dec 2025 13:00:53 -0700 Subject: [PATCH 5/6] fmt + clippy --- src/lib.rs | 2 ++ tests/block_builder_test.rs | 3 +-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/src/lib.rs b/src/lib.rs index b727a412..1ce39f27 100644 --- a/src/lib.rs +++ b/src/lib.rs @@ -34,8 +34,10 @@ pub mod utils; pub mod test_utils; use init4_bin_base::utils::from_env::FromEnv; + // Anonymous import suppresses warnings about unused imports. use openssl as _; +use signet_bundle as _; use signet_constants::SignetSystemConstants; use std::sync::OnceLock; diff --git a/tests/block_builder_test.rs b/tests/block_builder_test.rs index 17c722aa..477716dc 100644 --- a/tests/block_builder_test.rs +++ b/tests/block_builder_test.rs @@ -154,8 +154,7 @@ async fn latest_sim_env( ) -> SimEnv { let host_previous = host_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; - let ru_previous = - ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; + let ru_previous = ru_provider.get_block(BlockId::latest()).await.unwrap().unwrap().header.inner; let host_env = env_task.construct_host_env(host_previous); let ru_env = env_task.construct_rollup_env(ru_previous); From 4b4452687e1e92c2e8f84582ee768e9de0702f2a Mon Sep 17 00:00:00 2001 From: dylan Date: Wed, 3 Dec 2025 14:26:06 -0700 Subject: [PATCH 6/6] cleanup --- bin/builder.rs | 8 +++----- 1 file changed, 3 insertions(+), 5 deletions(-) diff --git a/bin/builder.rs b/bin/builder.rs index e7bfccea..e3c100bf 100644 --- a/bin/builder.rs +++ b/bin/builder.rs @@ -16,17 +16,15 @@ async fn main() -> eyre::Result<()> { let init_span_guard = info_span!("builder initialization"); let config = builder::config_from_env(); - let (env_host_provider, sim_host_provider, env_ru_provider, sim_ru_provider, quincey) = tokio::try_join!( + let (host_provider, ru_provider, quincey) = tokio::try_join!( config.connect_host_provider(), - config.connect_host_provider(), - config.connect_ru_provider(), config.connect_ru_provider(), config.connect_quincey(), )?; // Set up env and metrics tasks let (env_task, metrics_task) = tokio::try_join!( - EnvTask::new(env_host_provider, env_ru_provider, quincey), + EnvTask::new(host_provider.clone(), ru_provider.clone(), quincey), MetricsTask::new() )?; @@ -37,7 +35,7 @@ async fn main() -> eyre::Result<()> { // Set up the cache, submit, and simulator tasks let cache_tasks = CacheTasks::new(block_env.clone()); let submit_task = FlashbotsTask::new(tx_channel.clone()).await?; - let simulator_task = SimulatorTask::new(block_env, sim_host_provider, sim_ru_provider); + let simulator_task = SimulatorTask::new(block_env, host_provider.clone(), ru_provider.clone()); // Spawn the cache, submit, and simulator tasks let cache_system = cache_tasks.spawn();