feat: add relay management methods and update NostrClient creation

Author: tompro

crates/bcr-ebill-transport/src/lib.rs

@@ -21,7 +21,7 @@ use handler::{
     IdentityChainEventHandler, IdentityChainEventProcessor, LoggingEventHandler,
     NostrContactProcessor, NotificationHandlerApi,
 };
-use log::{debug, error};
+use log::{debug, error, warn};
 pub use nostr_transport::NostrTransportService;
 
 mod block_transport;
@@ -54,6 +54,7 @@ pub async fn create_nostr_clients(
     config: &Config,
     identity_store: Arc<dyn IdentityStoreApi>,
     company_store: Arc<dyn CompanyStoreApi>,
+    nostr_contact_store: Arc<dyn bcr_ebill_persistence::nostr::NostrContactStoreApi>,
 ) -> Result<Arc<NostrClient>> {
     // primary identity is required to launch
     let keys = identity_store.get_or_create_key_pair().await.map_err(|e| {
@@ -101,9 +102,17 @@ pub async fn create_nostr_clients(
         identities,
         config.nostr_config.relays.clone(),
         std::time::Duration::from_secs(20),
+        config.nostr_config.max_relays,
+        Some(nostr_contact_store),
     )
     .await?;
 
+    // Initial relay refresh to include contact relays
+    if let Err(e) = client.refresh_relays().await {
+        warn!("Failed initial relay refresh: {}", e);
+        // Continue anyway - we have user relays at minimum
+    }
+
     Ok(Arc::new(client))
 }
 

crates/bcr-ebill-transport/src/nostr.rs

@@ -20,7 +20,11 @@ use nostr_sdk::{
     PublicKey, RelayPoolNotification, RelayUrl, SingleLetterTag, TagKind, TagStandard, ToBech32,
 };
 use std::sync::{Arc, Mutex, atomic::Ordering};
-use std::{collections::{HashMap, HashSet}, sync::atomic::AtomicBool, time::Duration};
+use std::{
+    collections::{HashMap, HashSet},
+    sync::atomic::AtomicBool,
+    time::Duration,
+};
 
 use bcr_ebill_api::{
     constants::NOSTR_EVENT_TIME_SLACK,
@@ -64,6 +68,8 @@ pub struct NostrClient {
     relays: Vec<url::Url>,
     default_timeout: Duration,
     connected: Arc<AtomicBool>,
+    max_relays: Option<usize>,
+    nostr_contact_store: Option<Arc<dyn bcr_ebill_persistence::nostr::NostrContactStoreApi>>,
 }
 
 impl NostrClient {
@@ -72,6 +78,8 @@ impl NostrClient {
         identities: Vec<(NodeId, BcrKeys)>,
         relays: Vec<url::Url>,
         default_timeout: Duration,
+        max_relays: Option<usize>,
+        nostr_contact_store: Option<Arc<dyn bcr_ebill_persistence::nostr::NostrContactStoreApi>>,
     ) -> Result<Self> {
         if identities.is_empty() {
             return Err(Error::Message("At least one identity required".to_string()));
@@ -105,13 +113,22 @@ impl NostrClient {
             relays,
             default_timeout,
             connected: Arc::new(AtomicBool::new(false)),
+            max_relays,
+            nostr_contact_store,
         })
     }
 
     /// Creates a new nostr client with the given config.
     pub async fn default(config: &NostrConfig) -> Result<Self> {
         let identities = vec![(config.node_id.clone(), config.keys.clone())];
-        Self::new(identities, config.relays.clone(), config.default_timeout).await
+        Self::new(
+            identities,
+            config.relays.clone(),
+            config.default_timeout,
+            None, // max_relays not available in old config
+            None, // contact_store not available
+        )
+        .await
     }
 
     /// Get the signer for a specific identity
@@ -313,6 +330,69 @@ impl NostrClient {
         }
         Ok(&self.client)
     }
+
+    /// Calculate the complete relay set from user relays + contact relays
+    async fn calculate_relay_set(&self) -> Result<HashSet<url::Url>> {
+        // Get contacts from store if available
+        let contacts = if let Some(store) = &self.nostr_contact_store {
+            store.get_all().await.map_err(|e| {
+                error!("Failed to fetch contacts for relay calculation: {e}");
+                Error::Message("Failed to fetch contacts".to_string())
+            })?
+        } else {
+            vec![]
+        };
+
+        Ok(calculate_relay_set_internal(&self.relays, &contacts, self.max_relays))
+    }
+
+    /// Update the client's relay connections to match the target set
+    async fn update_relays(&self, target_relays: HashSet<url::Url>) -> Result<()> {
+        let client = &self.client;
+        
+        // Get current relays
+        let current_relays: HashSet<url::Url> = client
+            .relays()
+            .await
+            .into_iter()
+            .filter_map(|(_, relay)| relay.url().as_str().parse::<url::Url>().ok())
+            .collect();
+
+        // Add new relays
+        for relay in target_relays.iter() {
+            if !current_relays.contains(relay) {
+                match client.add_relay(relay).await {
+                    Ok(_) => debug!("Added relay: {}", relay),
+                    Err(e) => warn!("Failed to add relay {}: {}", relay, e),
+                }
+            }
+        }
+
+        // Remove old relays (relays not in target set)
+        for relay in current_relays.iter() {
+            if !target_relays.contains(relay) {
+                // Convert url::Url to RelayUrl
+                if let Ok(relay_url) = relay.as_str().parse::<RelayUrl>() {
+                    match client.remove_relay(relay_url).await {
+                        Ok(_) => debug!("Removed relay: {}", relay),
+                        Err(e) => warn!("Failed to remove relay {}: {}", relay, e),
+                    }
+                }
+            }
+        }
+
+        Ok(())
+    }
+
+    /// Public method to refresh relay connections based on current contacts
+    pub async fn refresh_relays(&self) -> Result<()> {
+        info!("Refreshing relay connections based on contacts");
+        let relay_set = self.calculate_relay_set().await?;
+        self.update_relays(relay_set).await?;
+        info!("Relay refresh complete, connected to {} relays", 
+              self.client.relays().await.len());
+        Ok(())
+    }
 }
 
 impl ServiceTraitBounds for NostrClient {}
@@ -1140,7 +1220,7 @@ mod tests {
             (node_id2.clone(), keys2.clone()),
         ];
 
-        let client = NostrClient::new(identities, vec![url], Duration::from_secs(20))
+        let client = NostrClient::new(identities, vec![url], Duration::from_secs(20), None, None)
             .await
             .expect("failed to create multi-identity client");
 
@@ -1168,7 +1248,7 @@ mod tests {
             (node_id2.clone(), keys2.clone()),
         ];
 
-        let client = NostrClient::new(identities, vec![url.clone()], Duration::from_secs(20))
+        let client = NostrClient::new(identities, vec![url.clone()], Duration::from_secs(20), None, None)
             .await
             .expect("failed to create client");
 
@@ -1215,7 +1295,7 @@ mod tests {
         ];
 
         let client = Arc::new(
-            NostrClient::new(identities, vec![url.clone()], Duration::from_secs(20))
+            NostrClient::new(identities, vec![url.clone()], Duration::from_secs(20), None, None)
                 .await
                 .expect("failed to create multi-identity client"),
         );
@@ -1261,29 +1341,30 @@ fn calculate_relay_set_internal(
 ) -> HashSet<url::Url> {
     use bcr_ebill_core::application::nostr_contact::TrustLevel;
     use std::collections::HashSet;
-    
+
     let mut relay_set = HashSet::new();
-    
+
     // Pass 1: Add all user relays (exempt from limit)
     for relay in user_relays {
         relay_set.insert(relay.clone());
     }
-    
+
     // Filter and sort contacts by trust level
-    let mut eligible_contacts: Vec<&bcr_ebill_core::application::nostr_contact::NostrContact> = contacts
-        .iter()
-        .filter(|c| matches!(c.trust_level, TrustLevel::Trusted | TrustLevel::Participant))
-        .collect();
-    
+    let mut eligible_contacts: Vec<&bcr_ebill_core::application::nostr_contact::NostrContact> =
+        contacts
+            .iter()
+            .filter(|c| matches!(c.trust_level, TrustLevel::Trusted | TrustLevel::Participant))
+            .collect();
+
     // Sort: Trusted (0) before Participant (1)
     eligible_contacts.sort_by_key(|c| match c.trust_level {
         TrustLevel::Trusted => 0,
         TrustLevel::Participant => 1,
         _ => 2, // unreachable due to filter
     });
-    
+
     let limit = max_relays.unwrap_or(usize::MAX);
-    
+
     // Pass 2: Add first relay from each contact (priority order)
     for contact in &eligible_contacts {
         if relay_set.len() >= limit {
@@ -1293,7 +1374,7 @@ fn calculate_relay_set_internal(
             relay_set.insert(first_relay.clone());
         }
     }
-    
+
     // Pass 3: Fill remaining slots with additional contact relays
     for contact in &eligible_contacts {
         for relay in contact.relays.iter().skip(1) {
@@ -1303,14 +1384,14 @@ fn calculate_relay_set_internal(
             relay_set.insert(relay.clone());
         }
     }
-    
+
     relay_set
 }
 
 #[cfg(test)]
 mod relay_calculation_tests {
     use super::*;
-    use bcr_ebill_core::application::nostr_contact::{NostrContact, TrustLevel, HandshakeStatus};
+    use bcr_ebill_core::application::nostr_contact::{HandshakeStatus, NostrContact, TrustLevel};
 
     fn create_test_contact(trust_level: TrustLevel, relays: Vec<&str>) -> NostrContact {
         use bcr_ebill_core::protocol::crypto::BcrKeys;
@@ -1335,9 +1416,9 @@ mod relay_calculation_tests {
         ];
         let contacts = vec![];
         let max_relays = Some(1); // Very low limit
-        
+
         let result = calculate_relay_set_internal(&user_relays, &contacts, max_relays);
-        
+
         // User relays should all be present despite low limit
         assert_eq!(result.len(), 2);
         assert!(result.contains(&url::Url::parse("wss://relay1.com").unwrap()));
@@ -1352,9 +1433,9 @@ mod relay_calculation_tests {
             create_test_contact(TrustLevel::Trusted, vec!["wss://trusted.com"]),
         ];
         let max_relays = Some(1);
-        
+
         let result = calculate_relay_set_internal(&user_relays, &contacts, max_relays);
-        
+
         // Should only include trusted contact's relay (higher priority)
         assert_eq!(result.len(), 1);
         assert!(result.contains(&url::Url::parse("wss://trusted.com").unwrap()));
@@ -1364,14 +1445,20 @@ mod relay_calculation_tests {
     fn test_one_relay_per_contact_guaranteed() {
         let user_relays = vec![];
         let contacts = vec![
-            create_test_contact(TrustLevel::Trusted, vec!["wss://contact1-relay1.com", "wss://contact1-relay2.com"]),
-            create_test_contact(TrustLevel::Trusted, vec!["wss://contact2-relay1.com", "wss://contact2-relay2.com"]),
+            create_test_contact(
+                TrustLevel::Trusted,
+                vec!["wss://contact1-relay1.com", "wss://contact1-relay2.com"],
+            ),
+            create_test_contact(
+                TrustLevel::Trusted,
+                vec!["wss://contact2-relay1.com", "wss://contact2-relay2.com"],
+            ),
             create_test_contact(TrustLevel::Trusted, vec!["wss://contact3-relay1.com"]),
         ];
         let max_relays = Some(3);
-        
+
         let result = calculate_relay_set_internal(&user_relays, &contacts, max_relays);
-        
+
         // Should have exactly 3 relays (first relay from each contact)
         assert_eq!(result.len(), 3);
         assert!(result.contains(&url::Url::parse("wss://contact1-relay1.com").unwrap()));
@@ -1383,13 +1470,19 @@ mod relay_calculation_tests {
     fn test_deduplication_across_contacts() {
         let user_relays = vec![];
         let contacts = vec![
-            create_test_contact(TrustLevel::Trusted, vec!["wss://shared.com", "wss://unique1.com"]),
-            create_test_contact(TrustLevel::Trusted, vec!["wss://shared.com", "wss://unique2.com"]),
+            create_test_contact(
+                TrustLevel::Trusted,
+                vec!["wss://shared.com", "wss://unique1.com"],
+            ),
+            create_test_contact(
+                TrustLevel::Trusted,
+                vec!["wss://shared.com", "wss://unique2.com"],
+            ),
         ];
         let max_relays = Some(10);
-        
+
         let result = calculate_relay_set_internal(&user_relays, &contacts, max_relays);
-        
+
         // Should only include shared.com once
         assert_eq!(result.len(), 3);
         assert!(result.contains(&url::Url::parse("wss://shared.com").unwrap()));
@@ -1405,9 +1498,9 @@ mod relay_calculation_tests {
             create_test_contact(TrustLevel::Trusted, vec!["wss://trusted.com"]),
         ];
         let max_relays = Some(10);
-        
+
         let result = calculate_relay_set_internal(&user_relays, &contacts, max_relays);
-        
+
         assert_eq!(result.len(), 1);
         assert!(result.contains(&url::Url::parse("wss://trusted.com").unwrap()));
         assert!(!result.contains(&url::Url::parse("wss://banned.com").unwrap()));
@@ -1421,9 +1514,9 @@ mod relay_calculation_tests {
             create_test_contact(TrustLevel::Participant, vec!["wss://participant.com"]),
         ];
         let max_relays = Some(10);
-        
+
         let result = calculate_relay_set_internal(&user_relays, &contacts, max_relays);
-        
+
         assert_eq!(result.len(), 1);
         assert!(result.contains(&url::Url::parse("wss://participant.com").unwrap()));
         assert!(!result.contains(&url::Url::parse("wss://unknown.com").unwrap()));
@@ -1433,13 +1526,19 @@ mod relay_calculation_tests {
     fn test_no_limit_when_max_relays_none() {
         let user_relays = vec![url::Url::parse("wss://user.com").unwrap()];
         let contacts = vec![
-            create_test_contact(TrustLevel::Trusted, vec!["wss://relay1.com", "wss://relay2.com"]),
-            create_test_contact(TrustLevel::Trusted, vec!["wss://relay3.com", "wss://relay4.com"]),
+            create_test_contact(
+                TrustLevel::Trusted,
+                vec!["wss://relay1.com", "wss://relay2.com"],
+            ),
+            create_test_contact(
+                TrustLevel::Trusted,
+                vec!["wss://relay3.com", "wss://relay4.com"],
+            ),
         ];
         let max_relays = None;
-        
+
         let result = calculate_relay_set_internal(&user_relays, &contacts, max_relays);
-        
+
         // All relays should be included
         assert_eq!(result.len(), 5);
     }
@@ -1449,9 +1548,9 @@ mod relay_calculation_tests {
         let user_relays = vec![url::Url::parse("wss://user.com").unwrap()];
         let contacts = vec![];
         let max_relays = Some(50);
-        
+
         let result = calculate_relay_set_internal(&user_relays, &contacts, max_relays);
-        
+
         assert_eq!(result.len(), 1);
         assert!(result.contains(&url::Url::parse("wss://user.com").unwrap()));
     }
@@ -1463,9 +1562,9 @@ mod relay_calculation_tests {
         contact.relays = vec![]; // Explicitly no relays
         let contacts = vec![contact];
         let max_relays = Some(10);
-        
+
         let result = calculate_relay_set_internal(&user_relays, &contacts, max_relays);
-        
+
         // Should handle gracefully
         assert_eq!(result.len(), 0);
     }