refactor configs

core/bin/zksync_server/src/main.rs

@@ -11,11 +11,11 @@ use zksync_config::{
         },
         fri_prover_group::FriProverGroupConfig,
         house_keeper::HouseKeeperConfig,
-        BasicWitnessInputProducerConfig, ContractsConfig, DatabaseSecrets, ExperimentalVmConfig,
-        ExternalPriceApiClientConfig, FriProofCompressorConfig, FriProverConfig,
-        FriProverGatewayConfig, FriWitnessGeneratorConfig, FriWitnessVectorGeneratorConfig,
-        L1Secrets, ObservabilityConfig, PrometheusConfig, ProofDataHandlerConfig,
-        ProtectiveReadsWriterConfig, Secrets,
+        BasicWitnessInputProducerConfig, ContractsConfig, DataAvailabilitySecrets, DatabaseSecrets,
+        ExperimentalVmConfig, ExternalPriceApiClientConfig, FriProofCompressorConfig,
+        FriProverConfig, FriProverGatewayConfig, FriWitnessGeneratorConfig,
+        FriWitnessVectorGeneratorConfig, L1Secrets, ObservabilityConfig, PrometheusConfig,
+        ProofDataHandlerConfig, ProtectiveReadsWriterConfig, Secrets,
     },
     ApiConfig, BaseTokenAdjusterConfig, ContractVerifierConfig, DAClientConfig, DADispatcherConfig,
     DBConfig, EthConfig, EthWatchConfig, ExternalProofIntegrationApiConfig, GasAdjusterConfig,
@@ -126,6 +126,7 @@ fn main() -> anyhow::Result<()> {
             consensus: config::read_consensus_secrets().context("read_consensus_secrets()")?,
             database: DatabaseSecrets::from_env().ok(),
             l1: L1Secrets::from_env().ok(),
+            data_availability: DataAvailabilitySecrets::from_env().ok(),
         },
     };
 

core/bin/zksync_server/src/node_builder.rs

@@ -1,11 +1,11 @@
 //! This module provides a "builder" for the main node,
 //! as well as an interface to run the node with the specified components.
 
-use anyhow::Context;
+use anyhow::{bail, Context};
 use zksync_config::{
     configs::{
-        da_client::DAClientConfig, eth_sender::PubdataSendingMode, wallets::Wallets, GeneralConfig,
-        Secrets,
+        da_client::DAClientConfig, eth_sender::PubdataSendingMode,
+        secrets::DataAvailabilitySecrets, wallets::Wallets, GeneralConfig, Secrets,
     },
     ContractsConfig, GenesisConfig,
 };
@@ -509,19 +509,22 @@ impl MainNodeBuilder {
             return Ok(self);
         };
 
-        match da_client_config {
-            DAClientConfig::Avail(config) => {
-                self.node.add_layer(AvailWiringLayer::new(config));
+        let secrets = try_load_config!(self.secrets.data_availability);
+        match (da_client_config, secrets) {
+            (DAClientConfig::Avail(config), DataAvailabilitySecrets::Avail(secret)) => {
+                self.node.add_layer(AvailWiringLayer::new(config, secret));
             }
 
-            DAClientConfig::Celestia(config) => {
-                self.node.add_layer(CelestiaWiringLayer::new(config));
+            (DAClientConfig::Celestia(config), DataAvailabilitySecrets::Celestia(secret)) => {
+                self.node
+                    .add_layer(CelestiaWiringLayer::new(config, secret));
             }
 
-            DAClientConfig::ObjectStore(config) => {
+            (DAClientConfig::ObjectStore(config), _) => {
                 self.node
                     .add_layer(ObjectStorageClientWiringLayer::new(config));
             }
+            _ => bail!("invalid pair of da_client and da_secrets"),
         }
 
         Ok(self)

core/lib/config/src/configs/da_client/avail.rs

@@ -8,8 +8,6 @@ pub struct AvailConfig {
     pub app_id: u32,
     pub timeout: usize,
     pub max_retries: usize,
-    #[serde(skip)]
-    pub secrets: Option<AvailSecrets>,
 }
 
 #[derive(Clone, Debug, PartialEq)]

core/lib/config/src/configs/da_client/celestia.rs

@@ -5,8 +5,6 @@ use zksync_basic_types::secrets::PrivateKey;
 pub struct CelestiaConfig {
     pub api_node_url: String,
     pub namespace: String,
-    #[serde(skip)]
-    pub secrets: Option<CelestiaSecrets>,
 }
 
 #[derive(Clone, Debug, PartialEq)]

core/lib/config/src/configs/mod.rs

@@ -25,7 +25,7 @@ pub use self::{
     proof_data_handler::ProofDataHandlerConfig,
     prover_job_monitor::ProverJobMonitorConfig,
     pruning::PruningConfig,
-    secrets::{DatabaseSecrets, L1Secrets, Secrets},
+    secrets::{DataAvailabilitySecrets, DatabaseSecrets, L1Secrets, Secrets},
     snapshot_recovery::SnapshotRecoveryConfig,
     snapshots_creator::SnapshotsCreatorConfig,
     utils::PrometheusConfig,

core/lib/config/src/configs/secrets.rs

@@ -1,7 +1,10 @@
 use anyhow::Context;
 use zksync_basic_types::url::SensitiveUrl;
 
-use crate::configs::consensus::ConsensusSecrets;
+use crate::configs::{
+    consensus::ConsensusSecrets,
+    da_client::{avail::AvailSecrets, celestia::CelestiaSecrets},
+};
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct DatabaseSecrets {
@@ -15,11 +18,18 @@ pub struct L1Secrets {
     pub l1_rpc_url: SensitiveUrl,
 }
 
+#[derive(Debug, Clone, PartialEq)]
+pub enum DataAvailabilitySecrets {
+    Avail(AvailSecrets),
+    Celestia(CelestiaSecrets),
+}
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct Secrets {
     pub consensus: Option<ConsensusSecrets>,
     pub database: Option<DatabaseSecrets>,
     pub l1: Option<L1Secrets>,
+    pub data_availability: Option<DataAvailabilitySecrets>,
 }
 
 impl DatabaseSecrets {

core/lib/config/src/testonly.rs

@@ -865,10 +865,19 @@ impl Distribution<configs::secrets::Secrets> for EncodeDist {
             consensus: self.sample_opt(|| self.sample(rng)),
             database: self.sample_opt(|| self.sample(rng)),
             l1: self.sample_opt(|| self.sample(rng)),
+            data_availability: self.sample_opt(|| self.sample(rng)),
         }
     }
 }
 
+impl Distribution<configs::secrets::DataAvailabilitySecrets> for EncodeDist {
+    fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> configs::secrets::DataAvailabilitySecrets {
+        configs::secrets::DataAvailabilitySecrets::Avail(configs::da_client::avail::AvailSecrets {
+            seed_phrase: SeedPhrase(Secret::new(self.sample(rng))),
+        })
+    }
+}
+
 impl Distribution<configs::wallets::Wallet> for EncodeDist {
     fn sample<R: Rng + ?Sized>(&self, rng: &mut R) -> configs::wallets::Wallet {
         configs::wallets::Wallet::new(K256PrivateKey::from_bytes(rng.gen()).unwrap())
@@ -942,10 +951,6 @@ impl Distribution<configs::da_client::DAClientConfig> for EncodeDist {
             app_id: self.sample(rng),
             timeout: self.sample(rng),
             max_retries: self.sample(rng),
-
-            secrets: Some(configs::da_client::avail::AvailSecrets {
-                seed_phrase: SeedPhrase(Secret::new(self.sample(rng))),
-            }),
         })
     }
 }

core/lib/env_config/src/da_client.rs

@@ -1,11 +1,11 @@
 use std::env;
 
-use zksync_config::{
-    configs::da_client::{
+use zksync_config::configs::{
+    da_client::{
         avail::AvailSecrets, celestia::CelestiaSecrets, DAClientConfig, AVAIL_CLIENT_CONFIG_NAME,
         CELESTIA_CLIENT_CONFIG_NAME, OBJECT_STORE_CLIENT_CONFIG_NAME,
     },
-    AvailConfig, CelestiaConfig,
+    secrets::DataAvailabilitySecrets,
 };
 
 use crate::{envy_load, FromEnv};
@@ -14,26 +14,8 @@ impl FromEnv for DAClientConfig {
     fn from_env() -> anyhow::Result<Self> {
         let client_tag = env::var("DA_CLIENT")?;
         let config = match client_tag.as_str() {
-            AVAIL_CLIENT_CONFIG_NAME => {
-                let mut avail: AvailConfig = envy_load("da_avail_config", "DA_")?;
-                if let Ok(seed) = env::var("DA_SECRETS_SEED_PHRASE") {
-                    avail.secrets = Some(AvailSecrets {
-                        seed_phrase: seed.parse()?,
-                    });
-                }
-
-                Self::Avail(avail)
-            }
-            CELESTIA_CLIENT_CONFIG_NAME => {
-                let mut celestia: CelestiaConfig = envy_load("da_celestia_config", "DA_")?;
-                if let Ok(pk) = env::var("DA_SECRETS_PRIVATE_KEY") {
-                    celestia.secrets = Some(CelestiaSecrets {
-                        private_key: pk.parse()?,
-                    });
-                }
-
-                Self::Celestia(celestia)
-            }
+            AVAIL_CLIENT_CONFIG_NAME => Self::Avail(envy_load("da_avail_config", "DA_")?),
+            CELESTIA_CLIENT_CONFIG_NAME => Self::Celestia(envy_load("da_celestia_config", "DA_")?),
             OBJECT_STORE_CLIENT_CONFIG_NAME => {
                 Self::ObjectStore(envy_load("da_object_store", "DA_")?)
             }
@@ -44,11 +26,38 @@ impl FromEnv for DAClientConfig {
     }
 }
 
+impl FromEnv for DataAvailabilitySecrets {
+    fn from_env() -> anyhow::Result<Self> {
+        let client_tag = std::env::var("DA_CLIENT")?;
+        let secrets = match client_tag.as_str() {
+            AVAIL_CLIENT_CONFIG_NAME => {
+                let seed_phrase = env::var("DA_SECRETS_SEED_PHRASE")
+                    .map_err(|e| anyhow::format_err!("seed phrase not found: {}", e))?
+                    .parse()
+                    .map_err(|e| anyhow::format_err!("failed to parse the seed phrase: {}", e))?;
+
+                Self::Avail(AvailSecrets { seed_phrase })
+            }
+            CELESTIA_CLIENT_CONFIG_NAME => {
+                let private_key = env::var("DA_SECRETS_PRIVATE_KEY")
+                    .map_err(|e| anyhow::format_err!("private key not found: {}", e))?
+                    .parse()
+                    .map_err(|e| anyhow::format_err!("failed to parse the private key: {}", e))?;
+                Self::Celestia(CelestiaSecrets { private_key })
+            }
+
+            _ => anyhow::bail!("Unknown DA client name: {}", client_tag),
+        };
+
+        Ok(secrets)
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use zksync_config::{
         configs::{
-            da_client::{celestia::CelestiaSecrets, DAClientConfig, DAClientConfig::ObjectStore},
+            da_client::{DAClientConfig, DAClientConfig::ObjectStore},
             object_store::ObjectStoreMode::GCS,
         },
         AvailConfig, CelestiaConfig, ObjectStoreConfig,
@@ -93,18 +102,13 @@ mod tests {
         app_id: u32,
         timeout: usize,
         max_retries: usize,
-        seed: &str,
     ) -> DAClientConfig {
         DAClientConfig::Avail(AvailConfig {
             api_node_url: api_node_url.to_string(),
             bridge_api_url: bridge_api_url.to_string(),
             app_id,
             timeout,
             max_retries,
-
-            secrets: Some(AvailSecrets {
-                seed_phrase: seed.parse().unwrap(),
-            }),
         })
     }
 
@@ -133,23 +137,36 @@ mod tests {
                 "1".parse::<u32>().unwrap(),
                 "2".parse::<usize>().unwrap(),
                 "3".parse::<usize>().unwrap(),
-                "bottom drive obey lake curtain smoke basket hold race lonely fit walk"
             )
         );
     }
 
-    fn expected_celestia_da_layer_config(
-        pk: &str,
-        api_node_url: &str,
-        namespace: &str,
-    ) -> DAClientConfig {
+    #[test]
+    fn from_env_avail_secrets() {
+        let mut lock = MUTEX.lock();
+        let config = r#"
+            DA_CLIENT="Avail"
+            DA_SECRETS_SEED_PHRASE="bottom drive obey lake curtain smoke basket hold race lonely fit walk"
+        "#;
+
+        lock.set_env(config);
+
+        let DataAvailabilitySecrets::Avail(actual) = DataAvailabilitySecrets::from_env().unwrap()
+        else {
+            panic!("expected Avail config")
+        };
+        assert_eq!(
+            actual.seed_phrase,
+            "bottom drive obey lake curtain smoke basket hold race lonely fit walk"
+                .parse()
+                .unwrap()
+        );
+    }
+
+    fn expected_celestia_da_layer_config(api_node_url: &str, namespace: &str) -> DAClientConfig {
         DAClientConfig::Celestia(CelestiaConfig {
             api_node_url: api_node_url.to_string(),
             namespace: namespace.to_string(),
-
-            secrets: Some(CelestiaSecrets {
-                private_key: pk.parse().unwrap(),
-            }),
         })
     }
 
@@ -160,19 +177,36 @@ mod tests {
             DA_CLIENT="Celestia"
             DA_API_NODE_URL="localhost:12345"
             DA_NAMESPACE="0x1234567890abcdef"
-
-            DA_SECRETS_PRIVATE_KEY="0xf55baf7c0e4e33b1d78fbf52f069c426bc36cff1aceb9bc8f45d14c07f034d73"
         "#;
         lock.set_env(config);
 
         let actual = DAClientConfig::from_env().unwrap();
         assert_eq!(
             actual,
-            expected_celestia_da_layer_config(
-                "0xf55baf7c0e4e33b1d78fbf52f069c426bc36cff1aceb9bc8f45d14c07f034d73",
-                "localhost:12345",
-                "0x1234567890abcdef"
-            )
+            expected_celestia_da_layer_config("localhost:12345", "0x1234567890abcdef")
+        );
+    }
+
+    #[test]
+    fn from_env_celestia_secrets() {
+        let mut lock = MUTEX.lock();
+        let config = r#"
+            DA_CLIENT="Celestia"
+            DA_SECRETS_PRIVATE_KEY="0xf55baf7c0e4e33b1d78fbf52f069c426bc36cff1aceb9bc8f45d14c07f034d73"
+        "#;
+
+        lock.set_env(config);
+
+        let DataAvailabilitySecrets::Celestia(actual) =
+            DataAvailabilitySecrets::from_env().unwrap()
+        else {
+            panic!("expected Celestia config")
+        };
+        assert_eq!(
+            actual.private_key,
+            "0xf55baf7c0e4e33b1d78fbf52f069c426bc36cff1aceb9bc8f45d14c07f034d73"
+                .parse()
+                .unwrap()
         );
     }
 }

core/lib/env_config/src/database.rs

@@ -1,23 +1,8 @@
-use std::{env, error, str::FromStr};
+use std::env;
 
-use anyhow::Context as _;
 use zksync_config::{configs::DatabaseSecrets, DBConfig, PostgresConfig};
 
-use crate::{envy_load, FromEnv};
-
-fn parse_optional_var<T>(name: &str) -> anyhow::Result<Option<T>>
-where
-    T: FromStr,
-    T::Err: 'static + error::Error + Send + Sync,
-{
-    env::var(name)
-        .ok()
-        .map(|val| {
-            val.parse()
-                .with_context(|| format!("failed to parse env variable {name}"))
-        })
-        .transpose()
-}
+use crate::{envy_load, utils::parse_optional_var, FromEnv};
 
 impl FromEnv for DBConfig {
     fn from_env() -> anyhow::Result<Self> {