feat: add filterv2 functions

waku-bindings/src/general/mod.rs

@@ -217,15 +217,16 @@ impl ContentFilter {
 /// The criteria to create subscription to a light node in JSON Format
 /// as per the [specification](https://rfc.vac.dev/spec/36/#filtersubscription-type)
 #[derive(Clone, Serialize, Deserialize, Debug)]
+#[deprecated]
 #[serde(rename_all = "camelCase")]
-pub struct FilterSubscription {
+pub struct LegacyFilterSubscription {
     /// Array of [`ContentFilter`] being subscribed to / unsubscribed from
     content_filters: Vec<ContentFilter>,
     /// Optional pubsub topic
     pubsub_topic: Option<WakuPubSubTopic>,
 }
 
-impl FilterSubscription {
+impl LegacyFilterSubscription {
     pub fn new(content_filters: Vec<ContentFilter>, pubsub_topic: Option<WakuPubSubTopic>) -> Self {
         Self {
             content_filters,
@@ -242,6 +243,37 @@ impl FilterSubscription {
     }
 }
 
+/// The criteria to create subscription to a filter full node matching a content filter.
+/// as per the [specification](https://rfc.vac.dev/spec/36/#filtersubscription-type)
+#[derive(Clone, Serialize, Deserialize, Debug)]
+#[serde(rename_all = "camelCase")]
+pub struct FilterSubscription {
+    /// mandatory, at least one required, with a max of 10
+    content_topics: Vec<WakuContentTopic>,
+    /// optional if using autosharding, mandatory if using static or named sharding.
+    pubsub_topic: Option<WakuPubSubTopic>,
+}
+
+impl FilterSubscription {
+    pub fn new(
+        content_topics: Vec<WakuContentTopic>,
+        pubsub_topic: Option<WakuPubSubTopic>,
+    ) -> Self {
+        Self {
+            content_topics,
+            pubsub_topic,
+        }
+    }
+
+    pub fn content_topics(&self) -> &[WakuContentTopic] {
+        &self.content_topics
+    }
+
+    pub fn pubsub_topic(&self) -> Option<&WakuPubSubTopic> {
+        self.pubsub_topic.as_ref()
+    }
+}
+
 /// Criteria used to retrieve historical messages
 #[derive(Clone, Serialize, Debug)]
 #[serde(rename_all = "camelCase")]

waku-bindings/src/lib.rs

@@ -16,9 +16,9 @@ pub use node::{
 };
 
 pub use general::{
-    ContentFilter, DecodedPayload, Encoding, FilterSubscription, MessageId, MessageIndex,
-    PagingOptions, PeerId, ProtocolId, Result, StoreQuery, StoreResponse, WakuContentTopic,
-    WakuMessage, WakuMessageVersion, WakuPubSubTopic,
+    ContentFilter, DecodedPayload, Encoding, FilterSubscription, LegacyFilterSubscription,
+    MessageId, MessageIndex, PagingOptions, PeerId, ProtocolId, Result, StoreQuery, StoreResponse,
+    WakuContentTopic, WakuMessage, WakuMessageVersion, WakuPubSubTopic,
 };
 
 pub use events::{waku_set_event_callback, Event, Signal, WakuMessageEvent};

waku-bindings/src/node/filter.rs

@@ -8,21 +8,57 @@ use libc::*;
 // internal
 use crate::general::Result;
 use crate::general::{FilterSubscription, PeerId};
-use crate::utils::{get_trampoline, handle_no_response};
+use crate::utils::{get_trampoline, handle_response, handle_no_response};
 
 /// Creates a subscription in a lightnode for messages that matches a content filter and optionally a [`WakuPubSubTopic`](`crate::general::WakuPubSubTopic`)
 /// As per the [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_filter_subscribechar-filterjson-char-peerid-int-timeoutms)
 pub fn waku_filter_subscribe(
     filter_subscription: &FilterSubscription,
-    peer_id: PeerId,
+    peer_id: Option<PeerId>,
     timeout: Duration,
-) -> Result<()> {
+) -> Result<PeerId> {
     let filter_subscription_ptr = CString::new(
         serde_json::to_string(filter_subscription)
             .expect("FilterSubscription should always succeed to serialize"),
     )
     .expect("FilterSubscription should always be able to be serialized")
     .into_raw();
+    let peer_id_ptr = match peer_id {
+        None => CString::new(""),
+        Some(t) => CString::new(t),
+    }
+    .expect("CString should build properly from peer id")
+    .into_raw();
+
+    let mut response: String = Default::default();
+    let response_cb = |v: &str| response = v.to_string();
+    let code = unsafe {
+        let mut closure = response_cb;
+        let cb = get_trampoline(&closure);
+        let out = waku_sys::waku_filter_subscribe(
+            filter_subscription_ptr,
+            peer_id_ptr,
+            timeout
+                .as_millis()
+                .try_into()
+                .expect("Duration as milliseconds should fit in a i32"),
+            cb,
+            &mut closure as *mut _ as *mut c_void,
+        );
+
+        drop(CString::from_raw(filter_subscription_ptr));
+        drop(CString::from_raw(peer_id_ptr));
+
+        out
+    };
+
+    TODO: extract the peerID from here?
+    handle_response(code, &response) 
+}
+
+/// Used to know if a service node has an active subscription for this client
+/// peerID should contain the ID of a peer we are subscribed to, supporting the filter protocol
+pub fn waku_filter_ping(peer_id: PeerId, timeout: Duration) -> Result<()> {
     let peer_id_ptr = CString::new(peer_id)
         .expect("PeerId should always be able to be serialized")
         .into_raw();
@@ -32,8 +68,7 @@ pub fn waku_filter_subscribe(
     let code = unsafe {
         let mut closure = error_cb;
         let cb = get_trampoline(&closure);
-        let out = waku_sys::waku_legacy_filter_subscribe(
-            filter_subscription_ptr,
+        let out = waku_sys::waku_filter_ping(
             peer_id_ptr,
             timeout
                 .as_millis()
@@ -43,7 +78,6 @@ pub fn waku_filter_subscribe(
             &mut closure as *mut _ as *mut c_void,
         );
 
-        drop(CString::from_raw(filter_subscription_ptr));
         drop(CString::from_raw(peer_id_ptr));
 
         out
@@ -52,10 +86,12 @@ pub fn waku_filter_subscribe(
     handle_no_response(code, &error)
 }
 
-/// Removes subscriptions in a light node matching a content filter and, optionally, a [`WakuPubSubTopic`](`crate::general::WakuPubSubTopic`)
-/// As per the [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_filter_unsubscribechar-filterjson-int-timeoutms)
+/// Sends a requests to a service node to stop pushing messages matching this filter to this client.
+/// It might be used to modify an existing subscription by providing a subset of the original filter
+/// criteria
 pub fn waku_filter_unsubscribe(
     filter_subscription: &FilterSubscription,
+    peer_id: PeerId,
     timeout: Duration,
 ) -> Result<()> {
     let filter_subscription_ptr = CString::new(
@@ -64,14 +100,18 @@ pub fn waku_filter_unsubscribe(
     )
     .expect("CString should build properly from the serialized filter subscription")
     .into_raw();
+    let peer_id_ptr = CString::new(peer_id)
+        .expect("PeerId should always be able to be serialized")
+        .into_raw();
 
     let mut error: String = Default::default();
     let error_cb = |v: &str| error = v.to_string();
     let code = unsafe {
         let mut closure = error_cb;
         let cb = get_trampoline(&closure);
-        let out = waku_sys::waku_legacy_filter_unsubscribe(
+        let out = waku_sys::waku_filter_unsubscribe(
             filter_subscription_ptr,
+            peer_id_ptr,
             timeout
                 .as_millis()
                 .try_into()
@@ -81,6 +121,41 @@ pub fn waku_filter_unsubscribe(
         );
 
         drop(CString::from_raw(filter_subscription_ptr));
+        drop(CString::from_raw(peer_id_ptr));
+
+        out
+    };
+
+    handle_no_response(code, &error)
+}
+
+/// Sends a requests to a service node (or all service nodes) to stop pushing messages
+/// peerID should contain the ID of a peer this client is subscribed to, or can be None
+/// to stop all active subscriptions
+pub fn waku_filter_unsubscribe_all(peer_id: Option<PeerId>, timeout: Duration) -> Result<()> {
+    let peer_id_ptr = match peer_id {
+        None => CString::new(""),
+        Some(t) => CString::new(t),
+    }
+    .expect("CString should build properly from peer id")
+    .into_raw();
+
+    let mut error: String = Default::default();
+    let error_cb = |v: &str| error = v.to_string();
+    let code = unsafe {
+        let mut closure = error_cb;
+        let cb = get_trampoline(&closure);
+        let out = waku_sys::waku_filter_unsubscribe_all(
+            peer_id_ptr,
+            timeout
+                .as_millis()
+                .try_into()
+                .expect("Duration as milliseconds should fit in a i32"),
+            cb,
+            &mut closure as *mut _ as *mut c_void,
+        );
+
+        drop(CString::from_raw(peer_id_ptr));
 
         out
     };

waku-bindings/src/node/legacyfilter.rs

@@ -0,0 +1,91 @@
+//! Waku [filter](https://rfc.vac.dev/spec/36/#waku-filter) protocol related methods
+
+// std
+use std::ffi::CString;
+use std::time::Duration;
+// crates
+use libc::*;
+// internal
+use crate::general::Result;
+use crate::general::{LegacyFilterSubscription, PeerId};
+use crate::utils::{get_trampoline, handle_no_response};
+
+/// Creates a subscription in a lightnode for messages that matches a content filter and optionally a [`WakuPubSubTopic`](`crate::general::WakuPubSubTopic`)
+/// As per the [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_legacy_filter_subscribechar-filterjson-char-peerid-int-timeoutms)
+#[deprecated]
+pub fn waku_legacy_filter_subscribe(
+    filter_subscription: &LegacyFilterSubscription,
+    peer_id: PeerId,
+    timeout: Duration,
+) -> Result<()> {
+    let filter_subscription_ptr = CString::new(
+        serde_json::to_string(filter_subscription)
+            .expect("FilterSubscription should always succeed to serialize"),
+    )
+    .expect("FilterSubscription should always be able to be serialized")
+    .into_raw();
+    let peer_id_ptr = CString::new(peer_id)
+        .expect("PeerId should always be able to be serialized")
+        .into_raw();
+
+    let mut error: String = Default::default();
+    let error_cb = |v: &str| error = v.to_string();
+    let code = unsafe {
+        let mut closure = error_cb;
+        let cb = get_trampoline(&closure);
+        let out = waku_sys::waku_legacy_filter_subscribe(
+            filter_subscription_ptr,
+            peer_id_ptr,
+            timeout
+                .as_millis()
+                .try_into()
+                .expect("Duration as milliseconds should fit in a i32"),
+            cb,
+            &mut closure as *mut _ as *mut c_void,
+        );
+
+        drop(CString::from_raw(filter_subscription_ptr));
+        drop(CString::from_raw(peer_id_ptr));
+
+        out
+    };
+
+    handle_no_response(code, &error)
+}
+
+/// Removes subscriptions in a light node matching a content filter and, optionally, a [`WakuPubSubTopic`](`crate::general::WakuPubSubTopic`)
+/// As per the [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_filter_unsubscribechar-filterjson-int-timeoutms)
+#[deprecated]
+pub fn waku_legacy_filter_unsubscribe(
+    filter_subscription: &LegacyFilterSubscription,
+    timeout: Duration,
+) -> Result<()> {
+    let filter_subscription_ptr = CString::new(
+        serde_json::to_string(filter_subscription)
+            .expect("FilterSubscription should always succeed to serialize"),
+    )
+    .expect("CString should build properly from the serialized filter subscription")
+    .into_raw();
+
+    let mut error: String = Default::default();
+    let error_cb = |v: &str| error = v.to_string();
+    let code = unsafe {
+        let mut closure = error_cb;
+        let cb = get_trampoline(&closure);
+        let out = waku_sys::waku_legacy_filter_unsubscribe(
+            filter_subscription_ptr,
+            timeout
+                .as_millis()
+                .try_into()
+                .expect("Duration as milliseconds should fit in a i32"),
+            cb,
+            &mut closure as *mut _ as *mut c_void,
+        );
+
+        drop(CString::from_raw(filter_subscription_ptr));
+
+        out
+    };
+
+    handle_no_response(code, &error)
+}