fix(p2p): Do not fail when an initial peer address cannot be resolved

Don't perform DNS resolution during parsing, instead perform all
name resolutions when building the list, and skip peers for which
the address cannot be resolved.

Author: tizoc

node/native/src/node/builder.rs

@@ -392,12 +392,25 @@ fn peers_from_reader(
     peers: &mut Vec<P2pConnectionOutgoingInitOpts>,
     read: impl Read,
 ) -> anyhow::Result<()> {
-    let read = BufReader::new(read);
-    for line in read.lines() {
+    let reader = BufReader::new(read);
+    for line in reader.lines() {
         let line = line.context("reading line")?;
-        let l = line.trim();
-        if !l.is_empty() {
-            peers.push(l.parse().context(anyhow::anyhow!("parsing entry"))?);
+        let trimmed = line.trim();
+        if trimmed.is_empty() {
+            continue;
+        }
+        match trimmed.parse::<P2pConnectionOutgoingInitOpts>() {
+            Ok(opts) => {
+                if let Some(opts) = opts.with_host_resolved() {
+                    peers.push(opts);
+                } else {
+                    openmina_core::warn!(
+                        "Peer address name resolution failed, skipping: {:?}",
+                        trimmed
+                    );
+                }
+            }
+            Err(e) => openmina_core::warn!("Peer address parse error: {:?}", e),
         }
     }
     Ok(())

node/testing/src/hosts.rs

@@ -23,6 +23,7 @@ pub fn devnet() -> Vec<ListenerNode> {
         .split_whitespace()
         .map(P2pConnectionOutgoingInitOpts::from_str)
         .filter_map(Result::ok)
+        .filter_map(|p| p.with_host_resolved())
         .map(Into::into)
         .collect()
 }

p2p/src/connection/outgoing/mod.rs

@@ -39,6 +39,16 @@ pub enum P2pConnectionOutgoingInitOpts {
     LibP2P(P2pConnectionOutgoingInitLibp2pOpts),
 }
 
+impl P2pConnectionOutgoingInitOpts {
+    pub fn with_host_resolved(self) -> Option<Self> {
+        if let Self::LibP2P(libp2p_opts) = self {
+            Some(Self::LibP2P(libp2p_opts.with_host_resolved()?))
+        } else {
+            Some(self)
+        }
+    }
+}
+
 #[derive(BinProtWrite, BinProtRead, Eq, PartialEq, Ord, PartialOrd, Debug, Clone)]
 pub struct P2pConnectionOutgoingInitLibp2pOpts {
     pub peer_id: PeerId,
@@ -80,6 +90,11 @@ impl P2pConnectionOutgoingInitLibp2pOpts {
             }
         }
     }
+
+    pub fn with_host_resolved(mut self) -> Option<Self> {
+        self.host = self.host.resolve()?;
+        Some(self)
+    }
 }
 
 pub(crate) mod libp2p_opts {
@@ -446,11 +461,7 @@ impl TryFrom<&multiaddr::Multiaddr> for P2pConnectionOutgoingInitLibp2pOpts {
             host: match iter.next() {
                 Some(Protocol::Ip4(v)) => Host::Ipv4(v),
                 Some(Protocol::Dns(v) | Protocol::Dns4(v) | Protocol::Dns6(v)) => {
-                    Host::Domain(v.to_string()).resolve().ok_or(
-                        P2pConnectionOutgoingInitOptsParseError::Other(format!(
-                            "cannot resolve host {v}"
-                        )),
-                    )?
+                    Host::Domain(v.to_string())
                 }
                 Some(_) => {
                     return Err(P2pConnectionOutgoingInitOptsParseError::Other(