Configure --network providers in snfoundry.toml (#3874)

MKowalski8 · web-flow · commit 16f570897cdf · 2025-11-05T09:31:24.000Z
Closes #3765 Stack: - #3874 ⬅ - #3875 ## Introduced changes  - Add possibility to configure used providers via `--network` flag in `snfoundry.toml` ## Checklist  - [x] Linked relevant issue - [x] Updated relevant documentation - [x] Added relevant tests - [x] Performed self-review of the code - [x] Added changes to `CHANGELOG.md`
diff --git a/crates/sncast/src/helpers/config.rs b/crates/sncast/src/helpers/config.rs
@@ -50,6 +50,12 @@ fn build_default_manifest() -> String {
         # accounts-file = "{default_accounts_file}"
         # account = ""
         # keystore = ""
+        
+        # Configure custom network addresses
+        # [sncast.default.networks]
+        # mainnet = "https://mainnet.your-node.com"
+        # sepolia = "https://sepolia.your-node.com"
+        # devnet = "http://127.0.0.1:5050/rpc"
         "#,
         default_accounts_file = DEFAULT_ACCOUNTS_FILE,
         default_wait_timeout = default_wait_params.timeout,
@@ -79,6 +85,9 @@ macro_rules! clone_field {
 pub fn combine_cast_configs(global_config: &CastConfig, local_config: &CastConfig) -> CastConfig {
     let default_cast_config = CastConfig::default();
 
+    let mut networks = global_config.networks.clone();
+    networks.override_with(&local_config.networks);
+
     CastConfig {
         url: clone_field!(global_config, local_config, default_cast_config, url),
         account: clone_field!(global_config, local_config, default_cast_config, account),
@@ -107,5 +116,6 @@ pub fn combine_cast_configs(global_config: &CastConfig, local_config: &CastConfi
             default_cast_config,
             show_explorer_links
         ),
+        networks,
     }
 }
diff --git a/crates/sncast/src/helpers/configuration.rs b/crates/sncast/src/helpers/configuration.rs
@@ -1,5 +1,5 @@
 use super::block_explorer;
-use crate::ValidatedWaitParams;
+use crate::{Network, ValidatedWaitParams};
 use anyhow::Result;
 use camino::Utf8PathBuf;
 use configuration::Config;
@@ -10,6 +10,37 @@ pub const fn show_explorer_links_default() -> bool {
     true
 }
 
+#[derive(Deserialize, Serialize, Clone, Debug, PartialEq, Default)]
+#[serde(deny_unknown_fields)]
+pub struct NetworksConfig {
+    pub mainnet: Option<String>,
+    pub sepolia: Option<String>,
+    pub devnet: Option<String>,
+}
+
+impl NetworksConfig {
+    #[must_use]
+    pub fn get_url(&self, network: Network) -> Option<&String> {
+        match network {
+            Network::Mainnet => self.mainnet.as_ref(),
+            Network::Sepolia => self.sepolia.as_ref(),
+            Network::Devnet => self.devnet.as_ref(),
+        }
+    }
+
+    pub fn override_with(&mut self, other: &NetworksConfig) {
+        if other.mainnet.is_some() {
+            self.mainnet.clone_from(&other.mainnet);
+        }
+        if other.sepolia.is_some() {
+            self.sepolia.clone_from(&other.sepolia);
+        }
+        if other.devnet.is_some() {
+            self.devnet.clone_from(&other.devnet);
+        }
+    }
+}
+
 #[derive(Deserialize, Serialize, Clone, Debug, PartialEq)]
 pub struct CastConfig {
     #[serde(default)]
@@ -46,6 +77,10 @@ pub struct CastConfig {
     )]
     /// Print links pointing to pages with transaction details in the chosen block explorer
     pub show_explorer_links: bool,
+
+    #[serde(default)]
+    /// Configurable urls of predefined networks - mainnet, sepolia, and devnet are supported
+    pub networks: NetworksConfig,
 }
 
 impl Default for CastConfig {
@@ -58,6 +93,7 @@ impl Default for CastConfig {
             wait_params: ValidatedWaitParams::default(),
             block_explorer: Some(block_explorer::Service::default()),
             show_explorer_links: show_explorer_links_default(),
+            networks: NetworksConfig::default(),
         }
     }
 }
@@ -71,3 +107,71 @@ impl Config for CastConfig {
         Ok(serde_json::from_value::<CastConfig>(config)?)
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn test_networks_config_get() {
+        let networks = NetworksConfig {
+            mainnet: Some("https://mainnet.example.com".to_string()),
+            sepolia: Some("https://sepolia.example.com".to_string()),
+            devnet: Some("https://devnet.example.com".to_string()),
+        };
+
+        assert_eq!(
+            networks.get_url(Network::Mainnet),
+            Some(&"https://mainnet.example.com".to_string())
+        );
+        assert_eq!(
+            networks.get_url(Network::Sepolia),
+            Some(&"https://sepolia.example.com".to_string())
+        );
+        assert_eq!(
+            networks.get_url(Network::Devnet),
+            Some(&"https://devnet.example.com".to_string())
+        );
+    }
+
+    #[test]
+    fn test_networks_config_override() {
+        let mut global = NetworksConfig {
+            mainnet: Some("https://global-mainnet.example.com".to_string()),
+            sepolia: Some("https://global-sepolia.example.com".to_string()),
+            devnet: None,
+        };
+        let local = NetworksConfig {
+            mainnet: Some("https://local-mainnet.example.com".to_string()),
+            sepolia: None,
+            devnet: None,
+        };
+
+        global.override_with(&local);
+
+        // Local mainnet should override global
+        assert_eq!(
+            global.mainnet,
+            Some("https://local-mainnet.example.com".to_string())
+        );
+        // Global sepolia should remain
+        assert_eq!(
+            global.sepolia,
+            Some("https://global-sepolia.example.com".to_string())
+        );
+    }
+
+    #[test]
+    fn test_networks_config_rejects_unknown_fields_and_typos() {
+        // Unknown fields should cause an error
+        let toml_str = r#"
+            mainnet = "https://mainnet.example.com"
+            custom = "https://custom.example.com"
+            wrong_key = "https://sepolia.example.com"
+        "#;
+
+        let result: Result<NetworksConfig, _> = toml::from_str(toml_str);
+        assert!(result.is_err());
+        assert!(result.unwrap_err().to_string().contains("unknown field"));
+    }
+}
diff --git a/crates/sncast/src/helpers/rpc.rs b/crates/sncast/src/helpers/rpc.rs
@@ -36,7 +36,7 @@ impl RpcArgs {
             )
         }
 
-        let url = self.get_url(&config.url).await?;
+        let url = self.get_url(config).await?;
 
         assert!(!url.is_empty(), "url cannot be empty");
         let provider = get_provider(&url)?;
@@ -46,15 +46,20 @@ impl RpcArgs {
         Ok(provider)
     }
 
-    pub async fn get_url(&self, config_url: &str) -> Result<String> {
-        match (&self.network, &self.url, config_url) {
-            (Some(network), None, _) => {
-                let free_provider = FreeProvider::semi_random();
-                network.url(&free_provider).await
-            }
+    pub async fn get_url(&self, config: &CastConfig) -> Result<String> {
+        match (&self.network, &self.url, &config.url) {
+            (Some(network), None, _) => self.resolve_network_url(network, config).await,
             (None, Some(url), _) => Ok(url.clone()),
-            (None, None, config_url) if !config_url.is_empty() => Ok(config_url.to_string()),
-            _ => bail!("Either `--network` or `--url` must be provided"),
+            (None, None, url) if !url.is_empty() => Ok(url.clone()),
+            _ => bail!("Either `--network` or `--url` must be provided."),
+        }
+    }
+
+    async fn resolve_network_url(&self, network: &Network, config: &CastConfig) -> Result<String> {
+        if let Some(custom_url) = config.networks.get_url(*network) {
+            Ok(custom_url.clone())
+        } else {
+            network.url(&FreeProvider::semi_random()).await
         }
     }
 }
@@ -147,4 +152,37 @@ mod tests {
         let spec_version = provider.spec_version().await.unwrap();
         assert!(is_expected_version(&Version::parse(&spec_version).unwrap()));
     }
+
+    #[tokio::test]
+    async fn test_custom_network_url_from_config() {
+        let mut config = CastConfig::default();
+        config.networks.mainnet =
+            Some("https://starknet-mainnet.infura.io/v3/custom-api-key".to_string());
+        config.networks.sepolia =
+            Some("https://starknet-sepolia.g.alchemy.com/v2/custom-api-key".to_string());
+
+        let rpc_args = RpcArgs {
+            url: None,
+            network: Some(Network::Mainnet),
+        };
+
+        let url = rpc_args.get_url(&config).await.unwrap();
+        assert_eq!(
+            url,
+            "https://starknet-mainnet.infura.io/v3/custom-api-key".to_string()
+        );
+    }
+
+    #[tokio::test]
+    async fn test_fallback_to_default_network_url() {
+        let config = CastConfig::default();
+
+        let rpc_args = RpcArgs {
+            url: None,
+            network: Some(Network::Mainnet),
+        };
+
+        let url = rpc_args.get_url(&config).await.unwrap();
+        assert_eq!(url, Network::free_mainnet_rpc(&FreeProvider::Alchemy));
+    }
 }
diff --git a/crates/sncast/src/lib.rs b/crates/sncast/src/lib.rs
@@ -287,7 +287,7 @@ pub async fn get_account<'a>(
         }
         (true, false) => {
             let url = rpc_args
-                .get_url(&config.url)
+                .get_url(config)
                 .await
                 .context("Failed to get url")?;
             return get_account_from_devnet(account, provider, &url).await;
diff --git a/crates/sncast/src/main.rs b/crates/sncast/src/main.rs
@@ -335,7 +335,7 @@ async fn run_async_command(cli: Cli, config: CastConfig, ui: &UI) -> Result<()>
                     serde_json::from_str(&contract_artifacts.sierra)
                         .context("Failed to parse sierra artifact")?;
                 let network_flag = generate_network_flag(
-                    rpc.get_url(&config.url).await.ok().as_deref(),
+                    rpc.get_url(&config).await.ok().as_deref(),
                     rpc.network.as_ref(),
                 );
                 Some(DeployCommandMessage::new(
@@ -742,11 +742,11 @@ fn get_cast_config(cli: &Cli, ui: &UI) -> Result<CastConfig> {
 
     let global_config =
         load_config::<CastConfig>(Some(&global_config_path.clone()), cli.profile.as_deref())
-            .unwrap_or_else(|_| {
-                load_config::<CastConfig>(Some(&global_config_path), None).unwrap()
-            });
+            .or_else(|_| load_config::<CastConfig>(Some(&global_config_path), None))
+            .map_err(|err| anyhow::anyhow!(format!("Failed to load config: {err}")))?;
 
-    let local_config = load_config::<CastConfig>(None, cli.profile.as_deref())?;
+    let local_config = load_config::<CastConfig>(None, cli.profile.as_deref())
+        .map_err(|err| anyhow::anyhow!(format!("Failed to load config: {err}")))?;
 
     let mut combined_config = combine_cast_configs(&global_config, &local_config);
 
diff --git a/crates/sncast/src/starknet_commands/script/mod.rs b/crates/sncast/src/starknet_commands/script/mod.rs
@@ -79,7 +79,7 @@ pub fn run_script_command(
                 )))
             };
             let url = runtime
-                .block_on(run.rpc.get_url(&config.url))
+                .block_on(run.rpc.get_url(&config))
                 .context("Failed to get url")?;
             let result = starknet_commands::script::run::run(
                 &run.script_name,

Original file line number	Diff line number	Diff line change
`@@ -287,7 +287,7 @@ pub async fn get_account<'a>(`
`287`	`287`	`}`
`288`	`288`	`(true, false) => {`
`289`	`289`	`let url = rpc_args`
`290`		`- .get_url(&config.url)`
	`290`	`+ .get_url(config)`
`291`	`291`	`.await`
`292`	`292`	`.context("Failed to get url")?;`
`293`	`293`	`return get_account_from_devnet(account, provider, &url).await;`