Use url::Url instead of string across sncast (#4017)

<!-- Reference any GitHub issues resolved by this PR -->

**Stack**
- #4020
- #4019
- #4017 ⬅
- #4013

Closes #

## Introduced changes

<!-- A brief description of the changes -->

-

## Checklist

<!-- Make sure all of these are complete -->

- [ ] Linked relevant issue
- [ ] Updated relevant documentation
- [x] Added relevant tests
- [x] Performed self-review of the code
- [ ] Added changes to `CHANGELOG.md`

Author: franciszekjob

Cargo.lock

@@ -13,3 +13,6 @@ serde.workspace = true
 camino.workspace = true
 toml.workspace = true
 tempfile.workspace = true
+
+[dev-dependencies]
+url.workspace = true

crates/configuration/Cargo.toml

@@ -79,12 +79,12 @@ pub fn find_config_file() -> Result<Utf8PathBuf> {
 
 #[cfg(test)]
 mod tests {
-    use std::fs::{self, File};
-
     use super::*;
     use crate::test_utils::copy_config_to_tempdir;
     use serde::{Deserialize, Serialize};
+    use std::fs::{self, File};
     use tempfile::tempdir;
+    use url::Url;
 
     #[test]
     fn find_config_in_current_dir() {
@@ -151,8 +151,7 @@ mod tests {
 
     #[derive(Debug, Default, Serialize, Deserialize)]
     pub struct StubConfig {
-        #[serde(default)]
-        pub url: String,
+        pub url: Option<Url>,
         #[serde(default)]
         pub account: String,
     }
@@ -162,7 +161,7 @@ mod tests {
         }
 
         fn from_raw(config: serde_json::Value) -> Result<Self> {
-            Ok(serde_json::from_value::<StubConfig>(config)?)
+            Ok(serde_json::from_value::<Self>(config)?)
         }
     }
     #[test]
@@ -174,7 +173,10 @@ mod tests {
         )
         .unwrap();
         assert_eq!(config.account, String::from("user3"));
-        assert_eq!(config.url, String::from("http://127.0.0.1:5050/rpc"));
+        assert_eq!(
+            config.url,
+            Some(Url::parse("http://127.0.0.1:5050/rpc").unwrap())
+        );
     }
 
     #[test]
@@ -186,7 +188,24 @@ mod tests {
         )
         .unwrap();
         assert_eq!(config.account, String::from("user1"));
-        assert_eq!(config.url, String::from("http://127.0.0.1:5055/rpc"));
+        assert_eq!(
+            config.url,
+            Some(Url::parse("http://127.0.0.1:5055/rpc").unwrap())
+        );
+    }
+    #[test]
+    fn load_config_invalid_url() {
+        let tempdir = copy_config_to_tempdir("tests/data/stubtool_snfoundry.toml", None);
+        let err = load_config::<StubConfig>(
+            Some(&Utf8PathBuf::try_from(tempdir.path().to_path_buf()).unwrap()),
+            Some(&String::from("profile6")),
+        )
+        .unwrap_err();
+
+        assert!(
+            err.to_string()
+                .contains("relative URL without a base: \"invalid_url\"")
+        );
     }
 
     #[test]
@@ -199,7 +218,7 @@ mod tests {
         .unwrap();
 
         assert_eq!(config.account, String::new());
-        assert_eq!(config.url, String::new());
+        assert_eq!(config.url, None);
     }
 
     #[derive(Debug, Default, Serialize, Deserialize)]
@@ -231,7 +250,7 @@ mod tests {
         }
 
         fn from_raw(config: serde_json::Value) -> Result<Self> {
-            Ok(serde_json::from_value::<StubComplexConfig>(config)?)
+            Ok(serde_json::from_value::<Self>(config)?)
         }
     }
 

crates/configuration/src/lib.rs

@@ -24,11 +24,15 @@ account = "user3"
 
 [stubtool.profile5]
 url = "http://127.0.0.1:5055/rpc"
+
+[stubtool.profile6]
+url = "invalid_url"
 account = "user8"
 
 [stubtool.with-envs]
 url = "$VALUE_STRING123132"
 account = "$VALUE_INT123132"
+
 [stubtool.with-envs.nested]
 list-example = [ "$VALUE_BOOL1231321", "$VALUE_BOOL1231322"  ]
 url-nested = "$VALUE_FLOAT123132"

crates/configuration/tests/data/stubtool_snfoundry.toml

@@ -35,7 +35,7 @@ pub(crate) async fn warn_if_incompatible_rpc_version(
     for url in urls {
         let ui = ui.clone();
         handles.push(tokio::spawn(async move {
-            let client = create_rpc_client(url.as_ref())?;
+            let client = create_rpc_client(&url)?;
 
             verify_and_warn_if_incompatible_rpc_version(&client, &url, &ui).await
         }));

crates/forge/src/warn.rs

@@ -7,9 +7,8 @@ use starknet_rust::providers::{JsonRpcClient, Provider};
 use std::str::FromStr;
 use url::Url;
 
-pub fn create_rpc_client(url: &str) -> Result<JsonRpcClient<HttpTransport>> {
-    let parsed_url = Url::parse(url).with_context(|| format!("Failed to parse URL: {url}"))?;
-    let client = JsonRpcClient::new(HttpTransport::new(parsed_url));
+pub fn create_rpc_client(url: &Url) -> Result<JsonRpcClient<HttpTransport>> {
+    let client = JsonRpcClient::new(HttpTransport::new(url.clone()));
     Ok(client)
 }
 

crates/shared/src/rpc.rs

@@ -10,6 +10,7 @@ use starknet_rust::{
 };
 use std::collections::{HashMap, HashSet};
 use std::fs;
+use url::Url;
 
 use crate::{AccountData, read_and_parse_json_file};
 use anyhow::Context;
@@ -82,14 +83,14 @@ pub fn is_devnet_account(account: &str) -> bool {
 pub async fn get_account_from_devnet<'a>(
     account: &str,
     provider: &'a JsonRpcClient<HttpTransport>,
-    url: &str,
+    url: &Url,
 ) -> Result<SingleOwnerAccount<&'a JsonRpcClient<HttpTransport>, LocalWallet>> {
     let account_number: u8 = account
         .strip_prefix("devnet-")
         .map(|s| s.parse::<u8>().expect("Invalid devnet account number"))
         .context("Failed to parse devnet account number")?;
 
-    let devnet_provider = DevnetProvider::new(url);
+    let devnet_provider = DevnetProvider::new(url.as_ref());
     devnet_provider.ensure_alive().await?;
 
     let devnet_config = devnet_provider.get_config().await;

crates/sncast/src/helpers/account.rs

@@ -4,6 +4,7 @@ use anyhow::Result;
 use camino::Utf8PathBuf;
 use configuration::Config;
 use serde::{Deserialize, Serialize};
+use url::Url;
 
 #[must_use]
 pub const fn show_explorer_links_default() -> bool {
@@ -13,14 +14,14 @@ pub const fn show_explorer_links_default() -> bool {
 #[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>,
+    pub mainnet: Option<Url>,
+    pub sepolia: Option<Url>,
+    pub devnet: Option<Url>,
 }
 
 impl NetworksConfig {
     #[must_use]
-    pub fn get_url(&self, network: Network) -> Option<&String> {
+    pub fn get_url(&self, network: Network) -> Option<&Url> {
         match network {
             Network::Mainnet => self.mainnet.as_ref(),
             Network::Sepolia => self.sepolia.as_ref(),
@@ -45,7 +46,7 @@ impl NetworksConfig {
 pub struct CastConfig {
     #[serde(default)]
     /// RPC url
-    pub url: String,
+    pub url: Option<Url>,
 
     #[serde(default)]
     pub account: String,
@@ -86,7 +87,7 @@ pub struct CastConfig {
 impl Default for CastConfig {
     fn default() -> Self {
         Self {
-            url: String::default(),
+            url: None,
             account: String::default(),
             accounts_file: Utf8PathBuf::default(),
             keystore: None,
@@ -104,7 +105,7 @@ impl Config for CastConfig {
     }
 
     fn from_raw(config: serde_json::Value) -> Result<Self> {
-        Ok(serde_json::from_value::<CastConfig>(config)?)
+        Ok(serde_json::from_value::<Self>(config)?)
     }
 }
 
@@ -115,34 +116,34 @@ mod tests {
     #[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()),
+            mainnet: Some(Url::parse("https://mainnet.example.com").unwrap()),
+            sepolia: Some(Url::parse("https://sepolia.example.com").unwrap()),
+            devnet: Some(Url::parse("https://devnet.example.com").unwrap()),
         };
 
         assert_eq!(
             networks.get_url(Network::Mainnet),
-            Some(&"https://mainnet.example.com".to_string())
+            Some(&Url::parse("https://mainnet.example.com").unwrap())
         );
         assert_eq!(
             networks.get_url(Network::Sepolia),
-            Some(&"https://sepolia.example.com".to_string())
+            Some(&Url::parse("https://sepolia.example.com").unwrap())
         );
         assert_eq!(
             networks.get_url(Network::Devnet),
-            Some(&"https://devnet.example.com".to_string())
+            Some(&Url::parse("https://devnet.example.com").unwrap())
         );
     }
 
     #[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()),
+            mainnet: Some(Url::parse("https://global-mainnet.example.com").unwrap()),
+            sepolia: Some(Url::parse("https://global-sepolia.example.com").unwrap()),
             devnet: None,
         };
         let local = NetworksConfig {
-            mainnet: Some("https://local-mainnet.example.com".to_string()),
+            mainnet: Some(Url::parse("https://local-mainnet.example.com").unwrap()),
             sepolia: None,
             devnet: None,
         };
@@ -152,12 +153,12 @@ mod tests {
         // Local mainnet should override global
         assert_eq!(
             global.mainnet,
-            Some("https://local-mainnet.example.com".to_string())
+            Some(Url::parse("https://local-mainnet.example.com").unwrap())
         );
         // Global sepolia should remain
         assert_eq!(
             global.sepolia,
-            Some("https://global-sepolia.example.com".to_string())
+            Some(Url::parse("https://global-sepolia.example.com").unwrap())
         );
     }
 

crates/sncast/src/helpers/configuration.rs

@@ -1,8 +1,8 @@
 mod direct;
 mod docker;
 mod flag_parsing;
-
 use std::process::Command;
+use url::Url;
 
 use crate::helpers::devnet::provider::DevnetProvider;
 
@@ -31,9 +31,11 @@ pub enum DevnetDetectionError {
         "Found starknet-devnet process, but could not reach it. Please use `--url <URL>` to specify the correct URL."
     )]
     ProcessNotReachable,
+    #[error("Failed to parse devnet URL: {0}")]
+    InvalidUrl(#[from] url::ParseError),
 }
 
-pub async fn detect_devnet_url() -> Result<String, DevnetDetectionError> {
+pub async fn detect_devnet_url() -> Result<Url, DevnetDetectionError> {
     detect_devnet_from_processes().await
 }
 
@@ -42,21 +44,21 @@ pub async fn is_devnet_running() -> bool {
     detect_devnet_from_processes().await.is_ok()
 }
 
-async fn detect_devnet_from_processes() -> Result<String, DevnetDetectionError> {
+async fn detect_devnet_from_processes() -> Result<Url, DevnetDetectionError> {
     match find_devnet_process_info() {
         Ok(info) => {
             if is_devnet_url_reachable(&info.host, info.port).await {
-                Ok(format!("http://{}:{}", info.host, info.port))
+                Ok(Url::parse(&format!("http://{}:{}", info.host, info.port))?)
             } else {
                 Err(DevnetDetectionError::ProcessNotReachable)
             }
         }
         Err(DevnetDetectionError::NoInstance | DevnetDetectionError::CommandFailed) => {
             // Fallback to default starknet-devnet URL if reachable
             if is_devnet_url_reachable(DEFAULT_DEVNET_HOST, DEFAULT_DEVNET_PORT).await {
-                Ok(format!(
+                Ok(Url::parse(&format!(
                     "http://{DEFAULT_DEVNET_HOST}:{DEFAULT_DEVNET_PORT}"
-                ))
+                ))?)
             } else {
                 Err(DevnetDetectionError::NoInstance)
             }