rework public address detection timing

veilid-core/src/network_manager/native/mod.rs

@@ -1017,14 +1017,27 @@ impl Network {
                 let routing_table = self.routing_table();
                 let rth = routing_table.get_routing_table_health();
 
-                // Need at least two entries to do this
+                // We want at least two live entries per crypto kind before we start doing this (bootstrap)
-                if rth.unreliable_entry_count + rth.reliable_entry_count >= 2 {
+                let mut has_at_least_two = true;
+                for ck in VALID_CRYPTO_KINDS {
+                    if rth
+                        .live_entry_counts
+                        .get(&(RoutingDomain::PublicInternet, ck))
+                        .copied()
+                        .unwrap_or_default()
+                        < 2
+                    {
+                        has_at_least_two = false;
+                        break;
+                    }
+                }
+
+                if has_at_least_two {
                     self.unlocked_inner.update_network_class_task.tick().await?;
                 }
             }
 
-            // If we aren't resetting the network already,
+            // Check our network interfaces to see if they have changed
-            // check our network interfaces to see if they have changed
             if !self.needs_restart() {
                 self.unlocked_inner.network_interfaces_task.tick().await?;
             }

veilid-core/src/routing_table/mod.rs

@@ -71,12 +71,14 @@ pub type SerializedBucketMap = BTreeMap<CryptoKind, SerializedBuckets>;
 
 #[derive(Clone, Debug, Default, Eq, PartialEq)]
 pub struct RoutingTableHealth {
-    /// Number of reliable (responsive) entries in the routing table
+    /// Number of reliable (long-term responsive) entries in the routing table
     pub reliable_entry_count: usize,
     /// Number of unreliable (occasionally unresponsive) entries in the routing table
     pub unreliable_entry_count: usize,
     /// Number of dead (always unresponsive) entries in the routing table
     pub dead_entry_count: usize,
+    /// Number of live (responsive) entries in the routing table per RoutingDomain and CryptoKind
+    pub live_entry_counts: BTreeMap<(RoutingDomain, CryptoKind), usize>,
     /// If PublicInternet network class is valid yet
     pub public_internet_ready: bool,
     /// If LocalNetwork network class is valid yet

veilid-core/src/routing_table/routing_table_inner.rs

@@ -925,10 +925,13 @@ impl RoutingTableInner {
             NetworkClass::Invalid
         );
 
+        let live_entry_counts = self.cached_entry_counts();
+
         RoutingTableHealth {
             reliable_entry_count,
             unreliable_entry_count,
             dead_entry_count,
+            live_entry_counts,
             public_internet_ready,
             local_network_ready,
         }