fix: tcp node peers discovery (#7438)

Description
---
Fixes base node connectivity issue with other peers when tor is
disabled.

Filters out peers addresses which are unsupported on host machine - this
includes:
- `onion` addresses if user has run `minotari_node` without tor.
- IPv6 addresses if host machine has no IPv6 address

This reduce amount of failed dial attempts to other peers and improves
connectivity overall.

Motivation and Context
---
Some users might not want to run tor with base node so we must ensure
it's still working without it.

How Has This Been Tested?
---
Run test cases in `peer_manager::storage::database::tests` which
validates peer filtering.
Build `minotari_node` and replaced one in the Tari Universe and I have
removed my node data directories including peer_db. I was able to pass
bootstrap and enter header sync with 6 peers on mainnet.

What process can a PR reviewer use to test or verify this change?
---
Code review, running test and same as above - run node and wait until it
get some connections.

Additional check `network.log` for base node to verify if
`minotari_node` was attempting to peers that had only onion address. It
should dial only if address is reachable.

<!-- Checklist -->
<!-- 1. Is the title of your PR in the form that would make nice release
notes? The title, excluding the conventional commit
tag, will be included exactly as is in the CHANGELOG, so please think
about it carefully. -->


Breaking Changes
---

- [x] None
- [ ] Requires data directory on base node to be deleted
- [ ] Requires hard fork
- [ ] Other - Please specify

<!-- Does this include a breaking change? If so, include this line as a
footer -->
<!-- BREAKING CHANGE: Description what the user should do, e.g. delete a
database, resync the chain -->


<!-- This is an auto-generated comment: release notes by coderabbit.ai
-->
## Summary by CodeRabbit

- New Features
- Introduced TransportProtocol to enumerate network address schemes and
configure supported protocols during startup.
- Builder option to set transport protocols; transports now advertise
supported protocols and auto-detect IPv6.
- Peer selection, discovery and dialing honor protocol reachability for
more reliable connections.
- Documentation
  - Clarified that peer propagation considers address reachability.
- Tests
  - Updated tests to support protocol-aware APIs.
- Chores
  - Added runtime dependency to detect IPv6.
<!-- end of auto-generated comment: release notes by coderabbit.ai -->

---------

Co-authored-by: SW van Heerden <swvheerden@gmail.com>

Author: MCozhusheck

Cargo.lock

@@ -44,7 +44,7 @@ use tari_comms::{
         PeerFeatures,
         PeerFlags,
     },
-    types::CommsPublicKey,
+    types::{CommsPublicKey, TransportProtocol},
     PeerManager,
 };
 use tari_crypto::keys::SecretKey;
@@ -233,7 +233,7 @@ fn create_test_peer() -> Peer {
 pub fn create_peer_manager() -> Arc<PeerManager> {
     let db_connection = DbConnection::connect_temp_file_and_migrate(MIGRATIONS).unwrap();
     let peers_db = PeerDatabaseSql::new(db_connection, &create_test_peer()).unwrap();
-    Arc::new(PeerManager::new(peers_db).unwrap())
+    Arc::new(PeerManager::new(peers_db, TransportProtocol::get_all()).unwrap())
 }
 
 pub fn create_chain_header(header: BlockHeader, prev_accum: &BlockHeaderAccumulatedData) -> ChainHeader {

base_layer/core/src/test_helpers/mod.rs

@@ -57,8 +57,7 @@ use tari_comms::{
         NodeNetworkInfo,
         ProtocolId,
     },
-    tor,
-    tor::{HiddenServiceControllerError, TorIdentity},
+    tor::{self, HiddenServiceControllerError, TorIdentity},
     transports::{
         predicate::FalsePredicate,
         HiddenServiceTransport,
@@ -332,8 +331,9 @@ async fn configure_comms_and_dht(
         .with_listener_liveness_max_sessions(config.listener_liveness_max_sessions)
         .with_listener_liveness_allowlist_cidrs(listener_liveness_allowlist_cidrs)
         .with_dial_backoff(ConstantBackoff::new(Duration::from_millis(500)))
+        .with_transport_protocols(config.transport.transport_type.get_supported_protocols())
         .with_peer_storage(peer_database)
-        .with_excluded_dial_addresses(config.dht.excluded_dial_addresses.clone().into_vec().clone());
+        .with_excluded_dial_addresses(config.dht.excluded_dial_addresses.clone().into_vec());
 
     let mut comms = match config.auxiliary_tcp_listener_address {
         Some(ref addr) => builder.with_auxiliary_tcp_listener_address(addr.clone()).build()?,

base_layer/p2p/src/initialization.rs

@@ -468,6 +468,7 @@ mod test {
             PeerFlags,
         },
         test_utils::mocks::create_connectivity_mock,
+        types::TransportProtocol,
     };
     use tari_comms_dht::{
         envelope::{DhtMessageHeader, DhtMessageType},
@@ -491,7 +492,7 @@ mod test {
     pub fn build_peer_manager() -> Arc<PeerManager> {
         let db_connection = DbConnection::connect_temp_file_and_migrate(MIGRATIONS).unwrap();
         let peers_db = PeerDatabaseSql::new(db_connection, &create_test_peer()).unwrap();
-        Arc::new(PeerManager::new(peers_db).unwrap())
+        Arc::new(PeerManager::new(peers_db, TransportProtocol::get_all()).unwrap())
     }
 
     #[tokio::test]

base_layer/p2p/src/services/liveness/service.rs

@@ -25,9 +25,9 @@ use serde::{Deserialize, Serialize};
 use tari_comms::{
     multiaddr::Multiaddr,
     socks,
-    tor,
-    tor::TorIdentity,
+    tor::{self, TorIdentity},
     transports::{predicate::FalsePredicate, SocksConfig},
+    types::TransportProtocol,
     utils::multiaddr::multiaddr_to_socketaddr,
 };
 
@@ -101,6 +101,25 @@ pub enum TransportType {
     Socks5,
 }
 
+impl TransportType {
+    pub fn get_supported_protocols(&self) -> Vec<TransportProtocol> {
+        match self {
+            TransportType::Memory => vec![TransportProtocol::Memory],
+            TransportType::Tcp => vec![TransportProtocol::Ipv4, TransportProtocol::Ipv6],
+            TransportType::Tor => vec![
+                TransportProtocol::Onion,
+                TransportProtocol::Ipv4,
+                TransportProtocol::Ipv6,
+            ],
+            TransportType::Socks5 => vec![
+                TransportProtocol::Onion,
+                TransportProtocol::Ipv4,
+                TransportProtocol::Ipv6,
+            ],
+        }
+    }
+}
+
 impl Default for TransportType {
     fn default() -> Self {
         // The tor transport configures itself as long as it has access to the control port at

base_layer/p2p/src/transport.rs

@@ -65,6 +65,7 @@ tower = { version = "0.4", features = ["util"] }
 tracing = "0.1.26"
 yamux = "0.13.2"
 zeroize = "1"
+local-ip-address = "0.6.5"
 
 [dev-dependencies]
 tari_test_utils = { workspace = true }

comms/core/Cargo.toml

@@ -50,7 +50,7 @@ use crate::{
     peer_validator::PeerValidatorConfig,
     protocol::{NodeNetworkInfo, ProtocolExtensions},
     tor,
-    types::CommsDatabase,
+    types::{CommsDatabase, TransportProtocol},
 };
 
 /// # CommsBuilder
@@ -124,6 +124,7 @@ pub struct CommsBuilder {
     connectivity_config: ConnectivityConfig,
     shutdown_signal: Option<ShutdownSignal>,
     maintain_n_closest_connections_only: Option<usize>,
+    transport_protocols: Vec<TransportProtocol>,
 }
 
 impl Default for CommsBuilder {
@@ -137,6 +138,7 @@ impl Default for CommsBuilder {
             connectivity_config: ConnectivityConfig::default(),
             shutdown_signal: None,
             maintain_n_closest_connections_only: None,
+            transport_protocols: TransportProtocol::get_all(),
         }
     }
 }
@@ -310,10 +312,18 @@ impl CommsBuilder {
         self
     }
 
+    /// Set the transport protocols to use for communication
+    /// if not provided defaults to IP4, IP6, TOR and memory address
+    pub fn with_transport_protocols(mut self, protocols: Vec<TransportProtocol>) -> Self {
+        self.transport_protocols = protocols;
+        self
+    }
+
     fn make_peer_manager(&mut self) -> Result<Arc<PeerManager>, CommsBuilderError> {
         match self.peer_storage.take() {
             Some(storage) => {
-                let peer_manager = PeerManager::new(storage).map_err(CommsBuilderError::PeerManagerError)?;
+                let peer_manager = PeerManager::new(storage, self.transport_protocols.clone())
+                    .map_err(CommsBuilderError::PeerManagerError)?;
                 Ok(Arc::new(peer_manager))
             },
             None => Err(CommsBuilderError::PeerStorageNotProvided),

comms/core/src/builder/mod.rs

@@ -52,8 +52,7 @@ use crate::connection_manager::metrics;
 use crate::{
     backoff::Backoff,
     connection_manager::{
-        common,
-        common::ValidatedPeerIdentityExchange,
+        common::{self, ValidatedPeerIdentityExchange},
         dial_state::DialState,
         manager::{ConnectionManagerConfig, ConnectionManagerEvent},
         peer_connection,
@@ -589,7 +588,7 @@ where
         }
     }
 
-    /// Attempts to dial a peer sequentially on all addresses; if connections are to be minimized only.
+    /// Attempts to dial a peer sequentially on supported addresses; if connections are to be minimized only.
     /// Returns ownership of the given `DialState` and a success or failure result for the dial,
     /// or None if the dial was cancelled inflight
     #[allow(clippy::too_many_lines)]
@@ -603,15 +602,22 @@ where
         DialState,
         Result<(NoiseSocket<TTransport::Output>, Multiaddr), ConnectionManagerError>,
     ) {
+        let supported_transport_protocols = transport.supported_protocols();
+        trace!(target: LOG_TARGET, "Supported transport protocols: {:?}", supported_transport_protocols);
+
         let addresses = dial_state
             .peer()
             .addresses
             .clone()
             .into_vec()
             .iter()
-            .filter(|&a| !excluded_dial_addresses.iter().any(|excluded| excluded.contains(a)))
+            .filter(|&a| {
+                !excluded_dial_addresses.iter().any(|excluded| excluded.contains(a)) &&
+                    supported_transport_protocols.contains(a.into())
+            })
             .cloned()
             .collect::<Vec<_>>();
+
         if addresses.is_empty() {
             let node_id_hex = dial_state.peer().node_id.clone().to_hex();
             trace!(