fix(common): ipc provider windows (foundry-rs#5831)

* fix(common): ipc provider windows

* temp: run windows action

* Revert "temp: run windows action"

This reverts commit a4f39a0.

Author: bernard-wagner

crates/common/src/provider.rs

@@ -6,7 +6,12 @@ use ethers_middleware::gas_oracle::{GasCategory, GasOracle, Polygon};
 use ethers_providers::{is_local_endpoint, Middleware, Provider, DEFAULT_LOCAL_POLL_INTERVAL};
 use eyre::WrapErr;
 use reqwest::{IntoUrl, Url};
-use std::{borrow::Cow, env, path::Path, time::Duration};
+use std::{
+    borrow::Cow,
+    env,
+    path::{Path, PathBuf},
+    time::Duration,
+};
 use url::ParseError;
 
 /// Helper type alias for a retry provider
@@ -68,31 +73,23 @@ impl ProviderBuilder {
         }
 
         let url = Url::parse(url_str)
-            .or_else(|err| {
-                match err {
-                    ParseError::RelativeUrlWithoutBase => {
-                        let path = Path::new(url_str);
-                        let absolute_path = if path.is_absolute() {
-                            path.to_path_buf()
-                        } else {
-                            // Assume the path is relative to the current directory.
-                            // Don't use `std::fs::canonicalize` as it requires the path to exist.
-                            // It should be possible to construct a provider and only
-                            // attempt to establish a connection later
-                            let current_dir =
-                                env::current_dir().expect("Current directory should exist");
-                            current_dir.join(path)
-                        };
-
-                        let path_str =
-                            absolute_path.to_str().expect("Path should be a valid string");
-
-                        // invalid url: non-prefixed URL scheme is not allowed, so we assume the URL
-                        // is for a local file
-                        Url::parse(format!("file://{path_str}").as_str())
+            .or_else(|err| match err {
+                ParseError::RelativeUrlWithoutBase => {
+                    let path = Path::new(url_str);
+
+                    if let Ok(path) = resolve_path(path) {
+                        Url::parse(
+                            format!(
+                                "file://{path_str}",
+                                path_str = path.to_str().expect("Should be valid string")
+                            )
+                            .as_str(),
+                        )
+                    } else {
+                        Err(err)
                     }
-                    _ => Err(err),
                 }
+                _ => Err(err),
             })
             .wrap_err(format!("Invalid provider url: {url_str}"));
 
@@ -280,6 +277,28 @@ where
     provider.estimate_eip1559_fees(None).await.wrap_err("Failed fetch EIP1559 fees")
 }
 
+#[cfg(not(windows))]
+fn resolve_path(path: &Path) -> Result<PathBuf, ()> {
+    if path.is_absolute() {
+        Ok(path.to_path_buf())
+    } else {
+        Ok(env::current_dir()
+            .map(|current_dir| current_dir.join(path))
+            .expect("Current directory should exist"))
+    }
+}
+
+#[cfg(windows)]
+fn resolve_path(path: &Path) -> Result<PathBuf, ()> {
+    let path_str = path.to_str().expect("Path should be a valid string");
+
+    if path_str.starts_with(r"\\.\pipe\") {
+        Ok(PathBuf::from(path_str))
+    } else {
+        Err(())
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

crates/common/src/runtime_client.rs

@@ -9,7 +9,7 @@ use ethers_providers::{
 };
 use reqwest::{header::HeaderValue, Url};
 use serde::{de::DeserializeOwned, Serialize};
-use std::{fmt::Debug, sync::Arc, time::Duration};
+use std::{fmt::Debug, path::PathBuf, sync::Arc, time::Duration};
 use thiserror::Error;
 use tokio::sync::RwLock;
 
@@ -176,9 +176,7 @@ impl RuntimeClient {
                 Ok(InnerClient::Ws(client))
             }
             "file" => {
-                let path = self
-                    .url
-                    .to_file_path()
+                let path = url_to_file_path(&self.url)
                     .map_err(|_| RuntimeClientError::BadPath(self.url.to_string()))?;
 
                 let client = Ipc::connect(path)
@@ -192,6 +190,26 @@ impl RuntimeClient {
     }
 }
 
+#[cfg(windows)]
+fn url_to_file_path(url: &Url) -> Result<PathBuf, ()> {
+    const PREFIX: &str = "file:///pipe/";
+
+    let url_str = url.as_str();
+
+    if url_str.starts_with(PREFIX) {
+        let pipe_name = &url_str[PREFIX.len()..];
+        let pipe_path = format!(r"\\.\pipe\{}", pipe_name);
+        return Ok(PathBuf::from(pipe_path))
+    }
+
+    url.to_file_path()
+}
+
+#[cfg(not(windows))]
+fn url_to_file_path(url: &Url) -> Result<PathBuf, ()> {
+    url.to_file_path()
+}
+
 #[cfg_attr(target_arch = "wasm32", async_trait(?Send))]
 #[cfg_attr(not(target_arch = "wasm32"), async_trait)]
 impl JsonRpcClient for RuntimeClient {