relay connected!

enostr/src/client/message.rs

@@ -0,0 +1,52 @@
+use crate::{Event, Filter}
+
+/// Messages sent by clients, received by relays
+#[derive(Debug, Eq, PartialEq)]
+pub enum ClientMessage {
+    Event {
+        event: Event,
+    },
+    Req {
+        sub_id: String,
+        filters: Vec<Filter>,
+    },
+    Close {
+        sub_id: String,
+    },
+}
+
+impl ClientMessage {
+    pub fn event(ev: Event) -> Self {
+        ClientMessage::Event {ev}
+    }
+
+    pub fn req(sub_id: String, filters: Vec<Filter>) -> Self {
+        ClientMessage::Req { sub_id, filters }
+    }
+
+    pub fn close(sub_id: String) -> Self {
+        ClientMessage::Close { sub_id }
+    }
+
+    pub fn to_json(&self) -> String {
+        match self {
+            Self::Event { event } => json!(["EVENT", event]).to_string(),
+            Self::Req {
+                subscription_id,
+                filters,
+            } => {
+                let mut json = json!(["REQ", subscription_id]);
+                let mut filters = json!(filters);
+
+                if let Some(json) = json.as_array_mut() {
+                    if let Some(filters) = filters.as_array_mut() {
+                        json.append(filters);
+                    }
+                }
+
+                json.to_string()
+            }
+            Self::Close { subscription_id } => json!(["CLOSE", subscription_id]).to_string(),
+        }
+    }
+}

enostr/src/client/mod.rs

@@ -0,0 +1 @@
+mod message;

enostr/src/filter.rs

@@ -0,0 +1,23 @@
+use serde::{Deserialize, Serialize};
+
+#[derive(Serialize, Deserialize, Debug, Eq, PartialEq, Clone)]
+pub struct Filter {
+    #[serde(skip_serializing_if = "Option::is_none")]
+    ids: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    authors: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    kinds: Option<Vec<u64>>,
+    #[serde(rename = "#e")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    events: Option<Vec<String>>,
+    #[serde(rename = "#p")]
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pubkeys: Option<Vec<String>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    since: Option<u64>, // unix timestamp seconds
+    #[serde(skip_serializing_if = "Option::is_none")]
+    until: Option<u64>, // unix timestamp seconds
+    #[serde(skip_serializing_if = "Option::is_none")]
+    limit: Option<u16>,
+}

enostr/src/lib.rs

@@ -1,9 +1,11 @@
 mod error;
 mod event;
+mod filter;
 mod relay;
 
 pub use error::Error;
 pub use event::Event;
+pub use filter::Filter;
 pub use relay::pool::RelayPool;
 pub use relay::Relay;
 

enostr/src/relay/mod.rs

@@ -46,9 +46,9 @@ impl PartialEq for Relay {
 impl Eq for Relay {}
 
 impl Relay {
-    pub fn new(url: String) -> Result<Self> {
+    pub fn new(url: String, wakeup: impl Fn() + Send + Sync + 'static) -> Result<Self> {
         let status = RelayStatus::Connecting;
-        let (sender, receiver) = ewebsock::connect(&url)?;
+        let (sender, receiver) = ewebsock::connect_with_wakeup(&url, wakeup)?;
 
         Ok(Self {
             url,

enostr/src/relay/pool.rs

@@ -1,6 +1,7 @@
 use crate::relay::message::RelayEvent;
 use crate::relay::Relay;
 use crate::Result;
+use tracing::error;
 
 #[derive(Debug)]
 pub struct PoolMessage<'a> {
@@ -20,8 +21,8 @@ impl Default for RelayPool {
 
 impl RelayPool {
     // Constructs a new, empty RelayPool.
-    pub fn new(relays: Vec<Relay>) -> RelayPool {
-        RelayPool { relays: relays }
+    pub fn new() -> RelayPool {
+        RelayPool { relays: vec![] }
     }
 
     pub fn has(&self, url: &str) -> bool {
@@ -34,8 +35,12 @@ impl RelayPool {
     }
 
     // Adds a websocket url to the RelayPool.
-    pub fn add_url(&mut self, url: String) -> Result<()> {
-        let relay = Relay::new(url)?;
+    pub fn add_url(
+        &mut self,
+        url: String,
+        wakeup: impl Fn() + Send + Sync + 'static,
+    ) -> Result<()> {
+        let relay = Relay::new(url, wakeup)?;
 
         self.relays.push(relay);
 
@@ -45,12 +50,18 @@ impl RelayPool {
     pub fn try_recv(&self) -> Option<PoolMessage<'_>> {
         for relay in &self.relays {
             if let Some(msg) = relay.receiver.try_recv() {
-                if let Ok(event) = msg.try_into() {
-                    let pmsg = PoolMessage {
-                        event,
-                        relay: &relay.url,
-                    };
-                    return Some(pmsg);
+                match msg.try_into() {
+                    Ok(event) => {
+                        return Some(PoolMessage {
+                            event,
+                            relay: &relay.url,
+                        });
+                    }
+
+                    Err(e) => {
+                        error!("{:?}", e);
+                        continue;
+                    }
                 }
             }
         }