fix(network): prevent mDNS from overwriting valid peer addresses (TM-B1)

After network partition recovery, mDNS rediscovery was overwriting
complete peer addresses (e.g., /ip4/x.x.x.x/tcp/10000) with incomplete
ones (e.g., /ip4/x.x.x.x without port), causing "Multiaddr is not
supported" errors during reconnection attempts.

Changes:
- Add `Ignored` variant to AlysNetworkBehaviourEvent for unhandled events
- Filter mDNS addresses to only include dialable ones with transport protocol
- Validate addresses in update_peer_address() before overwriting complete
  addresses with incomplete ones (defense-in-depth)
- Handle Ignored events in network_actor event loop

Author: michaelgpt

app/src/actors_v2/network/behaviour.rs

@@ -70,6 +70,8 @@ pub enum AlysNetworkBehaviourEvent {
     MdnsPeerExpired { peer_id: String },
     /// Remote peer subscribed to a gossipsub topic (used for bidirectional mesh recovery)
     GossipPeerSubscribed { peer_id: String, topic: String },
+    /// Internal event that should be ignored (placeholder for unhandled events)
+    Ignored,
 }
 
 impl AlysNetworkBehaviour {
@@ -199,12 +201,7 @@ impl From<libp2p::gossipsub::Event> for AlysNetworkBehaviourEvent {
             }
             _ => {
                 tracing::trace!("Unhandled gossipsub event: {:?}", event);
-                // For unhandled events, return a dummy event
-                AlysNetworkBehaviourEvent::PeerIdentified {
-                    peer_id: String::new(),
-                    protocols: vec![],
-                    addresses: vec![],
-                }
+                AlysNetworkBehaviourEvent::Ignored
             }
         }
     }
@@ -222,11 +219,7 @@ impl From<libp2p::identify::Event> for AlysNetworkBehaviourEvent {
             }
             _ => {
                 tracing::trace!("Unhandled identify event: {:?}", event);
-                AlysNetworkBehaviourEvent::PeerIdentified {
-                    peer_id: String::new(),
-                    protocols: vec![],
-                    addresses: vec![],
-                }
+                AlysNetworkBehaviourEvent::Ignored
             }
         }
     }
@@ -236,32 +229,43 @@ impl From<libp2p::mdns::Event> for AlysNetworkBehaviourEvent {
     fn from(event: libp2p::mdns::Event) -> Self {
         match event {
             libp2p::mdns::Event::Discovered(peers) => {
-                // Return first discovered peer (simplified)
                 if let Some((peer_id, addresses)) = peers.into_iter().next() {
-                    AlysNetworkBehaviourEvent::MdnsPeerDiscovered {
-                        peer_id: peer_id.to_string(),
-                        addresses: addresses.iter().map(|a| a.to_string()).collect(),
+                    // Filter to only include complete multiaddrs with transport protocol
+                    // This prevents incomplete addresses (e.g., "/ip4/172.22.0.11" without port)
+                    // from being stored and causing reconnection failures
+                    let valid_addresses: Vec<String> = addresses
+                        .iter()
+                        .filter(|addr| {
+                            let addr_str = addr.to_string();
+                            addr_str.contains("/tcp/") || addr_str.contains("/udp/")
+                        })
+                        .map(|a| a.to_string())
+                        .collect();
+
+                    if valid_addresses.is_empty() {
+                        tracing::debug!(
+                            peer_id = %peer_id,
+                            raw_addresses = ?addresses.iter().map(|a| a.to_string()).collect::<Vec<_>>(),
+                            "mDNS discovered peer but no valid transport addresses found"
+                        );
+                        AlysNetworkBehaviourEvent::Ignored
+                    } else {
+                        AlysNetworkBehaviourEvent::MdnsPeerDiscovered {
+                            peer_id: peer_id.to_string(),
+                            addresses: valid_addresses,
+                        }
                     }
                 } else {
-                    AlysNetworkBehaviourEvent::PeerIdentified {
-                        peer_id: String::new(),
-                        protocols: vec![],
-                        addresses: vec![],
-                    }
+                    AlysNetworkBehaviourEvent::Ignored
                 }
             }
             libp2p::mdns::Event::Expired(peers) => {
-                // Return first expired peer (simplified)
                 if let Some((peer_id, _)) = peers.into_iter().next() {
                     AlysNetworkBehaviourEvent::MdnsPeerExpired {
                         peer_id: peer_id.to_string(),
                     }
                 } else {
-                    AlysNetworkBehaviourEvent::PeerIdentified {
-                        peer_id: String::new(),
-                        protocols: vec![],
-                        addresses: vec![],
-                    }
+                    AlysNetworkBehaviourEvent::Ignored
                 }
             }
         }

app/src/actors_v2/network/managers/peer_manager.rs

@@ -253,20 +253,45 @@ impl PeerManager {
     }
 
     /// Update peer's address without resetting other fields
-    /// This is called when PeerIdentified provides a potentially updated address
+    /// This is called when PeerIdentified or mDNS provides a potentially updated address.
+    ///
+    /// IMPORTANT: This method validates that the new address is complete (has transport protocol)
+    /// before overwriting an existing complete address. This prevents mDNS from overwriting
+    /// good addresses with incomplete ones (e.g., "/ip4/172.22.0.11" without port), which
+    /// would cause reconnection failures after network partitions.
     pub fn update_peer_address(&mut self, peer_id: &PeerId, address: String) {
+        // Validate that the new address is dialable (has transport protocol)
+        // This prevents mDNS incomplete addresses from overwriting good addresses
+        let is_new_address_complete = address.contains("/tcp/") || address.contains("/udp/");
+
         // Update in connected_peers
         if let Some(peer_info) = self.connected_peers.get_mut(peer_id) {
-            if peer_info.address != address {
+            let is_existing_address_complete = peer_info.address.contains("/tcp/")
+                || peer_info.address.contains("/udp/");
+
+            // Only overwrite if:
+            // 1. New address is complete, OR
+            // 2. Existing address is also incomplete (nothing to lose)
+            if is_new_address_complete || !is_existing_address_complete {
+                if peer_info.address != address {
+                    tracing::debug!(
+                        peer_id = %peer_id,
+                        old_address = %peer_info.address,
+                        new_address = %address,
+                        "Updated peer address"
+                    );
+                    peer_info.address = address.clone();
+                    peer_info.last_seen = SystemTime::now();
+                    peer_info.last_activity = Instant::now();
+                }
+            } else {
                 tracing::debug!(
                     peer_id = %peer_id,
-                    old_address = %peer_info.address,
-                    new_address = %address,
-                    "Updated peer address"
+                    existing_address = %peer_info.address,
+                    rejected_address = %address,
+                    "Keeping complete address, rejecting incomplete update"
                 );
-                peer_info.address = address.clone();
-                peer_info.last_seen = SystemTime::now();
-                peer_info.last_activity = Instant::now();
+                return; // Don't update known_peers either
             }
         }
 

app/src/actors_v2/network/network_actor.rs

@@ -2034,6 +2034,10 @@ impl NetworkActor {
                     );
                 }
             }
+
+            AlysNetworkBehaviourEvent::Ignored => {
+                // Silently ignore - no action needed for placeholder events
+            }
         }
 
         Ok(())