Support devnet in --network flag (#3786)

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

Closes #3764 

## Introduced changes

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

- Implement `devnet` detection for `--network` flag

## Checklist

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

- [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`

Author: MKowalski8

CHANGELOG.md

@@ -21,6 +21,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Debug logging for `sncast` commands that can be enabled by setting `CAST_LOG` env variable.
 - `sncast declare` command now outputs a ready-to-use deployment command after successful declaration.
 - Possibility to use [`starknet-devnet`](https://github.com/0xSpaceShard/starknet-devnet) predeployed accounts directly in `sncast` without needing to import them. They are available under specific names - `devnet-1`, `devnet-2`, ..., `devnet-<N>`. Read more [here](https://foundry-rs.github.io/starknet-foundry/starknet/integration_with_devnet.html#predeployed-accounts)
+- Support for `--network devnet` flag that attempts to auto-detect running `starknet-devnet` instance and connect to it.
 - Support for automatically declaring the contract when running `sncast deploy`, by providing `--contract-name` flag instead of `--class-hash`. 
 
 ## [0.50.0] - 2025-09-29

crates/sncast/src/helpers/account.rs

@@ -1,5 +1,5 @@
 use crate::{
-    NestedMap, build_account, check_account_file_exists, helpers::devnet_provider::DevnetProvider,
+    NestedMap, build_account, check_account_file_exists, helpers::devnet::provider::DevnetProvider,
 };
 use anyhow::{Result, ensure};
 use camino::Utf8PathBuf;

crates/sncast/src/helpers/block_explorer.rs

@@ -24,6 +24,7 @@ impl Service {
             (Service::ViewBlock, Network::Mainnet) => Ok(Box::new(ViewBlock)),
             (Service::OkLink, Network::Mainnet) => Ok(Box::new(OkLink)),
             (_, Network::Sepolia) => Err(ExplorerError::SepoliaNotSupported),
+            (_, Network::Devnet) => Err(ExplorerError::DevnetNotSupported),
         }
     }
 }
@@ -36,8 +37,8 @@ pub trait LinkProvider {
 
 const fn network_subdomain(network: Network) -> &'static str {
     match network {
-        Network::Mainnet => "",
         Network::Sepolia => "sepolia.",
+        Network::Mainnet | Network::Devnet => "",
     }
 }
 

crates/sncast/src/helpers/devnet/detection.rs

@@ -0,0 +1,115 @@
+mod direct;
+mod docker;
+mod flag_parsing;
+
+use std::process::Command;
+
+use crate::helpers::devnet::provider::DevnetProvider;
+
+pub(super) const DEFAULT_DEVNET_HOST: &str = "127.0.0.1";
+pub(super) const DEFAULT_DEVNET_PORT: u16 = 5050;
+
+#[derive(Debug, Clone)]
+pub(super) struct ProcessInfo {
+    pub host: String,
+    pub port: u16,
+}
+
+#[derive(Debug, thiserror::Error)]
+pub enum DevnetDetectionError {
+    #[error(
+        "Could not detect running starknet-devnet instance. Please use `--url <URL>` instead or start devnet."
+    )]
+    NoInstance,
+    #[error(
+        "Multiple starknet-devnet instances found. Please use `--url <URL>` to specify which one to use."
+    )]
+    MultipleInstances,
+    #[error("Failed to execute process detection command.")]
+    CommandFailed,
+    #[error(
+        "Found starknet-devnet process, but could not reach it. Please use `--url <URL>` to specify the correct URL."
+    )]
+    ProcessNotReachable,
+}
+
+pub async fn detect_devnet_url() -> Result<String, DevnetDetectionError> {
+    detect_devnet_from_processes().await
+}
+
+#[must_use]
+pub async fn is_devnet_running() -> bool {
+    detect_devnet_from_processes().await.is_ok()
+}
+
+async fn detect_devnet_from_processes() -> Result<String, 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))
+            } 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!(
+                    "http://{DEFAULT_DEVNET_HOST}:{DEFAULT_DEVNET_PORT}"
+                ))
+            } else {
+                Err(DevnetDetectionError::NoInstance)
+            }
+        }
+        Err(e) => Err(e),
+    }
+}
+
+fn find_devnet_process_info() -> Result<ProcessInfo, DevnetDetectionError> {
+    let output = Command::new("sh")
+        .args(["-c", "ps aux | grep starknet-devnet | grep -v grep"])
+        .output()
+        .map_err(|_| DevnetDetectionError::CommandFailed)?;
+    let ps_output = String::from_utf8_lossy(&output.stdout);
+
+    let devnet_processes: Result<Vec<ProcessInfo>, DevnetDetectionError> = ps_output
+        .lines()
+        .map(|line| {
+            if line.contains("docker") || line.contains("podman") {
+                docker::extract_devnet_info_from_docker_run(line)
+            } else {
+                direct::extract_devnet_info_from_direct_run(line)
+            }
+        })
+        .collect();
+
+    let devnet_processes = devnet_processes?;
+
+    match devnet_processes.as_slice() {
+        [single] => Ok(single.clone()),
+        [] => Err(DevnetDetectionError::NoInstance),
+        _ => Err(DevnetDetectionError::MultipleInstances),
+    }
+}
+
+async fn is_devnet_url_reachable(host: &str, port: u16) -> bool {
+    let url = format!("http://{host}:{port}");
+
+    let provider = DevnetProvider::new(&url);
+    provider.ensure_alive().await.is_ok()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[tokio::test]
+    async fn test_detect_devnet_url() {
+        let result = detect_devnet_url().await;
+        assert!(result.is_err());
+        assert!(matches!(
+            result.unwrap_err(),
+            DevnetDetectionError::NoInstance
+        ));
+    }
+}

crates/sncast/src/helpers/devnet/detection/direct.rs

@@ -0,0 +1,150 @@
+use crate::helpers::devnet::detection::flag_parsing::{
+    extract_port_from_flag, extract_string_from_flag,
+};
+use crate::helpers::devnet::detection::{
+    DEFAULT_DEVNET_HOST, DEFAULT_DEVNET_PORT, DevnetDetectionError, ProcessInfo,
+};
+
+pub fn extract_devnet_info_from_direct_run(
+    cmdline: &str,
+) -> Result<ProcessInfo, DevnetDetectionError> {
+    let mut port = extract_port_from_flag(cmdline, "--port");
+    let mut host = extract_string_from_flag(cmdline, "--host");
+
+    if port.is_none()
+        && let Ok(port_env) = std::env::var("PORT")
+    {
+        port = Some(
+            port_env
+                .parse()
+                .map_err(|_| DevnetDetectionError::ProcessNotReachable)?,
+        );
+    }
+
+    if host.is_none()
+        && let Ok(host_env) = std::env::var("HOST")
+        && !host_env.is_empty()
+    {
+        host = Some(host_env);
+    }
+
+    let final_port = port.unwrap_or(DEFAULT_DEVNET_PORT);
+    let final_host = host.unwrap_or_else(|| DEFAULT_DEVNET_HOST.to_string());
+
+    Ok(ProcessInfo {
+        host: final_host,
+        port: final_port,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    // These tests are marked to run serially to avoid interference from environment variables
+    #[test]
+    fn test_direct_devnet_parsing() {
+        test_extract_devnet_info_from_cmdline();
+        test_extract_devnet_info_with_both_envs();
+        test_invalid_env();
+        test_cmdline_args_override_env();
+        test_wrong_env_var();
+    }
+
+    fn test_extract_devnet_info_from_cmdline() {
+        let cmdline1 = "starknet-devnet --port 6000 --host 127.0.0.1";
+        let info1 = extract_devnet_info_from_direct_run(cmdline1).unwrap();
+        assert_eq!(info1.port, 6000);
+        assert_eq!(info1.host, "127.0.0.1");
+
+        let cmdline2 = "/usr/bin/starknet-devnet --port=5000";
+        let info2 = extract_devnet_info_from_direct_run(cmdline2).unwrap();
+        assert_eq!(info2.port, 5000);
+        assert_eq!(info2.host, "127.0.0.1");
+
+        let cmdline3 = "starknet-devnet --host 127.0.0.1";
+        let info3 = extract_devnet_info_from_direct_run(cmdline3).unwrap();
+        assert_eq!(info3.port, 5050);
+        assert_eq!(info3.host, "127.0.0.1");
+    }
+
+    fn test_extract_devnet_info_with_both_envs() {
+        // SAFETY: Variables are only modified within this test and cleaned up afterwards
+        unsafe {
+            std::env::set_var("PORT", "9999");
+            std::env::set_var("HOST", "9.9.9.9");
+        }
+
+        let cmdline = "starknet-devnet";
+        let info = extract_devnet_info_from_direct_run(cmdline).unwrap();
+        assert_eq!(info.port, 9999);
+        assert_eq!(info.host, "9.9.9.9");
+
+        // SAFETY: Clean up environment variables to prevent interference
+        unsafe {
+            std::env::remove_var("PORT");
+            std::env::remove_var("HOST");
+        }
+    }
+
+    fn test_invalid_env() {
+        // SAFETY: Variables are only modified within this test and cleaned up afterwards
+        unsafe {
+            std::env::set_var("PORT", "asdf");
+            std::env::set_var("HOST", "9.9.9.9");
+        }
+        let cmdline = "starknet-devnet";
+        let result = extract_devnet_info_from_direct_run(cmdline);
+        assert!(result.is_err());
+        assert!(matches!(
+            result.unwrap_err(),
+            DevnetDetectionError::ProcessNotReachable
+        ));
+
+        // SAFETY: Clean up environment variables to prevent interference
+        unsafe {
+            std::env::remove_var("PORT");
+            std::env::remove_var("HOST");
+        }
+    }
+
+    fn test_cmdline_args_override_env() {
+        // SAFETY: Variables are only modified within this test and cleaned up afterwards
+        unsafe {
+            std::env::set_var("PORT", "3000");
+            std::env::set_var("HOST", "7.7.7.7");
+        }
+
+        let cmdline = "starknet-devnet --port 9999 --host 192.168.1.1";
+        let info = extract_devnet_info_from_direct_run(cmdline).unwrap();
+        assert_eq!(info.port, 9999);
+        assert_eq!(info.host, "192.168.1.1");
+
+        // SAFETY: Clean up environment variables to prevent interference
+        unsafe {
+            std::env::remove_var("PORT");
+            std::env::remove_var("HOST");
+        }
+    }
+
+    fn test_wrong_env_var() {
+        // SAFETY: Variables are only modified within this test and cleaned up afterwards
+        unsafe {
+            std::env::set_var("PORT", "asdf");
+        }
+
+        // Empty HOST env var should be ignored and defaults should be used
+        let cmdline = "starknet-devnet";
+        let result = extract_devnet_info_from_direct_run(cmdline);
+        assert!(result.is_err());
+        assert!(matches!(
+            result.unwrap_err(),
+            DevnetDetectionError::ProcessNotReachable
+        ));
+
+        // SAFETY: Clean up environment variables to prevent interference
+        unsafe {
+            std::env::remove_var("PORT");
+        }
+    }
+}