refactor: address PR review feedback for proximity cache

Improvements based on review feedback:

1. Use HashSet for O(1) duplicate checking in update.rs
   - Refactored get_broadcast_targets_update to use HashSet internally
   - Changed from O(n*m) to O(n+m) complexity when combining subscribers and proximity neighbors

2. Implement Default trait for ProximityCacheManager
   - Added Default trait implementation following Rust idioms
   - Made new() method call Self::default()

3. Extract magic constant to module-level constant
   - Created BATCH_ANNOUNCEMENT_INTERVAL constant (30 seconds)
   - Replaced hardcoded durations at lines 263 and 365

4. Fix fragile Instant→SystemTime conversion
   - Changed get_introspection_data return type to use Duration instead of SystemTime
   - Now returns time-since-last-update (monotonic, clock-change safe)
   - More useful for debugging purposes

Tests: 215 unit tests passing

[AI-assisted debugging and comment]

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <noreply@anthropic.com>

Author: sanity

crates/core/src/node/proximity_cache.rs

@@ -10,6 +10,9 @@ use tracing::{debug, info, trace};
 
 use super::PeerId;
 
+/// Batch announcement interval - how often to send batched removal announcements
+const BATCH_ANNOUNCEMENT_INTERVAL: Duration = Duration::from_secs(30);
+
 /// Proximity cache manager - tracks what contracts this node and its neighbors are caching
 pub struct ProximityCacheManager {
     /// Contracts we are caching locally
@@ -66,9 +69,8 @@ pub enum ProximityCacheMessage {
     CacheStateResponse { contracts: Vec<ContractInstanceId> },
 }
 
-#[allow(dead_code)] // Some methods reserved for future use (stats, introspection, lifecycle management)
-impl ProximityCacheManager {
-    pub fn new() -> Self {
+impl Default for ProximityCacheManager {
+    fn default() -> Self {
         Self {
             my_cache: Arc::new(RwLock::new(HashSet::new())),
             neighbor_caches: Arc::new(DashMap::new()),
@@ -77,6 +79,13 @@ impl ProximityCacheManager {
             pending_removals: Arc::new(RwLock::new(HashSet::new())),
         }
     }
+}
+
+#[allow(dead_code)] // Some methods reserved for future use (stats, introspection, lifecycle management)
+impl ProximityCacheManager {
+    pub fn new() -> Self {
+        Self::default()
+    }
 
     /// Called when we cache a new contract (PUT or successful GET)
     pub async fn on_contract_cached(
@@ -251,7 +260,7 @@ impl ProximityCacheManager {
         let mut last_announce = self.last_batch_announce.write().await;
 
         // Only send batch announcements every 30 seconds
-        if last_announce.elapsed() < Duration::from_secs(30) {
+        if last_announce.elapsed() < BATCH_ANNOUNCEMENT_INTERVAL {
             return None;
         }
 
@@ -289,24 +298,25 @@ impl ProximityCacheManager {
     }
 
     /// Get introspection data for debugging
+    /// Returns (my_cache, neighbor_data) where neighbor_data maps peer IDs to
+    /// (cached contracts, time since last update)
     pub async fn get_introspection_data(
         &self,
     ) -> (
         Vec<ContractInstanceId>,
-        HashMap<String, (Vec<ContractInstanceId>, std::time::SystemTime)>,
+        HashMap<String, (Vec<ContractInstanceId>, Duration)>,
     ) {
         let my_cache = self.my_cache.read().await.iter().cloned().collect();
-        let now = std::time::SystemTime::now();
 
         let mut neighbor_data = HashMap::new();
         for entry in self.neighbor_caches.iter() {
-            // Calculate SystemTime from Instant by subtracting elapsed time from now
-            let last_update_system_time = now - entry.value().last_update.elapsed();
+            // Use elapsed time since last update (monotonic, not affected by system clock changes)
+            let time_since_update = entry.value().last_update.elapsed();
             neighbor_data.insert(
                 entry.key().to_string(), // Convert PeerId to String for introspection
                 (
                     entry.value().contracts.iter().cloned().collect(),
-                    last_update_system_time,
+                    time_since_update,
                 ),
             );
         }
@@ -353,7 +363,7 @@ impl ProximityCacheManager {
         use crate::config::GlobalExecutor;
 
         GlobalExecutor::spawn(async move {
-            let mut interval = tokio::time::interval(Duration::from_secs(30));
+            let mut interval = tokio::time::interval(BATCH_ANNOUNCEMENT_INTERVAL);
             interval.set_missed_tick_behavior(tokio::time::MissedTickBehavior::Skip);
 
             info!("PROXIMITY_PROPAGATION: Periodic batch announcement task started");

crates/core/src/operations/update.rs

@@ -715,32 +715,41 @@ impl OpManager {
         key: &ContractKey,
         sender: &PeerId,
     ) -> Vec<PeerKeyLocation> {
-        let subscribers = self
+        use std::collections::HashSet;
+
+        // Collect subscribers into HashSet for O(1) duplicate checking
+        let subscriber_peers: HashSet<PeerId> = self
             .ring
             .subscribers_of(key)
             .map(|subs| {
                 subs.value()
                     .iter()
                     .filter(|pk| &pk.peer != sender)
-                    .cloned()
-                    .collect::<Vec<_>>()
+                    .map(|pk| pk.peer.clone())
+                    .collect()
             })
             .unwrap_or_default();
 
         // Get neighbors who have this contract cached (proximity-based targeting)
         let interested_neighbors = self.proximity_cache.neighbors_with_contract(key);
 
-        // Combine subscribers and interested neighbors, removing duplicates and sender
-        let mut targets = subscribers;
+        // Combine subscribers and interested neighbors using HashSet for deduplication
+        let mut all_peers: HashSet<PeerId> = subscriber_peers;
         for neighbor in interested_neighbors {
-            if &neighbor != sender && !targets.iter().any(|t| t.peer == neighbor) {
-                targets.push(PeerKeyLocation {
-                    peer: neighbor,
-                    location: None,
-                });
+            if &neighbor != sender {
+                all_peers.insert(neighbor);
             }
         }
 
+        // Convert to Vec<PeerKeyLocation> for return
+        let targets: Vec<PeerKeyLocation> = all_peers
+            .into_iter()
+            .map(|peer| PeerKeyLocation {
+                peer,
+                location: None,
+            })
+            .collect();
+
         // Trace update propagation for debugging
         if !targets.is_empty() {
             tracing::info!(