sdk: update the code to use nostr-gossip crate

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

Author: yukibtc

Cargo.lock

@@ -14,6 +14,7 @@ The project is split up into several crates:
     - [**nostr-ndb**](./database/nostr-ndb): [nostrdb](https://github.com/damus-io/nostrdb) storage backend
     - [**nostr-indexeddb**](./database/nostr-indexeddb): IndexedDB storage backend
 - [**nostr-gossip**](./gossip/nostr-gossip): Gossip traits
+    - [**nostr-gossip-sqlite**](./gossip/nostr-gossip-sqlite): SQLite storage for gossip
 - Remote File Storage implementations:
     - [**nostr-blossom**](./rfs/nostr-blossom): A library for interacting with the Blossom protocol
     - [**nostr-http-file-storage**](./rfs/nostr-http-file-storage): HTTP File Storage client (NIP-96)

README.md

@@ -35,13 +35,16 @@ nip98 = ["nostr/nip98"]
 async-utility.workspace = true
 nostr = { workspace = true, features = ["std"] }
 nostr-database.workspace = true
+nostr-gossip.workspace = true
 nostr-relay-pool.workspace = true
 tokio = { workspace = true, features = ["sync"] }
 
 [dev-dependencies]
 nostr-connect.workspace = true
 nostr-lmdb.workspace = true
 nostr-ndb.workspace = true
+nostr-gossip-sqlite.workspace = true
+tempfile.workspace = true
 tokio = { workspace = true, features = ["macros"] }
 tracing = { workspace = true, features = ["std"] }
 tracing-subscriber = { workspace = true, features = ["env-filter"] }

crates/nostr-sdk/Cargo.toml

@@ -4,15 +4,16 @@
 
 use std::time::Duration;
 
+use nostr_gossip_sqlite::prelude::*;
 use nostr_sdk::prelude::*;
 
 #[tokio::main]
 async fn main() -> Result<()> {
     tracing_subscriber::fmt::init();
 
     let keys = Keys::parse("nsec1ufnus6pju578ste3v90xd5m2decpuzpql2295m3sknqcjzyys9ls0qlc85")?;
-    let opts = ClientOptions::new().gossip(true);
-    let client = Client::builder().signer(keys).opts(opts).build();
+    let gossip = NostrGossipSqlite::open("db/gossip.db").await?;
+    let client = Client::builder().signer(keys).gossip(gossip).build();
 
     client.add_discovery_relay("wss://relay.damus.io").await?;
     client.add_discovery_relay("wss://purplepag.es").await?;

crates/nostr-sdk/examples/gossip.rs

@@ -9,6 +9,7 @@ use std::sync::Arc;
 use nostr::signer::{IntoNostrSigner, NostrSigner};
 use nostr_database::memory::MemoryDatabase;
 use nostr_database::{IntoNostrDatabase, NostrDatabase};
+use nostr_gossip::NostrGossip;
 use nostr_relay_pool::monitor::Monitor;
 use nostr_relay_pool::policy::AdmitPolicy;
 use nostr_relay_pool::transport::websocket::{
@@ -29,6 +30,8 @@ pub struct ClientBuilder {
     pub admit_policy: Option<Arc<dyn AdmitPolicy>>,
     /// Database
     pub database: Arc<dyn NostrDatabase>,
+    /// Gossip
+    pub gossip: Option<Arc<dyn NostrGossip>>,
     /// Relay monitor
     pub monitor: Option<Monitor>,
     /// Client options
@@ -42,6 +45,7 @@ impl Default for ClientBuilder {
             websocket_transport: Arc::new(DefaultWebsocketTransport),
             admit_policy: None,
             database: Arc::new(MemoryDatabase::default()),
+            gossip: None,
             monitor: None,
             opts: ClientOptions::default(),
         }
@@ -106,6 +110,16 @@ impl ClientBuilder {
         self
     }
 
+    /// Set a gossip database
+    #[inline]
+    pub fn gossip<T>(mut self, gossip: T) -> Self
+    where
+        T: NostrGossip + 'static,
+    {
+        self.gossip = Some(Arc::new(gossip));
+        self
+    }
+
     /// Set monitor
     #[inline]
     pub fn monitor(mut self, monitor: Monitor) -> Self {

crates/nostr-sdk/src/client/builder.rs

@@ -7,6 +7,7 @@ use std::fmt;
 use nostr::prelude::*;
 use nostr::serde_json;
 use nostr_database::prelude::*;
+use nostr_gossip::error::GossipError;
 use nostr_relay_pool::__private::SharedStateError;
 use nostr_relay_pool::prelude::*;
 
@@ -21,6 +22,8 @@ pub enum Error {
     Database(DatabaseError),
     /// Signer error
     Signer(SignerError),
+    /// Gossip error
+    Gossip(GossipError),
     /// [`EventBuilder`] error
     EventBuilder(event::builder::Error),
     /// Json error
@@ -45,6 +48,7 @@ impl fmt::Display for Error {
             Self::RelayPool(e) => e.fmt(f),
             Self::Database(e) => e.fmt(f),
             Self::Signer(e) => e.fmt(f),
+            Self::Gossip(e) => e.fmt(f),
             Self::EventBuilder(e) => e.fmt(f),
             Self::Json(e) => e.fmt(f),
             Self::SharedState(e) => e.fmt(f),
@@ -82,6 +86,12 @@ impl From<SignerError> for Error {
     }
 }
 
+impl From<GossipError> for Error {
+    fn from(e: GossipError) -> Self {
+        Self::Gossip(e)
+    }
+}
+
 impl From<event::builder::Error> for Error {
     fn from(e: event::builder::Error) -> Self {
         Self::EventBuilder(e)

crates/nostr-sdk/src/client/error.rs

@@ -0,0 +1,49 @@
+use std::sync::Arc;
+
+use nostr::prelude::BoxedFuture;
+use nostr::{Event, RelayUrl, SubscriptionId};
+use nostr_gossip::NostrGossip;
+use nostr_relay_pool::policy::{AdmitPolicy, AdmitStatus, PolicyError};
+
+#[derive(Debug)]
+pub(crate) struct AdmissionPolicyMiddleware {
+    pub(crate) gossip: Option<Arc<dyn NostrGossip>>,
+    pub(crate) external_policy: Option<Arc<dyn AdmitPolicy>>,
+}
+
+impl AdmitPolicy for AdmissionPolicyMiddleware {
+    fn admit_connection<'a>(
+        &'a self,
+        relay_url: &'a RelayUrl,
+    ) -> BoxedFuture<'a, Result<AdmitStatus, PolicyError>> {
+        Box::pin(async move {
+            match &self.external_policy {
+                Some(policy) => policy.admit_connection(relay_url).await,
+                None => Ok(AdmitStatus::Success),
+            }
+        })
+    }
+
+    fn admit_event<'a>(
+        &'a self,
+        relay_url: &'a RelayUrl,
+        subscription_id: &'a SubscriptionId,
+        event: &'a Event,
+    ) -> BoxedFuture<'a, Result<AdmitStatus, PolicyError>> {
+        Box::pin(async move {
+            // Process event in gossip
+            if let Some(gossip) = &self.gossip {
+                gossip
+                    .process(event, Some(relay_url))
+                    .await
+                    .map_err(PolicyError::backend)?;
+            }
+
+            // Check if event is allowed by external policy
+            match &self.external_policy {
+                Some(policy) => policy.admit_event(relay_url, subscription_id, event).await,
+                None => Ok(AdmitStatus::Success),
+            }
+        })
+    }
+}