nostr: take a single filter per REQ

Ref nostr-protocol/nips#1645 Closes #568 Signed-off-by: Yuki Kishimoto <[email protected]>
rust-nostr · Jan 28, 2025 · f7b5c0d · f7b5c0d
1 parent 4664dc4
commit f7b5c0d
Show file tree

Hide file tree

Showing 43 changed files with 679 additions and 1,033 deletions.
diff --git a/bindings/nostr-sdk-ffi/src/client/mod.rs b/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())
     }

diff --git a/bindings/nostr-sdk-ffi/src/database/mod.rs b/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`

diff --git a/bindings/nostr-sdk-ffi/src/protocol/message/client.rs b/bindings/nostr-sdk-ffi/src/protocol/message/client.rs
@@ -20,11 +20,11 @@ pub enum ClientMessageEnum {
     },
     Req {
         subscription_id: String,
-        filters: Vec<Arc<Filter>>,
+        filter: Arc<Filter>,
     },
     Count {
         subscription_id: String,
-        filters: Vec<Arc<Filter>>,
+        filter: Arc<Filter>,
     },
     Close {
         subscription_id: String,
@@ -59,23 +59,17 @@ impl From<ClientMessageEnum> for nostr::ClientMessage {
             }
             ClientMessageEnum::Req {
                 subscription_id,
-                filters,
+                filter,
             } => Self::Req {
                 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::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 +110,17 @@ impl From<nostr::ClientMessage> for ClientMessageEnum {
             },
             nostr::ClientMessage::Req {
                 subscription_id,
-                filters,
+                filter,
             } => Self::Req {
                 subscription_id: subscription_id.to_string(),
-                filters: filters.into_iter().map(|f| Arc::new(f.into())).collect(),
+                filter: Arc::new((*filter).into()),
             },
             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 +185,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(),
             ),
         }
     }