nostr: use Cow in ClientMessage and RelayMessage

Closes #735

Signed-off-by: Yuki Kishimoto <[email protected]>

CHANGELOG.md

@@ -34,6 +34,7 @@
 ### Changed
 
 * nostr: manually impl eq and cmp traits for `RelayUrl` ([Yuki Kishimoto])
+* nostr: use `Cow` in `ClientMessage` and `RelayMessage` ([Yuki Kishimoto])
 * ffi: improve `Events::merge` and `Events::to_vec` performance ([Yuki Kishimoto])
 
 ### Added

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

@@ -325,7 +325,7 @@ impl Client {
 
     pub async fn unsubscribe(&self, subscription_id: String) {
         self.inner
-            .unsubscribe(SubscriptionId::new(subscription_id))
+            .unsubscribe(&SubscriptionId::new(subscription_id))
             .await
     }
 

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

@@ -2,6 +2,7 @@
 // Copyright (c) 2023-2025 Rust Nostr Developers
 // Distributed under the MIT software license
 
+use std::borrow::Cow;
 use std::ops::Deref;
 use std::sync::Arc;
 
@@ -58,24 +59,22 @@ pub enum ClientMessageEnum {
     },
 }
 
-impl From<ClientMessageEnum> for nostr::ClientMessage {
+impl From<ClientMessageEnum> for nostr::ClientMessage<'static> {
     fn from(value: ClientMessageEnum) -> Self {
         match value {
-            ClientMessageEnum::EventMsg { event } => {
-                Self::Event(Box::new(event.as_ref().deref().clone()))
-            }
+            ClientMessageEnum::EventMsg { event } => Self::event(event.as_ref().deref().clone()),
             ClientMessageEnum::Req {
                 subscription_id,
                 filter,
-            } => Self::Req {
-                subscription_id: SubscriptionId::new(subscription_id),
-                filter: Box::new(filter.as_ref().deref().clone()),
-            },
+            } => Self::req(
+                SubscriptionId::new(subscription_id),
+                filter.as_ref().deref().clone(),
+            ),
             ClientMessageEnum::ReqMultiFilter {
                 subscription_id,
                 filters,
             } => Self::ReqMultiFilter {
-                subscription_id: SubscriptionId::new(subscription_id),
+                subscription_id: Cow::Owned(SubscriptionId::new(subscription_id)),
                 filters: filters
                     .into_iter()
                     .map(|f| f.as_ref().deref().clone())
@@ -84,43 +83,41 @@ impl From<ClientMessageEnum> for nostr::ClientMessage {
             ClientMessageEnum::Count {
                 subscription_id,
                 filter,
-            } => Self::Count {
-                subscription_id: SubscriptionId::new(subscription_id),
-                filter: Box::new(filter.as_ref().deref().clone()),
-            },
+            } => Self::count(
+                SubscriptionId::new(subscription_id),
+                filter.as_ref().deref().clone(),
+            ),
             ClientMessageEnum::Close { subscription_id } => {
-                Self::Close(SubscriptionId::new(subscription_id))
-            }
-            ClientMessageEnum::Auth { event } => {
-                Self::Auth(Box::new(event.as_ref().deref().clone()))
+                Self::close(SubscriptionId::new(subscription_id))
             }
+            ClientMessageEnum::Auth { event } => Self::auth(event.as_ref().deref().clone()),
             ClientMessageEnum::NegOpen {
                 subscription_id,
                 filter,
                 id_size,
                 initial_message,
             } => Self::NegOpen {
-                subscription_id: SubscriptionId::new(subscription_id),
-                filter: Box::new(filter.as_ref().deref().clone()),
+                subscription_id: Cow::Owned(SubscriptionId::new(subscription_id)),
+                filter: Cow::Owned(filter.as_ref().deref().clone()),
                 id_size,
-                initial_message,
+                initial_message: Cow::Owned(initial_message),
             },
             ClientMessageEnum::NegMsg {
                 subscription_id,
                 message,
             } => Self::NegMsg {
-                subscription_id: SubscriptionId::new(subscription_id),
-                message,
+                subscription_id: Cow::Owned(SubscriptionId::new(subscription_id)),
+                message: Cow::Owned(message),
             },
             ClientMessageEnum::NegClose { subscription_id } => Self::NegClose {
-                subscription_id: SubscriptionId::new(subscription_id),
+                subscription_id: Cow::Owned(SubscriptionId::new(subscription_id)),
             },
         }
     }
 }
 
-impl From<nostr::ClientMessage> for ClientMessageEnum {
-    fn from(value: nostr::ClientMessage) -> Self {
+impl<'a> From<nostr::ClientMessage<'a>> for ClientMessageEnum {
+    fn from(value: nostr::ClientMessage<'a>) -> Self {
         match value {
             nostr::ClientMessage::Event(event) => Self::EventMsg {
                 event: Arc::new(event.as_ref().to_owned().into()),
@@ -130,7 +127,7 @@ impl From<nostr::ClientMessage> for ClientMessageEnum {
                 filter,
             } => Self::Req {
                 subscription_id: subscription_id.to_string(),
-                filter: Arc::new((*filter).into()),
+                filter: Arc::new(filter.into_owned().into()),
             },
             nostr::ClientMessage::ReqMultiFilter {
                 subscription_id,
@@ -144,7 +141,7 @@ impl From<nostr::ClientMessage> for ClientMessageEnum {
                 filter,
             } => Self::Count {
                 subscription_id: subscription_id.to_string(),
-                filter: Arc::new((*filter).into()),
+                filter: Arc::new(filter.into_owned().into()),
             },
             nostr::ClientMessage::Close(subscription_id) => Self::Close {
                 subscription_id: subscription_id.to_string(),
@@ -161,14 +158,14 @@ impl From<nostr::ClientMessage> for ClientMessageEnum {
                 subscription_id: subscription_id.to_string(),
                 filter: Arc::new(filter.as_ref().to_owned().into()),
                 id_size,
-                initial_message,
+                initial_message: initial_message.into_owned(),
             },
             nostr::ClientMessage::NegMsg {
                 subscription_id,
                 message,
             } => Self::NegMsg {
                 subscription_id: subscription_id.to_string(),
-                message,
+                message: message.into_owned(),
             },
             nostr::ClientMessage::NegClose { subscription_id } => Self::NegClose {
                 subscription_id: subscription_id.to_string(),
@@ -180,19 +177,19 @@ impl From<nostr::ClientMessage> for ClientMessageEnum {
 #[derive(Debug, PartialEq, Eq, Object)]
 #[uniffi::export(Debug, Eq)]
 pub struct ClientMessage {
-    inner: nostr::ClientMessage,
+    inner: nostr::ClientMessage<'static>,
 }
 
 impl Deref for ClientMessage {
-    type Target = nostr::ClientMessage;
+    type Target = nostr::ClientMessage<'static>;
 
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
 
-impl From<nostr::ClientMessage> for ClientMessage {
-    fn from(inner: nostr::ClientMessage) -> Self {
+impl From<nostr::ClientMessage<'static>> for ClientMessage {
+    fn from(inner: nostr::ClientMessage<'static>) -> Self {
         Self { inner }
     }
 }

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

@@ -3,6 +3,7 @@
 // Distributed under the MIT software license
 
 use core::ops::Deref;
+use std::borrow::Cow;
 use std::sync::Arc;
 
 use nostr::{JsonUtil, SubscriptionId};
@@ -49,8 +50,8 @@ pub enum RelayMessageEnum {
     },
 }
 
-impl From<nostr::RelayMessage> for RelayMessageEnum {
-    fn from(value: nostr::RelayMessage) -> Self {
+impl<'a> From<nostr::RelayMessage<'a>> for RelayMessageEnum {
+    fn from(value: nostr::RelayMessage<'a>) -> Self {
         match value {
             nostr::RelayMessage::Event {
                 subscription_id,
@@ -64,9 +65,11 @@ impl From<nostr::RelayMessage> for RelayMessageEnum {
                 message,
             } => Self::Closed {
                 subscription_id: subscription_id.to_string(),
-                message,
+                message: message.into_owned(),
+            },
+            nostr::RelayMessage::Notice(message) => Self::Notice {
+                message: message.into_owned(),
             },
-            nostr::RelayMessage::Notice(message) => Self::Notice { message },
             nostr::RelayMessage::EndOfStoredEvents(sub_id) => Self::EndOfStoredEvents {
                 subscription_id: sub_id.to_string(),
             },
@@ -77,9 +80,11 @@ impl From<nostr::RelayMessage> for RelayMessageEnum {
             } => Self::Ok {
                 event_id: Arc::new(event_id.into()),
                 status,
-                message,
+                message: message.into_owned(),
+            },
+            nostr::RelayMessage::Auth { challenge } => Self::Auth {
+                challenge: challenge.into_owned(),
             },
-            nostr::RelayMessage::Auth { challenge } => Self::Auth { challenge },
             nostr::RelayMessage::Count {
                 subscription_id,
                 count,
@@ -92,70 +97,60 @@ impl From<nostr::RelayMessage> for RelayMessageEnum {
                 message,
             } => Self::NegMsg {
                 subscription_id: subscription_id.to_string(),
-                message,
+                message: message.into_owned(),
             },
             nostr::RelayMessage::NegErr {
                 subscription_id,
                 message,
             } => Self::NegErr {
                 subscription_id: subscription_id.to_string(),
-                message,
+                message: message.into_owned(),
             },
         }
     }
 }
 
-impl From<RelayMessageEnum> for nostr::RelayMessage {
+impl From<RelayMessageEnum> for nostr::RelayMessage<'static> {
     fn from(value: RelayMessageEnum) -> Self {
         match value {
             RelayMessageEnum::EventMsg {
                 subscription_id,
                 event,
-            } => Self::Event {
-                subscription_id: SubscriptionId::new(subscription_id),
-                event: Box::new(event.as_ref().deref().clone()),
-            },
+            } => Self::event(
+                SubscriptionId::new(subscription_id),
+                event.as_ref().deref().clone(),
+            ),
             RelayMessageEnum::Closed {
                 subscription_id,
                 message,
-            } => Self::Closed {
-                subscription_id: SubscriptionId::new(subscription_id),
-                message,
-            },
-            RelayMessageEnum::Notice { message } => Self::Notice(message),
+            } => Self::closed(SubscriptionId::new(subscription_id), message),
+            RelayMessageEnum::Notice { message } => Self::notice(message),
             RelayMessageEnum::EndOfStoredEvents { subscription_id } => {
                 Self::eose(SubscriptionId::new(subscription_id))
             }
             RelayMessageEnum::Ok {
                 event_id,
                 status,
                 message,
-            } => Self::Ok {
-                event_id: **event_id,
-                status,
-                message,
-            },
-            RelayMessageEnum::Auth { challenge } => Self::Auth { challenge },
+            } => Self::ok(**event_id, status, message),
+            RelayMessageEnum::Auth { challenge } => Self::auth(challenge),
             RelayMessageEnum::Count {
                 subscription_id,
                 count,
-            } => Self::Count {
-                subscription_id: SubscriptionId::new(subscription_id),
-                count: count as usize,
-            },
+            } => Self::count(SubscriptionId::new(subscription_id), count as usize),
             RelayMessageEnum::NegMsg {
                 subscription_id,
                 message,
             } => Self::NegMsg {
-                subscription_id: SubscriptionId::new(subscription_id),
-                message,
+                subscription_id: Cow::Owned(SubscriptionId::new(subscription_id)),
+                message: Cow::Owned(message),
             },
             RelayMessageEnum::NegErr {
                 subscription_id,
                 message,
             } => Self::NegErr {
-                subscription_id: SubscriptionId::new(subscription_id),
-                message,
+                subscription_id: Cow::Owned(SubscriptionId::new(subscription_id)),
+                message: Cow::Owned(message),
             },
         }
     }
@@ -164,11 +159,11 @@ impl From<RelayMessageEnum> for nostr::RelayMessage {
 #[derive(Debug, PartialEq, Eq, Hash, Object)]
 #[uniffi::export(Debug, Eq, Hash)]
 pub struct RelayMessage {
-    inner: nostr::RelayMessage,
+    inner: nostr::RelayMessage<'static>,
 }
 
-impl From<nostr::RelayMessage> for RelayMessage {
-    fn from(inner: nostr::RelayMessage) -> Self {
+impl From<nostr::RelayMessage<'static>> for RelayMessage {
+    fn from(inner: nostr::RelayMessage<'static>) -> Self {
         Self { inner }
     }
 }

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

@@ -278,7 +278,7 @@ impl Relay {
 
     /// Unsubscribe
     pub async fn unsubscribe(&self, id: String) -> Result<()> {
-        Ok(self.inner.unsubscribe(SubscriptionId::new(id)).await?)
+        Ok(self.inner.unsubscribe(&SubscriptionId::new(id)).await?)
     }
 
     /// Unsubscribe from all subscriptions

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

@@ -342,7 +342,7 @@ impl JsClient {
     /// Unsubscribe
     pub async fn unsubscribe(&self, subscription_id: &str) {
         self.inner
-            .unsubscribe(SubscriptionId::new(subscription_id))
+            .unsubscribe(&SubscriptionId::new(subscription_id))
             .await;
     }
 

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

@@ -13,19 +13,19 @@ use crate::protocol::filter::JsFilter;
 
 #[wasm_bindgen(js_name = ClientMessage)]
 pub struct JsClientMessage {
-    inner: ClientMessage,
+    inner: ClientMessage<'static>,
 }
 
 impl Deref for JsClientMessage {
-    type Target = ClientMessage;
+    type Target = ClientMessage<'static>;
 
     fn deref(&self) -> &Self::Target {
         &self.inner
     }
 }
 
-impl From<ClientMessage> for JsClientMessage {
-    fn from(inner: ClientMessage) -> Self {
+impl From<ClientMessage<'static>> for JsClientMessage {
+    fn from(inner: ClientMessage<'static>) -> Self {
         Self { inner }
     }
 }

bindings/nostr-sdk-js/src/protocol/message/relay.rs

@@ -12,11 +12,11 @@ use crate::protocol::event::{JsEvent, JsEventId};
 
 #[wasm_bindgen(js_name = RelayMessage)]
 pub struct JsRelayMessage {
-    inner: RelayMessage,
+    inner: RelayMessage<'static>,
 }
 
-impl From<RelayMessage> for JsRelayMessage {
-    fn from(inner: RelayMessage) -> Self {
+impl From<RelayMessage<'static>> for JsRelayMessage {
+    fn from(inner: RelayMessage<'static>) -> Self {
         Self { inner }
     }
 }

bindings/nostr-sdk-js/src/relay/mod.rs

@@ -239,7 +239,7 @@ impl JsRelay {
     /// Unsubscribe
     pub async fn unsubscribe(&self, id: String) -> Result<()> {
         self.inner
-            .unsubscribe(SubscriptionId::new(id))
+            .unsubscribe(&SubscriptionId::new(id))
             .await
             .map_err(into_err)
     }