[cli] Fix windows faucet wallet issue (#24384)

## Description 

This PR fixes an issue flagged in #24041. Unfortunately, Windows does
not allow clients to connect to 0.0.0.0, which was the case here, and
led to an error when the faucet had to make an RPC client to node.

## Test plan 

Existing tests. Manually tested on Windows!

---

## Release notes

Check each box that your changes affect. If none of the boxes relate to
your changes, release notes aren't required.

For each box you select, include information after the relevant heading
that describes the impact of your changes that a user might notice and
any actions they must take to implement updates.

- [ ] Protocol: 
- [ ] Nodes (Validators and Full nodes): 
- [ ] gRPC:
- [ ] JSON-RPC: 
- [ ] GraphQL: 
- [ ] CLI: 
- [ ] Rust SDK:
- [ ] Indexing Framework:

Author: stefan-mysten

crates/sui-indexer-alt-reader/src/consistent_reader.rs

@@ -102,10 +102,7 @@ impl ConsistentReader {
                 endpoint = endpoint.timeout(timeout);
             }
 
-            let channel = endpoint
-                .connect()
-                .await
-                .context("Failed to connect to gRPC endpoint")?;
+            let channel = endpoint.connect_lazy();
 
             Some(ConsistentServiceClient::new(channel))
         } else {

crates/sui-indexer-alt-reader/src/fullnode_client.rs

@@ -61,9 +61,7 @@ impl FullnodeClient {
         let execution_client = if let Some(url) = &args.fullnode_rpc_url {
             let channel = Channel::from_shared(url.clone())
                 .context("Failed to create channel for gRPC endpoint")?
-                .connect()
-                .await
-                .context("Failed to connect to gRPC endpoint")?;
+                .connect_lazy();
 
             Some(TransactionExecutionServiceClient::new(channel))
         } else {

crates/sui-indexer-alt-reader/src/ledger_grpc_reader.rs

@@ -51,11 +51,7 @@ impl LedgerGrpcReader {
         if let Some(timeout) = args.statement_timeout() {
             endpoint = endpoint.timeout(timeout);
         }
-        let channel = endpoint
-            .tls_config(tls_config)?
-            .connect()
-            .await
-            .context("Failed to connect to gRPC endpoint")?;
+        let channel = endpoint.tls_config(tls_config)?.connect_lazy();
 
         let client = LedgerServiceClient::new(channel.clone());
         Ok(Self(client))

crates/sui-keys/src/keystore.rs

@@ -407,7 +407,7 @@ impl FileBasedKeystore {
             });
 
             let reader =
-                BufReader::new(std::fs::File::open(path).with_context(|| {
+                BufReader::new(fs::File::open(path).with_context(|| {
                     format!("Cannot open the keystore file: {}", path.display())
                 })?);
             let kp_strings: Vec<String> = serde_json::from_reader(reader).with_context(|| {
@@ -430,7 +430,7 @@ impl FileBasedKeystore {
         aliases_path.set_extension(ALIASES_FILE_EXTENSION);
 
         let aliases = if aliases_path.exists() {
-            let reader = BufReader::new(std::fs::File::open(&aliases_path).with_context(|| {
+            let reader = BufReader::new(fs::File::open(&aliases_path).with_context(|| {
                 format!(
                     "Cannot open aliases file in keystore: {}",
                     aliases_path.display()
@@ -484,7 +484,7 @@ impl FileBasedKeystore {
                     )
                 })?;
 
-            std::fs::write(aliases_path, aliases_store)?;
+            fs::write(aliases_path, aliases_store)?;
             aliases
         };
 
@@ -513,7 +513,7 @@ impl FileBasedKeystore {
             let mut aliases_path = path.clone();
             aliases_path.set_extension(ALIASES_FILE_EXTENSION);
             // no reactor for tokio::fs::write in simtest, so we use spawn_blocking
-            tokio::task::spawn_blocking(move || std::fs::write(aliases_path, aliases_store))
+            tokio::task::spawn_blocking(move || fs::write(aliases_path, aliases_store))
                 .await?
                 .with_context(|| format!("Cannot write aliases to file: {}", path.display()))?;
         }
@@ -536,7 +536,7 @@ impl FileBasedKeystore {
             let keystore_path = path.clone();
             // no reactor for tokio::fs::write in simtest, so we use spawn_blocking
             tokio::task::spawn_blocking(move || {
-                let ret = std::fs::write(&keystore_path, store);
+                let ret = fs::write(&keystore_path, store);
                 #[cfg(unix)]
                 if ret.is_ok() {
                     let _ = set_reduced_file_permissions(&keystore_path).inspect_err(|error| {

crates/sui/src/sui_commands.rs

@@ -23,7 +23,7 @@ use prometheus::Registry;
 use rand::rngs::OsRng;
 use std::collections::BTreeMap;
 use std::io::{Write, stdout};
-use std::net::{AddrParseError, IpAddr, Ipv4Addr, SocketAddr};
+use std::net::{AddrParseError, IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr};
 use std::num::NonZeroUsize;
 use std::ops::Deref;
 use std::path::{Path, PathBuf};
@@ -1049,7 +1049,7 @@ async fn start(
     tokio::time::sleep(tokio::time::Duration::from_secs(2)).await;
     info!("Cluster started");
 
-    let fullnode_rpc_url = format!("http://{fullnode_rpc_address}");
+    let fullnode_rpc_url = socket_addr_to_url(fullnode_rpc_address)?.to_string();
     info!("Fullnode RPC URL: {fullnode_rpc_url}");
 
     let prometheus_registry = Registry::new();
@@ -1151,7 +1151,7 @@ async fn start(
         rpc_services.push(handle);
 
         info!("Consistent Store started at {address}");
-        Some(format!("http://{address}"))
+        Some(address)
     } else {
         None
     };
@@ -1167,12 +1167,9 @@ async fn start(
             no_ide: false,
         };
 
+        let consistent_store_url = consistent_store_url.map(socket_addr_to_url).transpose()?;
         let consistent_reader_args = ConsistentReaderArgs {
-            consistent_store_url: consistent_store_url
-                .as_ref()
-                .map(|url| Url::parse(url))
-                .transpose()
-                .context("Failed to parse consistent store URL")?,
+            consistent_store_url,
             ..Default::default()
         };
 
@@ -1223,6 +1220,7 @@ async fn start(
     if let Some(input) = with_faucet {
         let faucet_address = parse_host_port(input, DEFAULT_FAUCET_PORT)
             .map_err(|_| anyhow!("Invalid faucet host and port"))?;
+
         info!("Starting the faucet service at {faucet_address}");
 
         let host_ip = match faucet_address {
@@ -1247,12 +1245,13 @@ async fn start(
                 .import(None, SuiKeyPair::Ed25519(kp))
                 .await
                 .unwrap();
+
             SuiClientConfig {
                 keystore,
                 external_keys: None,
                 envs: vec![SuiEnv {
                     alias: "localnet".to_string(),
-                    rpc: fullnode_rpc_url,
+                    rpc: fullnode_rpc_url.clone(),
                     ws: None,
                     basic_auth: None,
                     chain_id: None,
@@ -1542,21 +1541,10 @@ async fn genesis(
         client_config.active_address = active_address;
     }
 
-    // On windows, using 0.0.0.0 will usually yield in an networking error. This localnet ip
-    // address must bind to 127.0.0.1 if the default 0.0.0.0 is used.
-    let localnet_ip =
-        if fullnode_config.json_rpc_address.ip() == IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)) {
-            "127.0.0.1".to_string()
-        } else {
-            fullnode_config.json_rpc_address.ip().to_string()
-        };
+    let rpc = socket_addr_to_url(fullnode_config.json_rpc_address)?.to_string();
     client_config.add_env(SuiEnv {
         alias: "localnet".to_string(),
-        rpc: format!(
-            "http://{}:{}",
-            localnet_ip,
-            fullnode_config.json_rpc_address.port()
-        ),
+        rpc,
         ws: None,
         basic_auth: None,
         chain_id: None,
@@ -1870,3 +1858,20 @@ pub async fn get_replay_node(
         Chain::Unknown => bail!(err_msg),
     })
 }
+
+/// Converts a socket address to a Url by setting the scheme to HTTP.
+fn socket_addr_to_url(addr: SocketAddr) -> Result<Url, anyhow::Error> {
+    let ip = normalize_bind_addr(addr);
+    Url::parse(&format!("http://{ip}:{}", addr.port()))
+        .with_context(|| format!("Failed to parse {addr} into a Url"))
+}
+
+/// Resolves an unspecified ip address to a localhost IP address. Particularly on Windows, clients
+/// cannot connect to 0.0.0.0 addresses.
+fn normalize_bind_addr(addr: SocketAddr) -> IpAddr {
+    match addr.ip() {
+        IpAddr::V4(v4) if v4.is_unspecified() => IpAddr::V4(Ipv4Addr::LOCALHOST),
+        IpAddr::V6(v6) if v6.is_unspecified() => IpAddr::V6(Ipv6Addr::LOCALHOST),
+        ip => ip,
+    }
+}