Make ContextualNetAddress::FromStr resolve hosts if needed

rpc/core/src/api/rpc.rs

@@ -114,7 +114,7 @@ pub trait RpcApi: Sync + Send + AnySync {
     /// Adds a peer to the node's outgoing connection list.
     ///
     /// This will, in most cases, result in the node connecting to said peer.
-    async fn add_peer(&self, peer_address: RpcContextualPeerAddress, is_permanent: bool) -> RpcResult<()> {
+    async fn add_peer(&self, peer_address: String, is_permanent: bool) -> RpcResult<()> {
         self.add_peer_call(AddPeerRequest::new(peer_address, is_permanent)).await?;
         Ok(())
     }

rpc/core/src/error.rs

@@ -1,5 +1,5 @@
 use kaspa_consensus_core::tx::TransactionId;
-use kaspa_utils::networking::IpAddress;
+use kaspa_utils::networking::{IpAddress, ResolveError};
 use std::{net::AddrParseError, num::TryFromIntError};
 use thiserror::Error;
 
@@ -10,6 +10,9 @@ pub enum RpcError {
     #[error("Not implemented")]
     NotImplemented,
 
+    #[error("Couldn't resolve host: {0}")]
+    ResolveHostError(#[from] ResolveError),
+
     #[error("Integer downsize conversion error {0}")]
     IntConversionError(#[from] TryFromIntError),
 

rpc/core/src/model/message.rs

@@ -255,12 +255,12 @@ impl GetConnectedPeerInfoResponse {
 #[derive(Clone, Debug, Serialize, Deserialize, BorshSerialize, BorshDeserialize, BorshSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct AddPeerRequest {
-    pub peer_address: RpcContextualPeerAddress,
+    pub peer_address: String,
     pub is_permanent: bool,
 }
 
 impl AddPeerRequest {
-    pub fn new(peer_address: RpcContextualPeerAddress, is_permanent: bool) -> Self {
+    pub fn new(peer_address: String, is_permanent: bool) -> Self {
         Self { peer_address, is_permanent }
     }
 }

rpc/grpc/core/src/convert/message.rs

@@ -1,7 +1,5 @@
 use crate::protowire::{self, submit_block_response_message::RejectReason};
-use kaspa_rpc_core::{
-    RpcContextualPeerAddress, RpcError, RpcExtraData, RpcHash, RpcIpAddress, RpcNetworkType, RpcPeerAddress, RpcResult,
-};
+use kaspa_rpc_core::{RpcError, RpcExtraData, RpcHash, RpcIpAddress, RpcNetworkType, RpcPeerAddress, RpcResult};
 use std::str::FromStr;
 
 macro_rules! from {
@@ -519,7 +517,7 @@ try_from!(item: &protowire::GetConnectedPeerInfoResponseMessage, RpcResult<kaspa
 });
 
 try_from!(item: &protowire::AddPeerRequestMessage, kaspa_rpc_core::AddPeerRequest, {
-    Self { peer_address: RpcContextualPeerAddress::from_str(&item.address)?, is_permanent: item.is_permanent }
+    Self { peer_address: item.address.clone().to_owned(), is_permanent: item.is_permanent }
 });
 try_from!(&protowire::AddPeerResponseMessage, RpcResult<kaspa_rpc_core::AddPeerResponse>);
 

rpc/service/src/service.rs

@@ -52,7 +52,7 @@ use kaspa_rpc_core::{
     Notification, RpcError, RpcResult,
 };
 use kaspa_txscript::{extract_script_pub_key_address, pay_to_address_script};
-use kaspa_utils::{channel::Channel, triggers::SingleTrigger};
+use kaspa_utils::{channel::Channel, networking::ContextualNetAddress, triggers::SingleTrigger};
 use kaspa_utxoindex::api::UtxoIndexProxy;
 use kaspa_wrpc_core::ServerCounters as WrpcServerCounters;
 use std::{
@@ -560,7 +560,8 @@ impl RpcApi for RpcCoreService {
             warn!("AddPeer RPC command called while node in safe RPC mode -- ignoring.");
             return Err(RpcError::UnavailableInSafeMode);
         }
-        let peer_address = request.peer_address.normalize(self.config.net.default_p2p_port());
+        let peer_address = tokio::task::spawn_blocking(move || ContextualNetAddress::resolve(&request.peer_address)).await.unwrap()?;
+        let peer_address = peer_address.normalize(self.config.net.default_p2p_port());
         if let Some(connection_manager) = self.flow_context.connection_manager() {
             connection_manager.add_connection_request(peer_address.into(), request.is_permanent).await;
         } else {

utils/Cargo.toml

@@ -20,6 +20,7 @@ thiserror.workspace = true
 triggered = "0.1"
 event-listener = "2.5.3"
 ipnet = "2.8.0"
+hostname-validator = "1.1.1"
 
 [dev-dependencies]
 bincode.workspace = true

utils/src/networking.rs

@@ -3,9 +3,11 @@ use ipnet::IpNet;
 use serde::{Deserialize, Serialize};
 use std::{
     fmt::Display,
-    net::{AddrParseError, IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr},
+    net::{AddrParseError, IpAddr, Ipv4Addr, Ipv6Addr, SocketAddr, ToSocketAddrs},
+    num::ParseIntError,
     ops::Deref,
     str::FromStr,
+    sync::Arc,
 };
 use uuid::Uuid;
 
@@ -281,6 +283,37 @@ impl ContextualNetAddress {
     pub fn loopback() -> Self {
         Self { ip: IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)).into(), port: None }
     }
+
+    // resolve uses `to_socket_addrs` which is a blocking io operation, so when used in
+    // a tokio context it's best to be used inside a `tokio::task::spawn_blocking` block.
+    pub fn resolve(s: &str) -> Result<Self, ResolveError> {
+        match s.parse::<ContextualNetAddress>() {
+            Ok(addr) => Ok(addr),
+            Err(e) => {
+                if !hostname_validator::is_valid(s) {
+                    return Err(ResolveError::AddrParseError(e));
+                } else {
+                    let (host, port) = match s.split_once(":") {
+                        Some((host, port_str)) => match port_str.parse::<u16>() {
+                            Ok(port) => (host, Some(port)),
+                            Err(e) => {
+                                return Err(ResolveError::ParseIntError(e));
+                            }
+                        },
+                        None => (s, None),
+                    };
+                    const STUB_PORT: u16 = 80;
+                    match (host, STUB_PORT).to_socket_addrs() {
+                        Ok(mut addrs) => match addrs.next() {
+                            Some(addr) => Ok(Self::new(addr.ip().into(), port)),
+                            None => Err(ResolveError::LookupFoundNoAddresses(s.to_owned())),
+                        },
+                        Err(e) => Err(ResolveError::IoError(Arc::new(e))),
+                    }
+                }
+            }
+        }
+    }
 }
 
 impl From<NetAddress> for ContextualNetAddress {
@@ -289,6 +322,21 @@ impl From<NetAddress> for ContextualNetAddress {
     }
 }
 
+#[derive(Debug, thiserror::Error, Clone)]
+pub enum ResolveError {
+    #[error("Lookup found no addresses associated with: {0}")]
+    LookupFoundNoAddresses(String),
+
+    #[error(transparent)]
+    AddrParseError(#[from] AddrParseError),
+
+    #[error(transparent)]
+    ParseIntError(#[from] ParseIntError),
+
+    #[error(transparent)]
+    IoError(#[from] Arc<std::io::Error>),
+}
+
 impl FromStr for ContextualNetAddress {
     type Err = AddrParseError;