diff --git a/waku-bindings/src/decrypt.rs b/waku-bindings/src/decrypt.rs
deleted file mode 100644
index 430ea5e..0000000
--- a/waku-bindings/src/decrypt.rs
+++ /dev/null
@@ -1,91 +0,0 @@
-//! Symmetric and asymmetric waku messages [decrypting](https://rfc.vac.dev/spec/36/#decrypting-messages) methods
-
-// std
-use std::ffi::CString;
-// crates
-use aes_gcm::{Aes256Gcm, Key};
-use libc::*;
-use secp256k1::SecretKey;
-// internal
-use crate::general::{DecodedPayload, Result, WakuMessage};
-use crate::utils::{get_trampoline, handle_json_response};
-
-/// Decrypt a message using a symmetric key
-///
-/// As per the [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_decode_symmetricchar-messagejson-char-symmetrickey)
-pub fn waku_decode_symmetric(
-    message: &WakuMessage,
-    symmetric_key: &Key<Aes256Gcm>,
-) -> Result<DecodedPayload> {
-    let symk = hex::encode(symmetric_key.as_slice());
-
-    let message_ptr = CString::new(
-        serde_json::to_string(&message)
-            .expect("WakuMessages should always be able to success serializing"),
-    )
-    .expect("CString should build properly from the serialized waku message")
-    .into_raw();
-    let symk_ptr = CString::new(symk)
-        .expect("CString should build properly from hex encoded symmetric key")
-        .into_raw();
-
-    let mut result: String = Default::default();
-    let result_cb = |v: &str| result = v.to_string();
-    let code = unsafe {
-        let mut closure = result_cb;
-        let cb = get_trampoline(&closure);
-        let out = waku_sys::waku_decode_symmetric(
-            message_ptr,
-            symk_ptr,
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(message_ptr));
-        drop(CString::from_raw(symk_ptr));
-
-        out
-    };
-
-    handle_json_response(code, &result)
-}
-
-/// Decrypt a message using a symmetric key
-///
-/// As per the [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_decode_asymmetricchar-messagejson-char-privatekey)
-pub fn waku_decode_asymmetric(
-    message: &WakuMessage,
-    asymmetric_key: &SecretKey,
-) -> Result<DecodedPayload> {
-    let sk = hex::encode(asymmetric_key.secret_bytes());
-
-    let message_ptr = CString::new(
-        serde_json::to_string(&message)
-            .expect("WakuMessages should always be able to success serializing"),
-    )
-    .expect("CString should build properly from the serialized waku message")
-    .into_raw();
-    let sk_ptr = CString::new(sk)
-        .expect("CString should build properly from hex encoded symmetric key")
-        .into_raw();
-
-    let mut result: String = Default::default();
-    let result_cb = |v: &str| result = v.to_string();
-    let code = unsafe {
-        let mut closure = result_cb;
-        let cb = get_trampoline(&closure);
-        let out = waku_sys::waku_decode_asymmetric(
-            message_ptr,
-            sk_ptr,
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(message_ptr));
-        drop(CString::from_raw(sk_ptr));
-
-        out
-    };
-
-    handle_json_response(code, &result)
-}
diff --git a/waku-bindings/src/encrypt.rs b/waku-bindings/src/encrypt.rs
deleted file mode 100644
index 0933c86..0000000
--- a/waku-bindings/src/encrypt.rs
+++ /dev/null
@@ -1,101 +0,0 @@
-// std
-use std::ffi::CString;
-// crates
-use aes_gcm::{Aes256Gcm, Key};
-use libc::*;
-use secp256k1::{PublicKey, SecretKey};
-// internal
-use crate::general::{Result, WakuMessage};
-use crate::utils::{get_trampoline, handle_json_response};
-
-/// Optionally sign and encrypt a message using asymmetric encryption
-pub fn waku_encode_asymmetric(
-    message: &WakuMessage,
-    public_key: &PublicKey,
-    signing_key: Option<&SecretKey>,
-) -> Result<WakuMessage> {
-    let pk = hex::encode(public_key.serialize_uncompressed());
-    let sk = signing_key
-        .map(|signing_key| hex::encode(signing_key.secret_bytes()))
-        .unwrap_or_default();
-    let message_ptr = CString::new(
-        serde_json::to_string(&message)
-            .expect("WakuMessages should always be able to success serializing"),
-    )
-    .expect("CString should build properly from the serialized waku message")
-    .into_raw();
-    let pk_ptr = CString::new(pk)
-        .expect("CString should build properly from hex encoded public key")
-        .into_raw();
-    let sk_ptr = CString::new(sk)
-        .expect("CString should build properly from hex encoded signing key")
-        .into_raw();
-
-    let mut result: String = Default::default();
-    let result_cb = |v: &str| result = v.to_string();
-    let code = unsafe {
-        let mut closure = result_cb;
-        let cb = get_trampoline(&closure);
-        let out = waku_sys::waku_encode_asymmetric(
-            message_ptr,
-            pk_ptr,
-            sk_ptr,
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(message_ptr));
-        drop(CString::from_raw(pk_ptr));
-        drop(CString::from_raw(sk_ptr));
-
-        out
-    };
-
-    handle_json_response(code, &result)
-}
-
-/// Optionally sign and encrypt a message using symmetric encryption
-pub fn waku_encode_symmetric(
-    message: &WakuMessage,
-    symmetric_key: &Key<Aes256Gcm>,
-    signing_key: Option<&SecretKey>,
-) -> Result<WakuMessage> {
-    let symk = hex::encode(symmetric_key.as_slice());
-    let sk = signing_key
-        .map(|signing_key| hex::encode(signing_key.secret_bytes()))
-        .unwrap_or_default();
-    let message_ptr = CString::new(
-        serde_json::to_string(&message)
-            .expect("WakuMessages should always be able to success serializing"),
-    )
-    .expect("CString should build properly from the serialized waku message")
-    .into_raw();
-    let symk_ptr = CString::new(symk)
-        .expect("CString should build properly from hex encoded symmetric key")
-        .into_raw();
-    let sk_ptr = CString::new(sk)
-        .expect("CString should build properly from hex encoded signing key")
-        .into_raw();
-
-    let mut result: String = Default::default();
-    let result_cb = |v: &str| result = v.to_string();
-    let code = unsafe {
-        let mut closure = result_cb;
-        let cb = get_trampoline(&closure);
-        let out = waku_sys::waku_encode_symmetric(
-            message_ptr,
-            symk_ptr,
-            sk_ptr,
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(message_ptr));
-        drop(CString::from_raw(symk_ptr));
-        drop(CString::from_raw(sk_ptr));
-
-        out
-    };
-
-    handle_json_response(code, &result)
-}
diff --git a/waku-bindings/src/node/discovery.rs b/waku-bindings/src/node/discovery.rs
deleted file mode 100644
index 5a38af5..0000000
--- a/waku-bindings/src/node/discovery.rs
+++ /dev/null
@@ -1,108 +0,0 @@
-// std
-use std::ffi::CString;
-use std::time::Duration;
-// crates
-use enr::Enr;
-use libc::*;
-use multiaddr::Multiaddr;
-use serde::Deserialize;
-use url::{Host, Url};
-// internal
-use crate::utils::{get_trampoline, handle_json_response, handle_no_response};
-use crate::{PeerId, Result};
-
-#[derive(Deserialize, Debug)]
-#[serde(rename_all = "camelCase")]
-pub struct DnsInfo {
-    #[serde(alias = "peerID")]
-    pub peer_id: PeerId,
-    #[serde(default, alias = "multiaddrs")]
-    pub addresses: Vec<Multiaddr>,
-    pub enr: Option<Enr<enr::secp256k1::SecretKey>>,
-}
-
-/// RetrieveNodes returns a list of multiaddress given a url to a DNS discoverable ENR tree.
-/// The nameserver can optionally be specified to resolve the enrtree url. Otherwise uses the default system dns.
-pub fn waku_dns_discovery(
-    url: &Url,
-    server: Option<&Host>,
-    timeout: Option<Duration>,
-) -> Result<Vec<DnsInfo>> {
-    let url = CString::new(url.to_string())
-        .expect("CString should build properly from a valid Url")
-        .into_raw();
-    let server = CString::new(server.map(|host| host.to_string()).unwrap_or_default())
-        .expect("CString should build properly from a String nameserver")
-        .into_raw();
-
-    let mut result: String = Default::default();
-    let result_cb = |v: &str| result = v.to_string();
-    let code = unsafe {
-        let mut closure = result_cb;
-        let cb = get_trampoline(&closure);
-        let out = waku_sys::waku_dns_discovery(
-            url,
-            server,
-            timeout
-                .map(|timeout| {
-                    timeout
-                        .as_millis()
-                        .try_into()
-                        .expect("Duration as milliseconds should fit in a i32")
-                })
-                .unwrap_or(0),
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(url));
-        drop(CString::from_raw(server));
-
-        out
-    };
-
-    handle_json_response(code, &result)
-}
-
-/// Update the bootnodes used by DiscoveryV5 by passing a list of ENRs
-pub fn waku_discv5_update_bootnodes(bootnodes: Vec<String>) -> Result<()> {
-    let bootnodes_ptr = CString::new(
-        serde_json::to_string(&bootnodes)
-            .expect("Serialization from properly built bootnode array should never fail"),
-    )
-    .expect("CString should build properly from the string vector")
-    .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_discv5_update_bootnodes(
-            bootnodes_ptr,
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(bootnodes_ptr));
-
-        out
-    };
-
-    handle_no_response(code, &error)
-}
-
-#[cfg(test)]
-mod test {
-    use url::Url;
-
-    #[test]
-    fn test_dns_discovery() {
-        let enrtree: Url =
-            "enrtree://AO47IDOLBKH72HIZZOXQP6NMRESAN7CHYWIBNXDXWRJRZWLODKII6@test.wakuv2.nodes.status.im".parse().unwrap();
-        let result = super::waku_dns_discovery(&enrtree, None, None);
-        assert!(result.is_ok());
-        assert!(!result.as_ref().unwrap().is_empty());
-        println!("{result:?}");
-    }
-}
diff --git a/waku-bindings/src/node/filter.rs b/waku-bindings/src/node/filter.rs
deleted file mode 100644
index 70336f2..0000000
--- a/waku-bindings/src/node/filter.rs
+++ /dev/null
@@ -1,182 +0,0 @@
-//! 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::{ContentFilter, FilterSubscriptionResult, PeerId};
-use crate::utils::{get_trampoline, handle_json_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(
-    content_filter: &ContentFilter,
-    peer_id: Option<PeerId>,
-    timeout: Option<Duration>,
-) -> Result<FilterSubscriptionResult> {
-    let content_filter_ptr = CString::new(
-        serde_json::to_string(content_filter)
-            .expect("ContentFilter should always succeed to serialize"),
-    )
-    .expect("ContentFilter 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(
-            content_filter_ptr,
-            peer_id_ptr,
-            timeout
-                .map(|timeout| {
-                    timeout
-                        .as_millis()
-                        .try_into()
-                        .expect("Duration as milliseconds should fit in a i32")
-                })
-                .unwrap_or(0),
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(content_filter_ptr));
-        drop(CString::from_raw(peer_id_ptr));
-
-        out
-    };
-
-    handle_json_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: Option<Duration>) -> Result<()> {
-    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_filter_ping(
-            peer_id_ptr,
-            timeout
-                .map(|timeout| {
-                    timeout
-                        .as_millis()
-                        .try_into()
-                        .expect("Duration as milliseconds should fit in a i32")
-                })
-                .unwrap_or(0),
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(peer_id_ptr));
-
-        out
-    };
-
-    handle_no_response(code, &error)
-}
-
-/// 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(
-    content_filter: &ContentFilter,
-    peer_id: PeerId,
-    timeout: Option<Duration>,
-) -> Result<()> {
-    let content_filter_ptr = CString::new(
-        serde_json::to_string(content_filter)
-            .expect("ContentFilter should always succeed to serialize"),
-    )
-    .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_filter_unsubscribe(
-            content_filter_ptr,
-            peer_id_ptr,
-            timeout
-                .map(|timeout| {
-                    timeout
-                        .as_millis()
-                        .try_into()
-                        .expect("Duration as milliseconds should fit in a i32")
-                })
-                .unwrap_or(0),
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(content_filter_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: Option<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
-                .map(|timeout| {
-                    timeout
-                        .as_millis()
-                        .try_into()
-                        .expect("Duration as milliseconds should fit in a i32")
-                })
-                .unwrap_or(0),
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(peer_id_ptr));
-
-        out
-    };
-
-    handle_no_response(code, &error)
-}
diff --git a/waku-bindings/src/node/legacyfilter.rs b/waku-bindings/src/node/legacyfilter.rs
deleted file mode 100644
index 35ef177..0000000
--- a/waku-bindings/src/node/legacyfilter.rs
+++ /dev/null
@@ -1,89 +0,0 @@
-//! 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)
-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)
-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)
-}
diff --git a/waku-bindings/src/node/lightpush.rs b/waku-bindings/src/node/lightpush.rs
deleted file mode 100644
index f51432a..0000000
--- a/waku-bindings/src/node/lightpush.rs
+++ /dev/null
@@ -1,66 +0,0 @@
-//! Waku [lightpush](https://rfc.vac.dev/spec/36/#waku-lightpush) protocol related methods
-
-// std
-use std::ffi::CString;
-use std::time::Duration;
-// crates
-use libc::*;
-// internal
-use crate::general::{MessageId, PeerId, Result, WakuMessage, WakuPubSubTopic};
-use crate::node::waku_default_pubsub_topic;
-use crate::utils::{get_trampoline, handle_response};
-
-/// Publish a message using Waku Lightpush
-/// As per the [specification](https://rfc.vac.dev/spec/36/#extern-char-waku_lightpush_publishchar-messagejson-char-topic-char-peerid-int-timeoutms)
-pub fn waku_lightpush_publish(
-    message: &WakuMessage,
-    pubsub_topic: Option<WakuPubSubTopic>,
-    peer_id: PeerId,
-    timeout: Option<Duration>,
-) -> Result<MessageId> {
-    let pubsub_topic = pubsub_topic
-        .unwrap_or_else(waku_default_pubsub_topic)
-        .to_string();
-    let message_ptr = CString::new(
-        serde_json::to_string(&message)
-            .expect("WakuMessages should always be able to success serializing"),
-    )
-    .expect("CString should build properly from the serialized waku message")
-    .into_raw();
-    let topic_ptr = CString::new(pubsub_topic)
-        .expect("CString should build properly from pubsub topic")
-        .into_raw();
-    let peer_id_ptr = CString::new(peer_id)
-        .expect("CString should build properly from peer id")
-        .into_raw();
-
-    let mut result: String = Default::default();
-    let result_cb = |v: &str| result = v.to_string();
-    let code = unsafe {
-        let mut closure = result_cb;
-        let cb = get_trampoline(&closure);
-        let out = waku_sys::waku_lightpush_publish(
-            message_ptr,
-            topic_ptr,
-            peer_id_ptr,
-            timeout
-                .map(|timeout| {
-                    timeout
-                        .as_millis()
-                        .try_into()
-                        .expect("Duration as milliseconds should fit in a i32")
-                })
-                .unwrap_or(0),
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(message_ptr));
-        drop(CString::from_raw(topic_ptr));
-        drop(CString::from_raw(peer_id_ptr));
-
-        out
-    };
-
-    handle_response(code, &result)
-}
diff --git a/waku-bindings/src/node/store.rs b/waku-bindings/src/node/store.rs
deleted file mode 100644
index 32f9ad0..0000000
--- a/waku-bindings/src/node/store.rs
+++ /dev/null
@@ -1,84 +0,0 @@
-//! Waku [store](https://rfc.vac.dev/spec/36/#waku-store) handling methods
-
-// std
-use std::ffi::CString;
-use std::time::Duration;
-// crates
-use libc::*;
-// internal
-use crate::general::{PeerId, Result, StoreQuery, StoreResponse};
-use crate::utils::{get_trampoline, handle_json_response};
-
-/// Retrieves historical messages on specific content topics. This method may be called with [`PagingOptions`](`crate::general::PagingOptions`),
-/// to retrieve historical messages on a per-page basis. If the request included [`PagingOptions`](`crate::general::PagingOptions`),
-/// the node must return messages on a per-page basis and include [`PagingOptions`](`crate::general::PagingOptions`) in the response.
-/// These [`PagingOptions`](`crate::general::PagingOptions`) must contain a cursor pointing to the Index from which a new page can be requested
-pub fn waku_store_query(
-    query: &StoreQuery,
-    peer_id: &PeerId,
-    timeout: Option<Duration>,
-) -> Result<StoreResponse> {
-    let query_ptr = CString::new(
-        serde_json::to_string(query).expect("StoreQuery should always be able to be serialized"),
-    )
-    .expect("CString should build properly from the serialized filter subscription")
-    .into_raw();
-    let peer_id_ptr = CString::new(peer_id.clone())
-        .expect("CString should build properly from peer id")
-        .into_raw();
-
-    let mut result: String = Default::default();
-    let result_cb = |v: &str| result = v.to_string();
-    let code = unsafe {
-        let mut closure = result_cb;
-        let cb = get_trampoline(&closure);
-        let out = waku_sys::waku_store_query(
-            query_ptr,
-            peer_id_ptr,
-            timeout
-                .map(|timeout| {
-                    timeout
-                        .as_millis()
-                        .try_into()
-                        .expect("Duration as milliseconds should fit in a i32")
-                })
-                .unwrap_or(0),
-            cb,
-            &mut closure as *mut _ as *mut c_void,
-        );
-
-        drop(CString::from_raw(query_ptr));
-        drop(CString::from_raw(peer_id_ptr));
-
-        out
-    };
-
-    handle_json_response(code, &result)
-}
-
-/// Retrieves locally stored historical messages on specific content topics from the local archive system. This method may be called with [`PagingOptions`](`crate::general::PagingOptions`),
-/// to retrieve historical messages on a per-page basis. If the request included [`PagingOptions`](`crate::general::PagingOptions`),
-/// the node must return messages on a per-page basis and include [`PagingOptions`](`crate::general::PagingOptions`) in the response.
-/// These [`PagingOptions`](`crate::general::PagingOptions`) must contain a cursor pointing to the Index from which a new page can be requested
-pub fn waku_local_store_query(query: &StoreQuery) -> Result<StoreResponse> {
-    let query_ptr = CString::new(
-        serde_json::to_string(query).expect("StoreQuery should always be able to be serialized"),
-    )
-    .expect("CString should build properly from the serialized filter subscription")
-    .into_raw();
-
-    let mut result: String = Default::default();
-    let result_cb = |v: &str| result = v.to_string();
-    let code = unsafe {
-        let mut closure = result_cb;
-        let cb = get_trampoline(&closure);
-        let out =
-            waku_sys::waku_store_local_query(query_ptr, cb, &mut closure as *mut _ as *mut c_void);
-
-        drop(CString::from_raw(query_ptr));
-
-        out
-    };
-
-    handle_json_response(code, &result)
-}