nostr: take a single filter per REQ

CHANGELOG.md

@@ -39,6 +39,7 @@
 * nostr: change `EventBuilder::gift_wrap` rumor arg type ([Yuki Kishimoto])
 * nostr: change `Filter::custom_tag` value arg type ([Yuki Kishimoto])
 * nostr: rename `Filter::remove_custom_tag` to `Filter::remove_custom_tags` ([Yuki Kishimoto])
+* nostr: take a single filter per REQ and COUNT ([Yuki Kishimoto])
 * pool: change `Relay::connect` method signature ([Yuki Kishimoto])
 * pool: change `Relay::disconnect` method signature ([Yuki Kishimoto])
 * pool: change `RelayPool::disconnect` method signature ([Yuki Kishimoto])
@@ -94,6 +95,7 @@
 * lmdb: use `EventBorrow` instead of `DatabaseEvent` ([Yuki Kishimoto])
 * ndb: refactor note-to-event conversion ([Yuki Kishimoto])
 * relay-builder: refactor shutdown mechanism to use `Notify` over `broadcast` ([Yuki Kishimoto])
+* relay-builder: increase default max REQs to 500 ([Yuki Kishimoto])
 
 ### Added
 

bindings/nostr-sdk-ffi/src/client/mod.rs

@@ -216,25 +216,20 @@ impl Client {
         self.inner.disconnect().await
     }
 
-    pub async fn subscriptions(&self) -> HashMap<String, Vec<Arc<Filter>>> {
+    pub async fn subscriptions(&self) -> HashMap<String, Arc<Filter>> {
         self.inner
             .subscriptions()
             .await
             .into_iter()
-            .map(|(id, filters)| {
-                (
-                    id.to_string(),
-                    filters.into_iter().map(|f| Arc::new(f.into())).collect(),
-                )
-            })
+            .map(|(id, f)| (id.to_string(), Arc::new(f.into())))
             .collect()
     }
 
-    pub async fn subscription(&self, id: String) -> Option<Vec<Arc<Filter>>> {
+    pub async fn subscription(&self, id: String) -> Option<Arc<Filter>> {
         self.inner
             .subscription(&SubscriptionId::new(id))
             .await
-            .map(|filters| filters.into_iter().map(|f| Arc::new(f.into())).collect())
+            .map(|f| Arc::new(f.into()))
     }
 
     /// Subscribe to filters
@@ -248,16 +243,12 @@ impl Client {
     #[uniffi::method(default(opts = None))]
     pub async fn subscribe(
         &self,
-        filters: Vec<Arc<Filter>>,
+        filter: &Filter,
         opts: Option<Arc<SubscribeAutoCloseOptions>>,
     ) -> Result<SubscribeOutput> {
-        let filters = filters
-            .into_iter()
-            .map(|f| f.as_ref().deref().clone())
-            .collect();
         Ok(self
             .inner
-            .subscribe(filters, opts.map(|o| **o))
+            .subscribe(filter.deref().clone(), opts.map(|o| **o))
             .await?
             .into())
     }
@@ -274,16 +265,16 @@ impl Client {
     pub async fn subscribe_with_id(
         &self,
         id: String,
-        filters: Vec<Arc<Filter>>,
+        filter: &Filter,
         opts: Option<Arc<SubscribeAutoCloseOptions>>,
     ) -> Result<Output> {
-        let filters = filters
-            .into_iter()
-            .map(|f| f.as_ref().deref().clone())
-            .collect();
         Ok(self
             .inner
-            .subscribe_with_id(SubscriptionId::new(id), filters, opts.map(|o| **o))
+            .subscribe_with_id(
+                SubscriptionId::new(id),
+                filter.deref().clone(),
+                opts.map(|o| **o),
+            )
             .await?
             .into())
     }
@@ -297,16 +288,12 @@ impl Client {
     pub async fn subscribe_to(
         &self,
         urls: Vec<String>,
-        filters: Vec<Arc<Filter>>,
+        filter: &Filter,
         opts: Option<Arc<SubscribeAutoCloseOptions>>,
     ) -> Result<SubscribeOutput> {
-        let filters = filters
-            .into_iter()
-            .map(|f| f.as_ref().deref().clone())
-            .collect();
         Ok(self
             .inner
-            .subscribe_to(urls, filters, opts.map(|o| **o))
+            .subscribe_to(urls, filter.deref().clone(), opts.map(|o| **o))
             .await?
             .into())
     }
@@ -321,16 +308,17 @@ impl Client {
         &self,
         urls: Vec<String>,
         id: String,
-        filters: Vec<Arc<Filter>>,
+        filter: &Filter,
         opts: Option<Arc<SubscribeAutoCloseOptions>>,
     ) -> Result<Output> {
-        let filters = filters
-            .into_iter()
-            .map(|f| f.as_ref().deref().clone())
-            .collect();
         Ok(self
             .inner
-            .subscribe_with_id_to(urls, SubscriptionId::new(id), filters, opts.map(|o| **o))
+            .subscribe_with_id_to(
+                urls,
+                SubscriptionId::new(id),
+                filter.deref().clone(),
+                opts.map(|o| **o),
+            )
             .await?
             .into())
     }
@@ -363,32 +351,24 @@ impl Client {
     ///
     /// If `gossip` is enabled (see `Options`) the events will be requested also to
     /// NIP65 relays (automatically discovered) of public keys included in filters (if any).
-    pub async fn fetch_events(
-        &self,
-        filters: Vec<Arc<Filter>>,
-        timeout: Duration,
-    ) -> Result<Events> {
-        let filters = filters
-            .into_iter()
-            .map(|f| f.as_ref().deref().clone())
-            .collect();
-        Ok(self.inner.fetch_events(filters, timeout).await?.into())
+    pub async fn fetch_events(&self, filter: &Filter, timeout: Duration) -> Result<Events> {
+        Ok(self
+            .inner
+            .fetch_events(filter.deref().clone(), timeout)
+            .await?
+            .into())
     }
 
     /// Fetch events from specific relays
     pub async fn fetch_events_from(
         &self,
         urls: Vec<String>,
-        filters: Vec<Arc<Filter>>,
+        filter: &Filter,
         timeout: Duration,
     ) -> Result<Events> {
-        let filters = filters
-            .into_iter()
-            .map(|f| f.as_ref().deref().clone())
-            .collect();
         Ok(self
             .inner
-            .fetch_events_from(urls, filters, timeout)
+            .fetch_events_from(urls, filter.deref().clone(), timeout)
             .await?
             .into())
     }
@@ -407,16 +387,12 @@ impl Client {
     /// NIP65 relays (automatically discovered) of public keys included in filters (if any).
     pub async fn fetch_combined_events(
         &self,
-        filters: Vec<Arc<Filter>>,
+        filter: &Filter,
         timeout: Duration,
     ) -> Result<Events> {
-        let filters = filters
-            .into_iter()
-            .map(|f| f.as_ref().deref().clone())
-            .collect();
         Ok(self
             .inner
-            .fetch_combined_events(filters, timeout)
+            .fetch_combined_events(filter.deref().clone(), timeout)
             .await?
             .into())
     }

bindings/nostr-sdk-ffi/src/database/mod.rs

@@ -136,20 +136,14 @@ impl NostrDatabase {
             .map(|e| Arc::new(e.into())))
     }
 
-    pub async fn count(&self, filters: Vec<Arc<Filter>>) -> Result<u64> {
-        let filters = filters
-            .into_iter()
-            .map(|f| f.as_ref().deref().clone())
-            .collect();
-        Ok(self.inner.count(filters).await? as u64)
+    pub async fn count(&self, filter: &Filter) -> Result<u64> {
+        Ok(self.inner.count(filter.deref().clone()).await? as u64)
     }
 
-    pub async fn query(&self, filters: Vec<Arc<Filter>>) -> Result<Arc<Events>> {
-        let filters = filters
-            .into_iter()
-            .map(|f| f.as_ref().deref().clone())
-            .collect();
-        Ok(Arc::new(self.inner.query(filters).await?.into()))
+    pub async fn query(&self, filter: &Filter) -> Result<Arc<Events>> {
+        Ok(Arc::new(
+            self.inner.query(filter.deref().clone()).await?.into(),
+        ))
     }
 
     /// Delete all events that match the `Filter`

bindings/nostr-sdk-ffi/src/protocol/message/client.rs

@@ -19,12 +19,19 @@ pub enum ClientMessageEnum {
         event: Arc<Event>,
     },
     Req {
+        subscription_id: String,
+        filter: Arc<Filter>,
+    },
+    /// Multi-filter REQ (deprecated)
+    ///
+    /// <https://github.com/nostr-protocol/nips/pull/1645>
+    ReqMultiFilter {
         subscription_id: String,
         filters: Vec<Arc<Filter>>,
     },
     Count {
         subscription_id: String,
-        filters: Vec<Arc<Filter>>,
+        filter: Arc<Filter>,
     },
     Close {
         subscription_id: String,
@@ -59,8 +66,15 @@ impl From<ClientMessageEnum> for nostr::ClientMessage {
             }
             ClientMessageEnum::Req {
                 subscription_id,
-                filters,
+                filter,
             } => Self::Req {
+                subscription_id: SubscriptionId::new(subscription_id),
+                filter: Box::new(filter.as_ref().deref().clone()),
+            },
+            ClientMessageEnum::ReqMultiFilter {
+                subscription_id,
+                filters,
+            } => Self::ReqMultiFilter {
                 subscription_id: SubscriptionId::new(subscription_id),
                 filters: filters
                     .into_iter()
@@ -69,13 +83,10 @@ impl From<ClientMessageEnum> for nostr::ClientMessage {
             },
             ClientMessageEnum::Count {
                 subscription_id,
-                filters,
+                filter,
             } => Self::Count {
                 subscription_id: SubscriptionId::new(subscription_id),
-                filters: filters
-                    .into_iter()
-                    .map(|f| f.as_ref().deref().clone())
-                    .collect(),
+                filter: Box::new(filter.as_ref().deref().clone()),
             },
             ClientMessageEnum::Close { subscription_id } => {
                 Self::Close(SubscriptionId::new(subscription_id))
@@ -116,17 +127,24 @@ impl From<nostr::ClientMessage> for ClientMessageEnum {
             },
             nostr::ClientMessage::Req {
                 subscription_id,
-                filters,
+                filter,
             } => Self::Req {
+                subscription_id: subscription_id.to_string(),
+                filter: Arc::new((*filter).into()),
+            },
+            nostr::ClientMessage::ReqMultiFilter {
+                subscription_id,
+                filters,
+            } => Self::ReqMultiFilter {
                 subscription_id: subscription_id.to_string(),
                 filters: filters.into_iter().map(|f| Arc::new(f.into())).collect(),
             },
             nostr::ClientMessage::Count {
                 subscription_id,
-                filters,
+                filter,
             } => Self::Count {
                 subscription_id: subscription_id.to_string(),
-                filters: filters.into_iter().map(|f| Arc::new(f.into())).collect(),
+                filter: Arc::new((*filter).into()),
             },
             nostr::ClientMessage::Close(subscription_id) => Self::Close {
                 subscription_id: subscription_id.to_string(),
@@ -191,28 +209,22 @@ impl ClientMessage {
 
     /// Create new `REQ` message
     #[uniffi::constructor]
-    pub fn req(subscription_id: &str, filters: Vec<Arc<Filter>>) -> Self {
+    pub fn req(subscription_id: &str, filter: &Filter) -> Self {
         Self {
             inner: nostr::ClientMessage::req(
                 SubscriptionId::new(subscription_id),
-                filters
-                    .into_iter()
-                    .map(|f| f.as_ref().deref().clone())
-                    .collect(),
+                filter.deref().clone(),
             ),
         }
     }
 
     /// Create new `COUNT` message
     #[uniffi::constructor]
-    pub fn count(subscription_id: &str, filters: Vec<Arc<Filter>>) -> Self {
+    pub fn count(subscription_id: &str, filter: &Filter) -> Self {
         Self {
             inner: nostr::ClientMessage::count(
                 SubscriptionId::new(subscription_id),
-                filters
-                    .into_iter()
-                    .map(|f| f.as_ref().deref().clone())
-                    .collect(),
+                filter.deref().clone(),
             ),
         }
     }