add proof of concept for sending orders and replying to them

Author: ikripaka

Cargo.toml

@@ -18,24 +18,17 @@ anyhow = { version = "1.0.100" }
 clap = { version = "4.5.49", features = ["derive"] }
 config = { version = "0.15.16", default-features = true }
 dotenvy = { version = "0.15" }
+futures-util = { version = "0.3.31" }
 global_utils = { path = "./crates/global_utils" }
-hex = { version = "0.4.3" }
-itertools = { version = "0.14.0" }
-reqwest = { version = "0.12.23", features = ["blocking", "json"] }
-ring = { version = "0.17.14" }
+nostr = { version = "0.43.1", features = ["std"] }
+nostr-sdk = { version = "0.43.0" }
 serde = { version = "1.0.228", features = ["derive"] }
 serde_json = { version = "1.0.145" }
-sha2 = { version = "0.10.9", features = ["compress"] }
-simplicity-lang = { version = "0.5.0" }
-simplicityhl = { version = "0.2.0", features = ["serde"] }
-simplicityhl-core = { version = "0.1.1" }
-state_change_types = { path = "./crates/state_change_types" }
 thiserror = { version = "2.0.17" }
+tokio = { version = "1.48.0", features = ["macros", "test-util"] }
 tracing = { version = "0.1.41" }
 tracing-appender = { version = "0.2.3" }
 tracing-subscriber = { version = "0.3.19", features = ["env-filter"] }
-nostr = { version = "0.43.1" }
-tokio-tungstenite = { version = "0.28.0", features = ["native-tls"] }
-futures-util = "0.3.31"
-tokio = {version =  "1.48.0", features = ["full"] }
-
+url = { version = "2.5.7" }
+nostr_relay_connector = { path = "./crates/nostr_relay_connector"}
+nostr_relay_processor = { path = "./crates/nostr_relay_processor"}

crates/global_utils/src/logger.rs

@@ -17,7 +17,7 @@ pub fn init_logger() -> LoggerGuard {
         .with_writer(std_out_writer)
         .with_target(false)
         .with_level(true)
-        .with_filter(EnvFilter::try_from_default_env().unwrap_or(EnvFilter::new("TRACE")));
+        .with_filter(EnvFilter::try_from_default_env().unwrap_or(EnvFilter::new("DEBUG")));
 
     let std_err_layer = fmt::layer()
         .with_writer(std_err_writer)

crates/nostr_relay_connector/Cargo.toml

@@ -0,0 +1,19 @@
+[package]
+name = "nostr_relay_connector"
+version.workspace = true
+edition.workspace = true
+rust-version.workspace = true
+authors.workspace = true
+readme.workspace = true
+
+[dependencies]
+tokio = { workspace = true, features = ["time"] }
+futures-util = {  workspace = true  }
+serde_json = {  workspace = true  }
+anyhow = {  workspace = true  }
+url = {  workspace = true  }
+nostr = { workspace = true }
+global_utils = { workspace = true }
+nostr-sdk = { workspace = true }
+thiserror = { workspace = true }
+tracing = { workspace = true }

crates/nostr_relay_connector/src/error.rs

@@ -0,0 +1,11 @@
+#[derive(Debug, thiserror::Error)]
+pub enum RelayClientError {
+    #[error("Failed to convert custom url to RelayURL, err: {err_msg}")]
+    FailedToConvertRelayUrl { err_msg: String },
+    #[error("An error occurred in Nostr Client, err: {0}")]
+    NostrClientFailure(#[from] nostr_sdk::client::Error),
+    #[error("Relay Client requires for operation signature, add key to the Client")]
+    MissingSigner,
+}
+
+pub type Result<T> = std::result::Result<T, RelayClientError>;

crates/nostr_relay_connector/src/lib.rs

@@ -0,0 +1,2 @@
+pub mod error;
+pub mod relay_client;

crates/nostr_relay_connector/src/relay_client.rs

@@ -0,0 +1,109 @@
+use crate::error::RelayClientError;
+use nostr::prelude::*;
+use nostr_sdk::pool::Output;
+use nostr_sdk::prelude::Events;
+use nostr_sdk::{Client, Relay, SubscribeAutoCloseOptions};
+use std::collections::HashMap;
+use std::fmt::Debug;
+use std::sync::Arc;
+use std::time::Duration;
+use tracing::instrument;
+
+#[derive(Debug)]
+pub struct RelayClient {
+    client: Client,
+    timeout: Duration,
+}
+
+#[derive(Debug)]
+pub struct ClientConfig {
+    pub timeout: Duration,
+}
+
+impl RelayClient {
+    #[instrument(skip_all, level = "debug", err)]
+    pub async fn connect(
+        relay_urls: impl IntoIterator<Item = impl TryIntoUrl>,
+        keys: Option<impl IntoNostrSigner>,
+        client_config: ClientConfig,
+    ) -> crate::error::Result<Self> {
+        tracing::debug!(client_config = ?client_config, "Connecting to Nostr Relay Client(s)");
+        let client = match keys {
+            None => Client::default(),
+            Some(keys) => {
+                let client = Client::new(keys);
+                client.automatic_authentication(true);
+                client
+            }
+        };
+        for url in relay_urls {
+            let url = url
+                .try_into_url()
+                .map_err(|err| RelayClientError::FailedToConvertRelayUrl {
+                    err_msg: format!("{:?}", err),
+                })?;
+            client.add_relay(url).await?;
+        }
+        client.connect().await;
+        Ok(Self {
+            client,
+            timeout: client_config.timeout,
+        })
+    }
+
+    #[instrument(skip_all, level = "debug", ret)]
+    pub async fn req_and_wait(&self, filter: Filter) -> crate::error::Result<Events> {
+        tracing::debug!(filter = ?filter, "Requesting events with filter");
+        let events = self.client.fetch_combined_events(filter, self.timeout).await?;
+        Ok(events)
+    }
+
+    #[instrument(skip_all, level = "debug", ret)]
+    pub async fn get_signer(&self) -> crate::error::Result<Arc<dyn NostrSigner>> {
+        if !self.client.has_signer().await {
+            return Err(RelayClientError::MissingSigner);
+        }
+        Ok(self.client.signer().await?)
+    }
+
+    #[instrument(skip_all, level = "debug", ret)]
+    pub async fn get_relays(&self) -> HashMap<RelayUrl, Relay> {
+        self.client.relays().await
+    }
+
+    #[instrument(skip_all, level = "debug", ret)]
+    pub async fn publish_event(&self, event: &Event) -> crate::error::Result<EventId> {
+        if !self.client.has_signer().await {
+            return Err(RelayClientError::MissingSigner);
+        }
+        let event_id = self.client.send_event(event).await?;
+        let event_id = Self::handle_relay_output(event_id)?;
+        Ok(event_id)
+    }
+
+    #[instrument(skip(self), level = "debug")]
+    pub async fn subscribe(
+        &self,
+        filter: Filter,
+        opts: Option<SubscribeAutoCloseOptions>,
+    ) -> crate::error::Result<SubscriptionId> {
+        Ok(self.client.subscribe(filter, opts).await?.val)
+    }
+
+    #[instrument(skip(self), level = "debug")]
+    pub async fn unsubscribe(&self, subscription_id: &SubscriptionId) {
+        self.client.unsubscribe(subscription_id).await;
+    }
+
+    #[instrument(skip_all, level = "debug", ret)]
+    pub async fn disconnect(&self) -> crate::error::Result<()> {
+        self.client.disconnect().await;
+        Ok(())
+    }
+
+    #[instrument(level = "debug")]
+    fn handle_relay_output<T: Debug>(output: Output<T>) -> crate::error::Result<T> {
+        tracing::trace!(output = ?output, "Handling Relay output");
+        Ok(output.val)
+    }
+}

crates/nostr_relay_processor/Cargo.toml

@@ -8,3 +8,10 @@ readme.workspace = true
 
 [dependencies]
 anyhow = { workspace = true }
+tokio = { workspace = true }
+global_utils = { workspace = true }
+nostr-sdk = { workspace = true }
+nostr = { workspace = true }
+nostr_relay_connector = { workspace = true }
+tracing = { workspace = true }
+thiserror = { workspace = true }

crates/nostr_relay_processor/src/error.rs

@@ -0,0 +1,9 @@
+use nostr_relay_connector::error::RelayClientError;
+
+#[derive(thiserror::Error, Debug)]
+pub enum RelayProcessorError {
+    #[error(transparent)]
+    RelayClient(#[from] RelayClientError),
+}
+
+pub type Result<T> = std::result::Result<T, RelayProcessorError>;

crates/nostr_relay_processor/src/handlers.rs

@@ -1,3 +1,4 @@
 pub(crate) mod list_orders;
+pub(crate) mod order_replies;
 pub(crate) mod place_order;
 pub(crate) mod reply_order;

crates/nostr_relay_processor/src/handlers/list_orders.rs

@@ -1,4 +1,21 @@
-#[warn(unused)]
-pub fn handle() -> anyhow::Result<()> {
-    Ok(())
+use crate::types::{CustomKind, MakerOrderKind};
+use nostr::{Filter, NostrSigner};
+use nostr_relay_connector::relay_client::RelayClient;
+use nostr_sdk::prelude::Events;
+use std::collections::{BTreeMap, BTreeSet};
+
+pub async fn handle(client: &RelayClient) -> anyhow::Result<Events> {
+    let events = client
+        .req_and_wait(Filter {
+            ids: None,
+            authors: Some(BTreeSet::from([client.get_signer().await?.get_public_key().await?])),
+            kinds: Some(BTreeSet::from([MakerOrderKind::get_kind()])),
+            search: None,
+            since: None,
+            until: None,
+            limit: None,
+            generic_tags: BTreeMap::default(),
+        })
+        .await?;
+    Ok(events)
 }