Refactoring

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

Author: yukibtc

crates/nostr-sdk/examples/bot.rs

@@ -2,16 +2,18 @@
 // Copyright (c) 2023-2025 Rust Nostr Developers
 // Distributed under the MIT software license
 
+use nostr_gossip_sqlite::prelude::*;
 use nostr_sdk::prelude::*;
 
 #[tokio::main]
 async fn main() -> Result<()> {
     tracing_subscriber::fmt::init();
 
     let keys = Keys::parse("nsec12kcgs78l06p30jz7z7h3n2x2cy99nw2z6zspjdp7qc206887mwvs95lnkx")?;
+    let gossip = NostrGossipSqlite::open("db/gossip.db").await?;
     let client = Client::builder()
         .signer(keys.clone())
-        .opts(ClientOptions::new().gossip(true))
+        .gossip(gossip)
         .build();
 
     println!("Bot public key: {}", keys.public_key().to_bech32()?);

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

@@ -13,7 +13,7 @@ use std::time::Duration;
 use async_utility::futures_util::stream::BoxStream;
 use nostr::prelude::*;
 use nostr_database::prelude::*;
-use nostr_gossip::{BestRelaySelection, GossipListKind, NostrGossip};
+use nostr_gossip::{BestRelaySelection, GossipListKind, GossipPublicKeyStatus, NostrGossip};
 use nostr_relay_pool::prelude::*;
 use tokio::sync::broadcast;
 
@@ -74,7 +74,6 @@ impl Client {
     /// use nostr_sdk::prelude::*;
     ///
     /// let signer = Keys::generate();
-    /// let opts = ClientOptions::default().gossip(true);
     /// let client: Client = Client::builder().signer(signer).opts(opts).build();
     /// ```
     #[inline]
@@ -1341,14 +1340,14 @@ impl Client {
     {
         tracing::debug!(kind = ?gossip_kind, "Start checking and updating gossip data.");
 
-        let mut outdated_public_keys: HashSet<PublicKey> = HashSet::new();
+        let mut outdated_public_keys: HashMap<PublicKey, Timestamp> = HashMap::new();
 
         for public_key in public_keys.into_iter() {
             // Get the public key status
             let status = gossip.status(&public_key, gossip_kind).await?;
 
-            if status.is_outdated() {
-                outdated_public_keys.insert(public_key);
+            if let GossipPublicKeyStatus::Outdated { created_at } = status {
+                outdated_public_keys.insert(public_key, created_at.unwrap_or_default());
             }
         }
 
@@ -1366,7 +1365,7 @@ impl Client {
 
         // Compose database filter
         let db_filter: Filter = Filter::default()
-            .authors(outdated_public_keys.clone())
+            .authors(outdated_public_keys.keys().copied())
             .kind(kind);
 
         tracing::debug!(filter = ?db_filter, "Querying database for outdated gossip data.");
@@ -1391,32 +1390,29 @@ impl Client {
         let mut filters: Vec<Filter> = Vec::with_capacity(stored_events.len());
 
         // Keep track of the missing public keys
-        let mut missing_public_keys: HashSet<PublicKey> = outdated_public_keys;
+        let mut missing_public_keys: HashSet<PublicKey> =
+            outdated_public_keys.keys().copied().collect();
 
         // Try to fetch from relays only the newer events (last created_at + 1)
-        for event in stored_events.iter() {
-            let author = event.pubkey;
-            let created_at = event.created_at;
-
+        for (author, created_at) in outdated_public_keys.iter() {
             // Construct filter
             let filter: Filter = Filter::new()
-                .author(author)
+                .author(*author)
                 .kind(kind)
-                .since(created_at + Duration::from_secs(1))
+                .since(*created_at + Duration::from_secs(1))
                 .limit(1);
 
             filters.push(filter);
 
             // Remove from the missing set
-            missing_public_keys.remove(&event.pubkey);
+            missing_public_keys.remove(author);
         }
 
         tracing::debug!(filters = ?filters, "Fetching outdated gossip data from relays.");
 
         // Fetch the events
         // NOTE: the received events are automatically processed
-        self
-            .pool
+        self.pool
             .fetch_events_from(
                 urls.clone(),
                 filters,
@@ -1426,11 +1422,9 @@ impl Client {
             .await?;
 
         // Update the last check for the stored public keys
-        for pk in stored_events.iter().map(|e| e.pubkey) {
+        for pk in outdated_public_keys.keys() {
             // Update the last check for this public key
-            gossip
-                .update_fetch_attempt(&pk, gossip_kind)
-                .await?;
+            gossip.update_fetch_attempt(pk, gossip_kind).await?;
         }
 
         // Get the missing events

gossip/nostr-gossip-sqlite/doc/database.md

@@ -5,8 +5,12 @@
 - `id`: Public Key ID
 - `public_key`: Public Key 32-byte array
 
+## Lists table
+
+- `event_created_at`: UNIX timestamp
+- `last_checked_at`: UNIX timestamp of the last check
+
 ## Relays table
 
 - `id`: Relay ID
-
-TODO
+- `url`: Relay URL

gossip/nostr-gossip-sqlite/migrations/001_init.sql

@@ -3,13 +3,23 @@ PRAGMA foreign_keys = ON;
 CREATE TABLE public_keys(
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     public_key BLOB NOT NULL UNIQUE,
-    last_nip17_update BIGINT DEFAULT NULL,
-    last_nip65_update BIGINT DEFAULT NULL,
     CHECK (length(public_key) = 32)
 );
 
 CREATE INDEX idx_public_keys_public_key ON public_keys(public_key);
 
+CREATE TABLE lists(
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    public_key_id INTEGER NOT NULL,
+    event_kind INTEGER NOT NULL,
+    event_created_at BIGINT DEFAULT NULL,
+    last_checked_at BIGINT DEFAULT NULL,
+    UNIQUE(public_key_id, event_kind),
+    FOREIGN KEY (public_key_id) REFERENCES public_keys(id) ON DELETE CASCADE
+);
+
+CREATE INDEX idx_lists_pub_kind ON lists(public_key_id, event_kind);
+
 CREATE TABLE relays(
     id INTEGER PRIMARY KEY AUTOINCREMENT,
     url TEXT NOT NULL UNIQUE

gossip/nostr-gossip-sqlite/src/constant.rs

@@ -4,4 +4,8 @@
 
 use std::time::Duration;
 
+use crate::flags::Flags;
+
 pub(super) const PUBKEY_METADATA_OUTDATED_AFTER: Duration = Duration::from_secs(60 * 60); // 60 min
+
+pub(super) const READ_WRITE_FLAGS: Flags = Flags::read_write();

gossip/nostr-gossip-sqlite/src/flags.rs

@@ -1,7 +1,12 @@
+use sqlx::encode::IsNull;
+use sqlx::error::BoxDynError;
+use sqlx::sqlite::SqliteTypeInfo;
+use sqlx::{Database, Encode, Sqlite, Type};
+
 pub(crate) struct Flags(u16);
 
 impl Flags {
-    //pub(crate) const NONE: Self = Self(0); // 0
+    pub(crate) const NONE: Self = Self(0); // 0
 
     pub(crate) const READ: Self = Self(1 << 0); // 1
 
@@ -13,11 +18,19 @@ impl Flags {
 
     pub(crate) const RECEIVED: Self = Self(1 << 4); // 16
 
-    // /// New empty flags.
-    // #[inline]
-    // pub(crate) const fn new() -> Self {
-    //     Self::NONE
-    // }
+    /// New empty flags.
+    #[inline]
+    pub(crate) const fn new() -> Self {
+        Self::NONE
+    }
+
+    /// New flags with [`READ`] and [`WRITE`].
+    pub(crate) const fn read_write() -> Self {
+        let mut flags: Self = Self::new();
+        flags.add(Self::READ);
+        flags.add(Self::WRITE);
+        flags
+    }
 
     /// Add flag.
     #[inline]
@@ -32,7 +45,23 @@ impl Flags {
     // }
 
     #[inline]
-    pub(crate) const fn as_u16(&self) -> u16 {
+    const fn as_u16(&self) -> u16 {
         self.0
     }
 }
+
+impl Type<Sqlite> for Flags {
+    fn type_info() -> SqliteTypeInfo {
+        <u16 as Type<Sqlite>>::type_info()
+    }
+}
+
+impl<'a> Encode<'a, Sqlite> for Flags {
+    fn encode_by_ref(
+        &self,
+        buf: &mut <Sqlite as Database>::ArgumentBuffer<'a>,
+    ) -> Result<IsNull, BoxDynError> {
+        let val: u16 = self.as_u16();
+        <u16 as Encode<Sqlite>>::encode_by_ref(&val, buf)
+    }
+}

gossip/nostr-gossip-sqlite/src/model.rs

@@ -1,7 +1,7 @@
 use sqlx::FromRow;
 
 #[derive(FromRow)]
-pub(super) struct PublicKeyRow {
-    pub(super) last_nip17_update: Option<i64>,
-    pub(super) last_nip65_update: Option<i64>,
+pub(super) struct ListRow {
+    pub(super) event_created_at: Option<i64>,
+    pub(super) last_checked_at: Option<i64>,
 }