apollo_config: generic comma-separated deserializer (#9643)

Author: asmaastarkware

Cargo.lock

@@ -14,8 +14,6 @@ const_format.workspace = true
 itertools.workspace = true
 serde = { workspace = true, features = ["derive"] }
 serde_json = { workspace = true, features = ["arbitrary_precision"] }
-starknet-types-core.workspace = true
-starknet_api.workspace = true
 strum_macros.workspace = true
 thiserror.workspace = true
 tracing.workspace = true

crates/apollo_config/Cargo.toml

@@ -31,8 +31,6 @@ use std::time::Duration;
 
 use serde::de::Error;
 use serde::{Deserialize, Deserializer, Serialize};
-use starknet_api::core::ContractAddress;
-use starknet_types_core::felt::Felt;
 use url::Url;
 
 /// Deserializes milliseconds to duration object.
@@ -264,7 +262,7 @@ where
     T: FromStr,
     T::Err: std::fmt::Display,
 {
-    let raw: String = <String as serde::Deserialize>::deserialize(de)?;
+    let raw = String::deserialize(de)?;
 
     if raw.trim().is_empty() {
         return Ok(Vec::new());
@@ -275,38 +273,28 @@ where
         .collect()
 }
 
-// TODO(Asmaa): refactor this to `deserialize_comma_separated_str<T>` where
-// T: TryFrom<&str>, to support deserializing comma-separated lists of any type.
-/// Deserializes an optional comma-separated list of contract addresses into
-/// `Option<Vec<ContractAddress>>`. An empty string is invalid if the `#is_none` flag is false.
-pub fn deserialize_optional_contract_addresses<'de, D>(
-    de: D,
-) -> Result<Option<Vec<ContractAddress>>, D::Error>
+/// Deserializes an optional comma-separated list of values implementing `FromStr` into
+/// `Option<Vec<T>>`. Returns `None` for empty or missing strings.
+pub fn deserialize_comma_separated_str<'de, D, T>(de: D) -> Result<Option<Vec<T>>, D::Error>
 where
     D: Deserializer<'de>,
+    T: FromStr,
+    <T as FromStr>::Err: std::fmt::Display,
 {
-    let raw: String = match Option::<String>::deserialize(de)? {
-        Some(addresses) => addresses,
-        None => return Ok(None),
-    };
-
-    if raw.is_empty() {
-        return Err(D::Error::custom(
-            "Empty string is not a valid input for contract addresses. The config field is marked \
-             as not none.",
-        ));
+    let raw = String::deserialize(de).unwrap_or_default();
+    if raw.trim().is_empty() {
+        return Ok(None);
     }
 
-    let mut result = Vec::new();
-    for addresses_str in raw.split(',') {
-        let felt = Felt::from_str(addresses_str).map_err(|err| {
-            D::Error::custom(format!("Failed to parse Felt from '{addresses_str}': {err}"))
-        })?;
-        let addr = ContractAddress::try_from(felt).map_err(|err| {
-            D::Error::custom(format!("Invalid contract address '{addresses_str}': {err}"))
-        })?;
-        result.push(addr);
+    let mut output: Vec<T> = Vec::new();
+    for part in raw.split(',').filter(|s| !s.is_empty()) {
+        let value = T::from_str(part)
+            .map_err(|e| D::Error::custom(format!("Invalid value '{part}': {e}")))?;
+        output.push(value);
     }
 
-    Ok(Some(result))
+    if output.is_empty() {
+        return Ok(None);
+    }
+    Ok(Some(output))
 }

crates/apollo_config/src/converters.rs

@@ -3,8 +3,8 @@ use std::fmt::Debug;
 use std::time::Duration;
 
 use apollo_config::converters::{
+    deserialize_comma_separated_str,
     deserialize_milliseconds_to_duration,
-    deserialize_optional_contract_addresses,
     deserialize_seconds_to_duration,
 };
 use apollo_config::dumping::{ser_optional_param, ser_param, SerializeConfig};
@@ -96,7 +96,7 @@ pub struct ContextConfig {
     pub num_validators: u64,
     /// Optional explicit set of validator IDs (contract addresses) to use.
     /// If provided, this overrides `num_validators`.
-    #[serde(default, deserialize_with = "deserialize_optional_contract_addresses")]
+    #[serde(default, deserialize_with = "deserialize_comma_separated_str")]
     pub validator_ids: Option<Vec<ContractAddress>>,
     /// The chain id of the Starknet chain.
     pub chain_id: ChainId,

crates/apollo_consensus_orchestrator_config/src/config.rs

@@ -1,6 +1,6 @@
 use std::collections::BTreeMap;
 
-use apollo_config::converters::deserialize_optional_contract_addresses;
+use apollo_config::converters::deserialize_comma_separated_str;
 use apollo_config::dumping::{
     prepend_sub_config_name,
     ser_optional_param,
@@ -25,7 +25,7 @@ pub struct GatewayConfig {
     pub stateful_tx_validator_config: StatefulTransactionValidatorConfig,
     pub chain_info: ChainInfo,
     pub block_declare: bool,
-    #[serde(default, deserialize_with = "deserialize_optional_contract_addresses")]
+    #[serde(default, deserialize_with = "deserialize_comma_separated_str")]
     pub authorized_declarer_accounts: Option<Vec<ContractAddress>>,
 }
 

crates/apollo_gateway_config/src/config.rs

@@ -19,10 +19,10 @@ mod test_utils;
 pub mod utils;
 
 use std::collections::{BTreeMap, HashSet};
-use std::str::FromStr;
 use std::time::Duration;
 
 use apollo_config::converters::{
+    deserialize_comma_separated_str,
     deserialize_optional_vec_u8,
     deserialize_seconds_to_duration,
     serialize_optional_vec_u8,
@@ -39,42 +39,12 @@ use discovery::DiscoveryConfig;
 use libp2p::swarm::dial_opts::DialOpts;
 use libp2p::Multiaddr;
 use peer_manager::PeerManagerConfig;
-use serde::de::Error;
-use serde::{Deserialize, Deserializer, Serialize};
+use serde::{Deserialize, Serialize};
 use starknet_api::core::ChainId;
 use validator::{Validate, ValidationError};
 
 pub(crate) type Bytes = Vec<u8>;
 
-// TODO(AndrewL): Fix this
-/// This function considers `""` to be `None` and
-/// `"multiaddr1,multiaddr2"` to be `Some(vec![multiaddr1, multiaddr2])`.
-/// It was purposefully designed this way to be compatible with the old config where only one
-/// bootstrap peer was supported. Hence there is no way to express an empty vector in the config.
-fn deserialize_multi_addrs<'de, D>(de: D) -> Result<Option<Vec<Multiaddr>>, D::Error>
-where
-    D: Deserializer<'de>,
-{
-    let raw_str: String = Deserialize::deserialize(de).unwrap_or_default();
-    if raw_str.is_empty() {
-        return Ok(None);
-    }
-
-    let mut vector = Vec::new();
-    for i in raw_str.split(',').filter(|s| !s.is_empty()) {
-        let value = Multiaddr::from_str(i).map_err(|_| {
-            D::Error::custom(format!("Couldn't deserialize vector. Failed to parse value: {i}"))
-        })?;
-        vector.push(value);
-    }
-
-    if vector.is_empty() {
-        return Ok(None);
-    }
-
-    Ok(Some(vector))
-}
-
 // TODO(Tsabary): move to the config converter module.
 pub fn serialize_multi_addrs(multi_addrs: &Option<Vec<Multiaddr>>) -> String {
     match multi_addrs {
@@ -95,7 +65,7 @@ pub struct NetworkConfig {
     pub session_timeout: Duration,
     #[serde(deserialize_with = "deserialize_seconds_to_duration")]
     pub idle_connection_timeout: Duration,
-    #[serde(deserialize_with = "deserialize_multi_addrs")]
+    #[serde(deserialize_with = "deserialize_comma_separated_str")]
     #[validate(custom(function = "validate_bootstrap_peer_multiaddr_list"))]
     pub bootstrap_peer_multiaddr: Option<Vec<Multiaddr>>,
     #[validate(custom = "validate_vec_u256")]

crates/apollo_network/src/lib.rs

@@ -3,6 +3,7 @@
 mod core_test;
 
 use std::fmt::Debug;
+use std::str::FromStr;
 use std::sync::LazyLock;
 
 use num_traits::ToPrimitive;
@@ -154,6 +155,15 @@ impl From<u128> for ContractAddress {
 
 impl_from_through_intermediate!(u128, ContractAddress, u8, u16, u32, u64);
 
+impl FromStr for ContractAddress {
+    type Err = StarknetApiError;
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let felt = Felt::from_str(s)
+            .map_err(|e| StarknetApiError::OutOfRange { string: format!("{e}") })?;
+        Ok(ContractAddress(PatriciaKey::try_from(felt)?))
+    }
+}
+
 /// The maximal size of storage var.
 pub const MAX_STORAGE_ITEM_SIZE: u16 = 256;
 /// The prefix used in the calculation of a contract address.