sdk: fetch gossip NIP-17 list only if really needed

yukibtc · yukibtc · commit f2bf31e8d15e · 2025-10-10T12:07:06.000-03:00
Closes https://gitworkshop.dev/yukikishimoto.com/nostr/issues/note15mhvsqdntu8w3njkh7urf92jlvak5rxdq7z9snfjtf2678kd9qvsgut0hz Signed-off-by: Yuki Kishimoto <yukikishimoto@protonmail.com>
diff --git a/crates/nostr-sdk/CHANGELOG.md b/crates/nostr-sdk/CHANGELOG.md
@@ -30,6 +30,10 @@
 - Remove `lmdb`, `ndb` and `indexeddb` features (https://github.com/rust-nostr/nostr/pull/1083)
 - Replace `ReceiverStream` with `BoxStream` (https://github.com/rust-nostr/nostr/pull/1087)
 
+### Changed
+
+- Fetch gossip NIP-17 list only if really needed (https://github.com/rust-nostr/nostr/pull/1090)
+
 ### Added
 
 - `Client::public_key` function to retrieve the public key (https://github.com/rust-nostr/nostr/pull/1028)
diff --git a/crates/nostr-sdk/src/client/mod.rs b/crates/nostr-sdk/src/client/mod.rs
@@ -25,7 +25,7 @@ pub use self::error::Error;
 pub use self::options::{ClientOptions, SleepWhenIdle};
 #[cfg(not(target_arch = "wasm32"))]
 pub use self::options::{Connection, ConnectionTarget};
-use crate::gossip::{BrokenDownFilters, Gossip};
+use crate::gossip::{self, BrokenDownFilters, Gossip, GossipFilterPattern, GossipKind};
 
 /// Nostr client
 #[derive(Debug, Clone)]
@@ -1323,22 +1323,29 @@ impl Client {
 // Gossip
 impl Client {
     /// Check if there are outdated public keys and update them
-    async fn check_and_update_gossip<I>(&self, public_keys: I) -> Result<(), Error>
+    async fn check_and_update_gossip<I>(
+        &self,
+        public_keys: I,
+        kind: GossipKind,
+    ) -> Result<(), Error>
     where
         I: IntoIterator<Item = PublicKey>,
     {
         let outdated_public_keys: HashSet<PublicKey> =
-            self.gossip.check_outdated(public_keys).await;
+            self.gossip.check_outdated(public_keys, &kind).await;
 
         // No outdated public keys, immediately return.
         if outdated_public_keys.is_empty() {
             return Ok(());
         }
 
+        // Get kind
+        let kind: Kind = kind.to_event_kind();
+
         // Compose filters
         let filter: Filter = Filter::default()
             .authors(outdated_public_keys.clone())
-            .kinds([Kind::RelayList, Kind::InboxRelays]);
+            .kind(kind);
 
         // Query from database
         let stored_events: Events = self.database().query(filter.clone()).await?;
@@ -1374,23 +1381,38 @@ impl Client {
         // Extract all public keys from filters
         let public_keys = filter.extract_public_keys();
 
-        // Check and update outdated public keys
-        self.check_and_update_gossip(public_keys).await?;
+        // Find pattern to decide what list to update
+        let pattern: GossipFilterPattern = gossip::find_filter_pattern(&filter);
+
+        // Update outdated public keys
+        match &pattern {
+            GossipFilterPattern::Nip65 => {
+                self.check_and_update_gossip(public_keys, GossipKind::Nip65)
+                    .await?;
+            }
+            GossipFilterPattern::Nip65AndNip17 => {
+                self.check_and_update_gossip(public_keys.iter().copied(), GossipKind::Nip65)
+                    .await?;
+                self.check_and_update_gossip(public_keys, GossipKind::Nip17)
+                    .await?;
+            }
+        }
 
         // Broken-down filters
-        let filters: HashMap<RelayUrl, Filter> = match self.gossip.break_down_filter(filter).await {
-            BrokenDownFilters::Filters(filters) => filters,
-            BrokenDownFilters::Orphan(filter) | BrokenDownFilters::Other(filter) => {
-                // Get read relays
-                let read_relays: Vec<RelayUrl> = self.pool.__read_relay_urls().await;
-
-                let mut map = HashMap::with_capacity(read_relays.len());
-                for url in read_relays.into_iter() {
-                    map.insert(url, filter.clone());
+        let filters: HashMap<RelayUrl, Filter> =
+            match self.gossip.break_down_filter(filter, pattern).await {
+                BrokenDownFilters::Filters(filters) => filters,
+                BrokenDownFilters::Orphan(filter) | BrokenDownFilters::Other(filter) => {
+                    // Get read relays
+                    let read_relays: Vec<RelayUrl> = self.pool.__read_relay_urls().await;
+
+                    let mut map = HashMap::with_capacity(read_relays.len());
+                    for url in read_relays.into_iter() {
+                        map.insert(url, filter.clone());
+                    }
+                    map
                 }
-                map
-            }
-        };
+            };
 
         // Add gossip (outbox and inbox) relays
         for url in filters.keys() {
@@ -1417,17 +1439,24 @@ impl Client {
 
         // Get involved public keys and check what are up to date in the gossip graph and which ones require an update.
         if is_gift_wrap {
+            let kind: GossipKind = if is_nip17 {
+                GossipKind::Nip17
+            } else {
+                GossipKind::Nip65
+            };
+
             // Get only p tags since the author of a gift wrap is randomized
             let public_keys = event.tags.public_keys().copied();
-            self.check_and_update_gossip(public_keys).await?;
+            self.check_and_update_gossip(public_keys, kind).await?;
         } else {
             // Get all public keys involved in the event: author + p tags
             let public_keys = event
                 .tags
                 .public_keys()
                 .copied()
                 .chain(iter::once(event.pubkey));
-            self.check_and_update_gossip(public_keys).await?;
+            self.check_and_update_gossip(public_keys, GossipKind::Nip65)
+                .await?;
         };
 
         // Check if NIP17 or NIP65
diff --git a/crates/nostr-sdk/src/gossip/mod.rs b/crates/nostr-sdk/src/gossip/mod.rs
@@ -18,6 +18,21 @@ use self::constant::{
 
 const P_TAG: SingleLetterTag = SingleLetterTag::lowercase(Alphabet::P);
 
+pub(crate) enum GossipKind {
+    Nip17,
+    Nip65,
+}
+
+impl GossipKind {
+    #[allow(clippy::wrong_self_convention)]
+    pub(crate) fn to_event_kind(self) -> Kind {
+        match self {
+            Self::Nip17 => Kind::InboxRelays,
+            Self::Nip65 => Kind::RelayList,
+        }
+    }
+}
+
 #[derive(Debug)]
 pub enum BrokenDownFilters {
     /// Filters by url
@@ -145,7 +160,7 @@ impl Gossip {
     }
 
     /// Check for what public keys the metadata are outdated or not existent (both for NIP17 and NIP65)
-    pub async fn check_outdated<I>(&self, public_keys: I) -> HashSet<PublicKey>
+    pub async fn check_outdated<I>(&self, public_keys: I, kind: &GossipKind) -> HashSet<PublicKey>
     where
         I: IntoIterator<Item = PublicKey>,
     {
@@ -161,14 +176,28 @@ impl Gossip {
                         continue;
                     }
 
-                    // Check if collections are empty
-                    let empty: bool =
-                        lists.nip17.collection.is_empty() || lists.nip65.collection.is_empty();
+                    let (empty, expired) = match kind {
+                        GossipKind::Nip17 => {
+                            // Check if the collection is empty
+                            let empty: bool = lists.nip17.collection.is_empty();
 
-                    // Check if expired
-                    let expired: bool = lists.nip17.last_update + PUBKEY_METADATA_OUTDATED_AFTER
-                        < now
-                        || lists.nip65.last_update + PUBKEY_METADATA_OUTDATED_AFTER < now;
+                            // Check if expired
+                            let expired: bool =
+                                lists.nip17.last_update + PUBKEY_METADATA_OUTDATED_AFTER < now;
+
+                            (empty, expired)
+                        }
+                        GossipKind::Nip65 => {
+                            // Check if the collection is empty
+                            let empty: bool = lists.nip65.collection.is_empty();
+
+                            // Check if expired
+                            let expired: bool =
+                                lists.nip65.last_update + PUBKEY_METADATA_OUTDATED_AFTER < now;
+
+                            (empty, expired)
+                        }
+                    };
 
                     if empty || expired {
                         outdated.insert(public_key);
@@ -372,7 +401,11 @@ impl Gossip {
         self.map_nip65_relays(txn, public_keys, RelayMetadata::Read)
     }
 
-    pub async fn break_down_filter(&self, filter: Filter) -> BrokenDownFilters {
+    pub async fn break_down_filter(
+        &self,
+        filter: Filter,
+        pattern: GossipFilterPattern,
+    ) -> BrokenDownFilters {
         let txn = self.public_keys.read().await;
 
         // Extract `p` tag from generic tags and parse public key hex
@@ -390,7 +423,9 @@ impl Gossip {
                     self.map_nip65_outbox_relays(&txn, authors);
 
                 // Extend with NIP17 relays
-                outbox.extend(self.map_nip17_relays(&txn, authors));
+                if pattern.has_nip17() {
+                    outbox.extend(self.map_nip17_relays(&txn, authors));
+                }
 
                 // No relay available for the authors
                 if outbox.is_empty() {
@@ -417,7 +452,9 @@ impl Gossip {
                     self.map_nip65_inbox_relays(&txn, p_public_keys);
 
                 // Extend with NIP17 relays
-                inbox.extend(self.map_nip17_relays(&txn, p_public_keys));
+                if pattern.has_nip17() {
+                    inbox.extend(self.map_nip17_relays(&txn, p_public_keys));
+                }
 
                 // No relay available for the p tags
                 if inbox.is_empty() {
@@ -446,7 +483,9 @@ impl Gossip {
                     self.get_nip65_relays(&txn, authors.union(p_public_keys), None);
 
                 // Extend with NIP17 relays
-                relays.extend(self.get_nip17_relays(&txn, authors.union(p_public_keys)));
+                if pattern.has_nip17() {
+                    relays.extend(self.get_nip17_relays(&txn, authors.union(p_public_keys)));
+                }
 
                 // No relay available for the authors and p tags
                 if relays.is_empty() {
@@ -561,6 +600,38 @@ fn extract_nip65_relay_list(
     map
 }
 
+pub(crate) enum GossipFilterPattern {
+    Nip65,
+    Nip65AndNip17,
+}
+
+impl GossipFilterPattern {
+    #[inline]
+    fn has_nip17(&self) -> bool {
+        matches!(self, Self::Nip65AndNip17)
+    }
+}
+
+/// Use both NIP-65 and NIP-17 if:
+/// - the `kinds` field contains the [`Kind::GiftWrap`];
+/// - if it's set a `#p` tag and no kind is specified
+pub(crate) fn find_filter_pattern(filter: &Filter) -> GossipFilterPattern {
+    let (are_kinds_empty, has_gift_wrap_kind): (bool, bool) = match &filter.kinds {
+        Some(kinds) if kinds.is_empty() => (true, false),
+        Some(kinds) => (false, kinds.contains(&Kind::GiftWrap)),
+        None => (true, false),
+    };
+    let has_p_tags: bool = filter.generic_tags.contains_key(&P_TAG);
+
+    // TODO: use both also if there are only IDs?
+
+    if has_gift_wrap_kind || (has_p_tags && are_kinds_empty) {
+        return GossipFilterPattern::Nip65AndNip17;
+    }
+
+    GossipFilterPattern::Nip65
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -736,7 +807,10 @@ mod tests {
 
         // Single author
         let filter = Filter::new().author(keys_a.public_key);
-        match graph.break_down_filter(filter.clone()).await {
+        match graph
+            .break_down_filter(filter.clone(), GossipFilterPattern::Nip65)
+            .await
+        {
             BrokenDownFilters::Filters(map) => {
                 assert_eq!(map.get(&damus_url).unwrap(), &filter);
                 assert_eq!(map.get(&nostr_bg_url).unwrap(), &filter);
@@ -748,7 +822,10 @@ mod tests {
 
         // Multiple authors
         let authors_filter = Filter::new().authors([keys_a.public_key, keys_b.public_key]);
-        match graph.break_down_filter(authors_filter.clone()).await {
+        match graph
+            .break_down_filter(authors_filter.clone(), GossipFilterPattern::Nip65)
+            .await
+        {
             BrokenDownFilters::Filters(map) => {
                 assert_eq!(map.get(&damus_url).unwrap(), &authors_filter);
                 assert_eq!(
@@ -775,7 +852,10 @@ mod tests {
 
         // Other filter
         let search_filter = Filter::new().search("Test").limit(10);
-        match graph.break_down_filter(search_filter.clone()).await {
+        match graph
+            .break_down_filter(search_filter.clone(), GossipFilterPattern::Nip65)
+            .await
+        {
             BrokenDownFilters::Other(filter) => {
                 assert_eq!(filter, search_filter);
             }
@@ -784,7 +864,10 @@ mod tests {
 
         // Single p tags
         let p_tag_filter = Filter::new().pubkey(keys_a.public_key);
-        match graph.break_down_filter(p_tag_filter.clone()).await {
+        match graph
+            .break_down_filter(p_tag_filter.clone(), GossipFilterPattern::Nip65)
+            .await
+        {
             BrokenDownFilters::Filters(map) => {
                 assert_eq!(map.get(&damus_url).unwrap(), &p_tag_filter);
                 assert_eq!(map.get(&nostr_bg_url).unwrap(), &p_tag_filter);
@@ -801,7 +884,10 @@ mod tests {
         let filter = Filter::new()
             .author(keys_a.public_key)
             .pubkey(keys_b.public_key);
-        match graph.break_down_filter(filter.clone()).await {
+        match graph
+            .break_down_filter(filter.clone(), GossipFilterPattern::Nip65)
+            .await
+        {
             BrokenDownFilters::Filters(map) => {
                 assert_eq!(map.get(&damus_url).unwrap(), &filter);
                 assert_eq!(map.get(&nostr_bg_url).unwrap(), &filter);
@@ -817,7 +903,10 @@ mod tests {
         // test orphan filters
         let random_keys = Keys::generate();
         let filter = Filter::new().author(random_keys.public_key);
-        match graph.break_down_filter(filter.clone()).await {
+        match graph
+            .break_down_filter(filter.clone(), GossipFilterPattern::Nip65)
+            .await
+        {
             BrokenDownFilters::Orphan(f) => {
                 assert_eq!(f, filter);
             }
