fix: simplify provider connection

Author: prestwich

bin/builder.rs

@@ -23,11 +23,9 @@ async fn main() -> eyre::Result<()> {
     let constants = config.load_pecorino_constants();
     let authenticator = Authenticator::new(&config)?;
 
-    let (host_provider, ru_provider, sequencer_signer) = tokio::try_join!(
-        config.connect_host_provider(),
-        config.connect_ru_provider(),
-        config.connect_sequencer_signer(),
-    )?;
+    let (host_provider, sequencer_signer) =
+        tokio::try_join!(config.connect_host_provider(), config.connect_sequencer_signer(),)?;
+    let ru_provider = config.connect_ru_provider();
 
     let zenith = config.connect_zenith(host_provider.clone());
 

src/config.rs

@@ -18,7 +18,7 @@ use init4_bin_base::utils::{calc::SlotCalculator, from_env::FromEnv};
 use oauth2::url;
 use signet_types::config::{HostConfig, PredeployTokens, RollupConfig, SignetSystemConstants};
 use signet_zenith::Zenith;
-use std::{borrow::Cow, num};
+use std::borrow::Cow;
 
 /// Configuration for a builder running a specific rollup on a specific host
 /// chain.
@@ -142,39 +142,6 @@ pub struct BuilderConfig {
     pub slot_calculator: SlotCalculator,
 }
 
-/// Error loading the configuration.
-#[derive(Debug, thiserror::Error)]
-pub enum ConfigError {
-    /// Error loading from environment variable
-    #[error("missing or non-unicode environment variable: {0}")]
-    Var(String),
-    /// Error parsing environment variable
-    #[error("failed to parse environment variable: {0}")]
-    Parse(#[from] num::ParseIntError),
-    /// Error parsing boolean environment variable
-    #[error("failed to parse boolean environment variable")]
-    ParseBool,
-    /// Error parsing hex from environment variable
-    #[error("failed to parse hex: {0}")]
-    Hex(#[from] hex::FromHexError),
-    /// Error connecting to the provider
-    #[error("failed to connect to provider: {0}")]
-    Provider(#[from] alloy::transports::TransportError),
-    /// Error connecting to the signer
-    #[error("failed to connect to signer: {0}")]
-    Signer(#[from] SignerError),
-    /// I/O error
-    #[error("I/O error: {0}")]
-    Io(#[from] std::io::Error),
-}
-
-impl ConfigError {
-    /// Missing or non-unicode env var.
-    pub fn missing(s: &str) -> Self {
-        ConfigError::Var(s.to_string())
-    }
-}
-
 /// Type alias for the provider used to build and submit blocks to the host.
 pub type HostProvider = FillProvider<
     JoinFill<
@@ -196,51 +163,47 @@ pub type ZenithInstance<P = HostProvider> = Zenith::ZenithInstance<(), P, alloy:
 
 impl BuilderConfig {
     /// Connect to the Builder signer.
-    pub async fn connect_builder_signer(&self) -> Result<LocalOrAws, ConfigError> {
-        LocalOrAws::load(&self.builder_key, Some(self.host_chain_id)).await.map_err(Into::into)
+    pub async fn connect_builder_signer(&self) -> Result<LocalOrAws, SignerError> {
+        LocalOrAws::load(&self.builder_key, Some(self.host_chain_id)).await
     }
 
     /// Connect to the Sequencer signer.
-    pub async fn connect_sequencer_signer(&self) -> Result<Option<LocalOrAws>, ConfigError> {
-        match &self.sequencer_key {
-            Some(sequencer_key) => LocalOrAws::load(sequencer_key, Some(self.host_chain_id))
+    pub async fn connect_sequencer_signer(&self) -> eyre::Result<Option<LocalOrAws>> {
+        if let Some(sequencer_key) = &self.sequencer_key {
+            LocalOrAws::load(sequencer_key, Some(self.host_chain_id))
                 .await
                 .map_err(Into::into)
-                .map(Some),
-            None => Ok(None),
+                .map(Some)
+        } else {
+            Ok(None)
         }
     }
 
     /// Connect to the Rollup rpc provider.
-    pub async fn connect_ru_provider(&self) -> Result<RootProvider<Ethereum>, ConfigError> {
+    pub fn connect_ru_provider(&self) -> RootProvider<Ethereum> {
         let url = url::Url::parse(&self.ru_rpc_url).expect("failed to parse URL");
-        let provider = RootProvider::<Ethereum>::new_http(url);
-        Ok(provider)
+        RootProvider::<Ethereum>::new_http(url)
     }
 
     /// Connect to the Host rpc provider.
-    pub async fn connect_host_provider(&self) -> Result<HostProvider, ConfigError> {
+    pub async fn connect_host_provider(&self) -> eyre::Result<HostProvider> {
         let builder_signer = self.connect_builder_signer().await?;
-        let provider = ProviderBuilder::new()
+        ProviderBuilder::new()
             .wallet(EthereumWallet::from(builder_signer))
             .connect(&self.host_rpc_url)
             .await
-            .map_err(ConfigError::Provider)?;
-
-        Ok(provider)
+            .map_err(Into::into)
     }
 
     /// Connect additional broadcast providers.
-    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)
+    pub fn connect_additional_broadcast(&self) -> Vec<RootProvider> {
+        self.tx_broadcast_urls
+            .iter()
+            .map(|url_str| {
+                let url = url::Url::parse(url_str).expect("failed to parse URL");
+                RootProvider::new_http(url)
+            })
+            .collect::<Vec<_>>()
     }
 
     /// Connect to the Zenith instance, using the specified provider.

src/tasks/submit.rs

@@ -206,7 +206,7 @@ impl SubmitTask {
         let fut = spawn_provider_send!(&self.host_provider, &tx);
 
         // Spawn send_tx futures for all additional broadcast host_providers
-        for host_provider in self.config.connect_additional_broadcast().await? {
+        for host_provider in self.config.connect_additional_broadcast() {
             spawn_provider_send!(&host_provider, &tx);
         }