refactors the rollup provider type

- refactors the rollup provider type from a FillProvider to a RootProvider
- defines the alloy database provider type around this
- updates relevant connection functions to use the new RuProvider type
- renames Provider to HostProvider
- renames WalletlessProvider to RuProvider

Author: dylanlott

bin/submit_transaction.rs

@@ -6,7 +6,7 @@ use alloy::{
     signers::aws::AwsSigner,
 };
 use aws_config::BehaviorVersion;
-use builder::config::{Provider, load_address, load_string, load_u64, load_url};
+use builder::config::{HostProvider, load_address, load_string, load_u64, load_url};
 use init4_bin_base::{
     deps::metrics::{counter, histogram},
     init4,
@@ -30,7 +30,7 @@ async fn main() {
     }
 }
 
-async fn send_transaction(provider: Provider, recipient_address: Address) {
+async fn send_transaction(provider: HostProvider, recipient_address: Address) {
     // construct simple transaction to send ETH to a recipient
     let tx = TransactionRequest::default()
         .with_from(provider.default_signer_address())
@@ -67,7 +67,7 @@ async fn send_transaction(provider: Provider, recipient_address: Address) {
     histogram!("txn_submitter.tx_mine_time").record(mine_time as f64);
 }
 
-async fn connect_from_config() -> (Provider, Address, u64) {
+async fn connect_from_config() -> (HostProvider, Address, u64) {
     // load signer config values from .env
     let rpc_url = load_url("RPC_URL").unwrap();
     let chain_id = load_u64("CHAIN_ID").unwrap();

src/config.rs

@@ -11,6 +11,7 @@ use alloy::{
     },
 };
 use eyre::Result;
+use oauth2::url;
 use signet_types::config::{HostConfig, PredeployTokens, RollupConfig, SignetSystemConstants};
 use signet_zenith::Zenith;
 use std::{borrow::Cow, env, num, str::FromStr};
@@ -135,8 +136,8 @@ impl ConfigError {
     }
 }
 
-/// Type alias for the provider used in the builder.
-pub type Provider = FillProvider<
+/// Type alias for the provider used to build and submit blocks to the host.
+pub type HostProvider = FillProvider<
     JoinFill<
         JoinFill<
             Identity,
@@ -148,18 +149,11 @@ pub type Provider = FillProvider<
     Ethereum,
 >;
 
-/// 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,
-    Ethereum,
->;
+/// Type alias for the provider used to simulate against rollup state.
+pub type RuProvider = RootProvider<Ethereum>;
 
 /// A [`Zenith`] contract instance using [`Provider`] as the provider.
-pub type ZenithInstance<P = Provider> = Zenith::ZenithInstance<(), P, alloy::network::Ethereum>;
+pub type ZenithInstance<P = HostProvider> = Zenith::ZenithInstance<(), P, alloy::network::Ethereum>;
 
 impl BuilderConfig {
     /// Load the builder configuration from environment variables.
@@ -217,17 +211,14 @@ impl BuilderConfig {
     }
 
     /// Connect to the Rollup rpc provider.
-    pub async fn connect_ru_provider(&self) -> Result<WalletlessProvider, ConfigError> {
-        let provider = ProviderBuilder::new()
-            .connect(&self.ru_rpc_url)
-            .await
-            .map_err(ConfigError::Provider)?;
-
+    pub async fn connect_ru_provider(&self) -> Result<RootProvider<Ethereum>, ConfigError> {
+        let url = url::Url::parse(&self.ru_rpc_url).expect("failed to parse URL");
+        let provider = RootProvider::<Ethereum>::new_http(url);
         Ok(provider)
     }
 
     /// Connect to the Host rpc provider.
-    pub async fn connect_host_provider(&self) -> Result<Provider, ConfigError> {
+    pub async fn connect_host_provider(&self) -> Result<HostProvider, ConfigError> {
         let builder_signer = self.connect_builder_signer().await?;
         let provider = ProviderBuilder::new()
             .wallet(EthereumWallet::from(builder_signer))
@@ -239,22 +230,20 @@ impl BuilderConfig {
     }
 
     /// Connect additional broadcast providers.
-    pub async fn connect_additional_broadcast(
-        &self,
-    ) -> 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().connect(url).await.map_err(ConfigError::Provider)?;
+    pub async fn connect_additional_broadcast(&self) -> Result<Vec<RootProvider>, ConfigError> {
+        let mut providers: Vec<RootProvider> = Vec::with_capacity(self.tx_broadcast_urls.len());
 
+        for url_str in self.tx_broadcast_urls.iter() {
+            let url = url::Url::parse(url_str).expect("failed to parse URL");
+            let provider = RootProvider::new_http(url);
             providers.push(provider);
         }
+
         Ok(providers)
     }
 
     /// Connect to the Zenith instance, using the specified provider.
-    pub const fn connect_zenith(&self, provider: Provider) -> ZenithInstance {
+    pub const fn connect_zenith(&self, provider: HostProvider) -> ZenithInstance {
         Zenith::new(self.zenith_address, provider)
     }
 

src/tasks/block.rs

@@ -1,10 +1,11 @@
 use crate::{
-    config::{BuilderConfig, WalletlessProvider},
+    config::{BuilderConfig, RuProvider},
     tasks::bundler::Bundle,
 };
 use alloy::{
     consensus::TxEnvelope,
     eips::{BlockId, BlockNumberOrTag::Latest},
+    network::Ethereum,
     providers::Provider,
 };
 use signet_sim::{BlockBuild, BuiltBlock, SimCache};
@@ -42,11 +43,13 @@ pub struct Simulator {
     /// Configuration for the builder.
     pub config: BuilderConfig,
     /// A provider that cannot sign transactions, used for interacting with the rollup.
-    pub ru_provider: WalletlessProvider,
+    pub ru_provider: RuProvider,
     /// The slot calculator for determining when to wake up and build blocks.
     pub slot_calculator: SlotCalculator,
 }
 
+type AlloyDatabaseProvider = WrapDatabaseAsync<AlloyDB<Ethereum, RuProvider>>;
+
 impl Simulator {
     /// Creates a new `Simulator` instance.
     ///
@@ -61,7 +64,7 @@ impl Simulator {
     /// A new `Simulator` instance.
     pub fn new(
         config: &BuilderConfig,
-        ru_provider: WalletlessProvider,
+        ru_provider: RuProvider,
         slot_calculator: SlotCalculator,
     ) -> Self {
         Self { config: config.clone(), ru_provider, slot_calculator }
@@ -276,18 +279,20 @@ impl Simulator {
     /// # Returns
     ///
     /// An `Option` containing the wrapped database or `None` if an error occurs.
-    async fn create_db(&self) -> Option<WrapAlloyDatabaseAsync> {
+    async fn create_db(&self) -> Option<AlloyDatabaseProvider> {
         let latest = match self.ru_provider.get_block_number().await {
             Ok(block_number) => block_number,
             Err(e) => {
                 tracing::error!(error = %e, "failed to get latest block number");
                 return None;
             }
         };
-        let alloy_db = AlloyDB::new(self.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")
-        });
+        let alloy_db: AlloyDB<Ethereum, RuProvider> =
+            AlloyDB::new(self.ru_provider.clone(), BlockId::from(latest));
+        let wrapped_db: WrapDatabaseAsync<AlloyDB<Ethereum, RuProvider>> =
+            WrapDatabaseAsync::new(alloy_db).unwrap_or_else(|| {
+                panic!("failed to acquire async alloy_db; check which runtime you're using")
+            });
         Some(wrapped_db)
     }
 }
@@ -329,29 +334,6 @@ async fn cache_updater(
     }
 }
 
-/// The wrapped alloy database type that is compatible with `Db` and `DatabaseRef`.
-type WrapAlloyDatabaseAsync = 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,
-        >,
-    >,
->;
-
 /// Configuration struct for Pecorino network values.
 #[derive(Debug, Clone)]
 pub struct PecorinoCfg {}

src/tasks/metrics.rs

@@ -1,4 +1,4 @@
-use crate::config::Provider;
+use crate::config::HostProvider;
 use alloy::{primitives::TxHash, providers::Provider as _};
 use init4_bin_base::deps::metrics::{counter, histogram};
 use std::time::Instant;
@@ -9,7 +9,7 @@ use tracing::{debug, error};
 #[derive(Debug, Clone)]
 pub struct MetricsTask {
     /// Ethereum Provider
-    pub host_provider: Provider,
+    pub host_provider: HostProvider,
 }
 
 impl MetricsTask {

src/tasks/submit.rs

@@ -1,5 +1,5 @@
 use crate::{
-    config::{Provider, ZenithInstance},
+    config::{HostProvider, ZenithInstance},
     signer::LocalOrAws,
     utils::extract_signature_components,
 };
@@ -58,7 +58,7 @@ pub enum ControlFlow {
 #[derive(Debug, Clone)]
 pub struct SubmitTask {
     /// Ethereum Provider
-    pub host_provider: Provider,
+    pub host_provider: HostProvider,
     /// Zenith
     pub zenith: ZenithInstance,
     /// Reqwest

tests/block_builder_test.rs

@@ -2,7 +2,7 @@
 #[cfg(test)]
 mod tests {
     use alloy::{
-        node_bindings::Anvil, primitives::U256, providers::ProviderBuilder,
+        network::Ethereum, node_bindings::Anvil, primitives::U256, providers::RootProvider,
         signers::local::PrivateKeySigner,
     };
     use builder::{
@@ -41,7 +41,7 @@ mod tests {
         let test_key_1 = PrivateKeySigner::from_signing_key(keys[1].clone().into());
 
         // Create a rollup provider
-        let ru_provider = ProviderBuilder::new().on_http(anvil_instance.endpoint_url());
+        let ru_provider = RootProvider::<Ethereum>::new_http(anvil_instance.endpoint_url());
 
         // Create a block builder with a slot calculator for testing
         let now = SystemTime::now()
@@ -100,7 +100,7 @@ mod tests {
         let (block_sender, mut block_receiver) = unbounded_channel();
 
         // Create a rollup provider
-        let ru_provider = ProviderBuilder::new().on_http(anvil_instance.endpoint_url());
+        let ru_provider = RootProvider::<Ethereum>::new_http(anvil_instance.endpoint_url());
 
         // Create a builder with a test slot calculator
         let slot_calculator = SlotCalculator::new(