.

Cargo.lock

@@ -1912,7 +1912,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
 dependencies = [
  "libc",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -1976,6 +1976,18 @@ dependencies = [
  "zune-inflate",
 ]
 
+[[package]]
+name = "fallible-iterator"
+version = "0.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2acce4a10f12dc2fb14a218589d4f1f62ef011b2d0cc4b3cb1bba8e94da14649"
+
+[[package]]
+name = "fallible-streaming-iterator"
+version = "0.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7360491ce676a36bf9bb3c56c1aa791658183a54d2744120f27285738d90465a"
+
 [[package]]
 name = "fastrand"
 version = "1.9.0"
@@ -3589,6 +3601,17 @@ dependencies = [
  "redox_syscall 0.7.2",
 ]
 
+[[package]]
+name = "libsqlite3-sys"
+version = "0.36.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95b4103cffefa72eb8428cb6b47d6627161e51c2739fc5e3b734584157bc642a"
+dependencies = [
+ "cc",
+ "pkg-config",
+ "vcpkg",
+]
+
 [[package]]
 name = "linebender_resource_handle"
 version = "0.1.1"
@@ -4095,6 +4118,18 @@ dependencies = [
  "nostr",
 ]
 
+[[package]]
+name = "nostr-gossip-sqlite"
+version = "0.44.0"
+source = "git+https://github.com/rust-nostr/nostr#b1ac65997d05424ad7b888dbdb5214b8999924ff"
+dependencies = [
+ "async-utility",
+ "nostr",
+ "nostr-gossip",
+ "rusqlite",
+ "tokio",
+]
+
 [[package]]
 name = "nostr-lmdb"
 version = "0.44.0"
@@ -4144,7 +4179,7 @@ version = "0.50.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "7957b9740744892f114936ab4a57b3f487491bbeafaf8083688b16841a4240e5"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -4977,7 +5012,7 @@ dependencies = [
  "once_cell",
  "socket2",
  "tracing",
- "windows-sys 0.60.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -5396,6 +5431,30 @@ version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "6c20b6793b5c2fa6553b250154b78d6d0db37e72700ae35fad9387a46f487c97"
 
+[[package]]
+name = "rsqlite-vfs"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8a1f2315036ef6b1fbacd1972e8ee7688030b0a2121edfc2a6550febd41574d"
+dependencies = [
+ "hashbrown 0.16.1",
+ "thiserror 2.0.18",
+]
+
+[[package]]
+name = "rusqlite"
+version = "0.38.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1c93dd1c9683b438c392c492109cb702b8090b2bfc8fed6f6e4eb4523f17af3"
+dependencies = [
+ "bitflags 2.11.0",
+ "fallible-iterator",
+ "fallible-streaming-iterator",
+ "libsqlite3-sys",
+ "smallvec",
+ "sqlite-wasm-rs",
+]
+
 [[package]]
 name = "rust-embed"
 version = "8.11.0"
@@ -5491,7 +5550,7 @@ dependencies = [
  "errno",
  "libc",
  "linux-raw-sys 0.12.1",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -6117,6 +6176,18 @@ dependencies = [
  "bitflags 2.11.0",
 ]
 
+[[package]]
+name = "sqlite-wasm-rs"
+version = "0.5.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2f4206ed3a67690b9c29b77d728f6acc3ce78f16bf846d83c94f76400320181b"
+dependencies = [
+ "cc",
+ "js-sys",
+ "rsqlite-vfs",
+ "wasm-bindgen",
+]
+
 [[package]]
 name = "stable_deref_trait"
 version = "1.2.1"
@@ -6171,6 +6242,7 @@ dependencies = [
  "nostr",
  "nostr-blossom",
  "nostr-connect",
+ "nostr-gossip-sqlite",
  "nostr-lmdb",
  "nostr-sdk",
  "petname",
@@ -6471,7 +6543,7 @@ dependencies = [
  "getrandom 0.4.1",
  "once_cell",
  "rustix 1.1.4",
- "windows-sys 0.61.2",
+ "windows-sys 0.59.0",
 ]
 
 [[package]]
@@ -7287,6 +7359,12 @@ dependencies = [
  "sval_serde",
 ]
 
+[[package]]
+name = "vcpkg"
+version = "0.2.15"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accd4ea62f7bb7a82fe23066fb0957d48ef677f6eeb8215f372f52e48bb32426"
+
 [[package]]
 name = "version_check"
 version = "0.9.5"
@@ -7845,7 +7923,7 @@ version = "0.1.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c2a7b1c03c876122aa43f3020e6c3c3ee5c05081c9a00739faf7503aeba10d22"
 dependencies = [
- "windows-sys 0.61.2",
+ "windows-sys 0.48.0",
 ]
 
 [[package]]

Cargo.toml

@@ -23,6 +23,7 @@ reqwest_client = { git = "https://github.com/zed-industries/zed" }
 nostr-lmdb = { git = "https://github.com/rust-nostr/nostr" }
 nostr-connect = { git = "https://github.com/rust-nostr/nostr" }
 nostr-blossom = { git = "https://github.com/rust-nostr/nostr" }
+nostr-gossip-sqlite = { git = "https://github.com/rust-nostr/nostr" }
 nostr-sdk = { git = "https://github.com/rust-nostr/nostr" }
 nostr = { git = "https://github.com/rust-nostr/nostr", features = [ "nip96", "nip59", "nip49", "nip44" ] }
 

crates/chat/src/lib.rs

@@ -285,24 +285,17 @@ impl ChatRegistry {
 
         let signer = nostr.read(cx).signer();
         let public_key = signer.public_key().unwrap();
-        let write_relays = nostr.read(cx).write_relays(&public_key, cx);
 
         cx.background_spawn(async move {
-            let urls = write_relays.await;
-
             // Construct filter for inbox relays
             let filter = Filter::new()
                 .kind(Kind::InboxRelays)
                 .author(public_key)
                 .limit(1);
 
-            // Construct target for subscription
-            let target: HashMap<&RelayUrl, Filter> =
-                urls.iter().map(|relay| (relay, filter.clone())).collect();
-
             // Stream events from user's write relays
             let mut stream = client
-                .stream_events(target)
+                .stream_events(filter)
                 .timeout(Duration::from_secs(TIMEOUT))
                 .await?;
 

crates/chat/src/room.rs

@@ -3,7 +3,7 @@ use std::collections::HashMap;
 use std::hash::{Hash, Hasher};
 use std::time::Duration;
 
-use anyhow::{anyhow, Error};
+use anyhow::Error;
 use common::EventUtils;
 use gpui::{App, AppContext, Context, EventEmitter, SharedString, Task};
 use itertools::Itertools;
@@ -323,6 +323,7 @@ impl Room {
     /// Get gossip relays for each member
     pub fn connect(&self, cx: &App) -> HashMap<PublicKey, Task<Result<(bool, bool), Error>>> {
         let nostr = NostrRegistry::global(cx);
+
         let signer = nostr.read(cx).signer();
         let public_key = signer.public_key().unwrap();
 
@@ -330,56 +331,37 @@ impl Room {
         let mut tasks = HashMap::new();
 
         for member in members.into_iter() {
+            let client = nostr.read(cx).client();
+
             // Skip if member is the current user
             if member == public_key {
                 continue;
             }
 
-            let client = nostr.read(cx).client();
-            let write_relays = nostr.read(cx).write_relays(&member, cx);
-
             tasks.insert(
                 member,
                 cx.background_spawn(async move {
-                    let urls = write_relays.await;
+                    let mut has_inbox = false;
+                    let mut has_announcement = false;
 
-                    // Return if no relays are available
+                    // Construct filters for inbox
-                    if urls.is_empty() {
+                    let inbox = Filter::new()
-                        return Err(anyhow!(
-                            "User has not set up any relays. You cannot send messages to them."
-                        ));
-                    }
-
-                    // Construct filters for inbox and announcement
-                    let inbox_filter = Filter::new()
                         .kind(Kind::InboxRelays)
                         .author(member)
                         .limit(1);
-                    let announcement_filter = Filter::new()
+
+                    // Construct filters for announcement
+                    let announcement = Filter::new()
                         .kind(Kind::Custom(10044))
                         .author(member)
                         .limit(1);
 
-                    // Create subscription targets
-                    let target = urls
-                        .into_iter()
-                        .map(|relay| {
-                            (
-                                relay,
-                                vec![inbox_filter.clone(), announcement_filter.clone()],
-                            )
-                        })
-                        .collect::<HashMap<_, _>>();
-
                     // Stream events from user's write relays
                     let mut stream = client
-                        .stream_events(target)
+                        .stream_events(vec![inbox.clone(), announcement.clone()])
                         .timeout(Duration::from_secs(TIMEOUT))
                         .await?;
 
-                    let mut has_inbox = false;
-                    let mut has_announcement = false;
-
                     while let Some((_url, res)) = stream.next().await {
                         let event = res?;
 

crates/coop/src/panels/encryption_key.rs

@@ -36,6 +36,9 @@ pub struct EncryptionPanel {
     /// Whether the panel is loading
     loading: bool,
 
+    /// Whether the encryption is resetting
+    resetting: bool,
+
     /// Tasks
     tasks: Vec<Task<Result<(), Error>>>,
 }
@@ -47,6 +50,7 @@ impl EncryptionPanel {
             focus_handle: cx.focus_handle(),
             public_key,
             loading: false,
+            resetting: false,
             tasks: vec![],
         }
     }
@@ -91,6 +95,42 @@ impl EncryptionPanel {
         }));
     }
 
+    fn set_resetting(&mut self, status: bool, cx: &mut Context<Self>) {
+        self.resetting = status;
+        cx.notify();
+    }
+
+    fn reset(&mut self, window: &mut Window, cx: &mut Context<Self>) {
+        let device = DeviceRegistry::global(cx);
+        let task = device.read(cx).create_encryption(cx);
+
+        // Update the reset status
+        self.set_resetting(true, cx);
+
+        self.tasks.push(cx.spawn_in(window, async move |this, cx| {
+            match task.await {
+                Ok(keys) => {
+                    this.update_in(cx, |this, _window, cx| {
+                        this.set_resetting(false, cx);
+
+                        device.update(cx, |this, cx| {
+                            this.set_signer(keys, cx);
+                            this.listen_request(cx);
+                        });
+                    })?;
+                }
+                Err(e) => {
+                    this.update_in(cx, |this, window, cx| {
+                        this.set_resetting(false, cx);
+                        window.push_notification(Notification::error(e.to_string()), cx);
+                    })?;
+                }
+            }
+
+            Ok(())
+        }));
+    }
+
     fn render_requests(&mut self, cx: &mut Context<Self>) -> Vec<impl IntoElement> {
         const TITLE: &str = "You've requested for the Encryption Key from:";
 
@@ -269,8 +309,7 @@ impl Render for EncryptionPanel {
                         )),
                 )
             })
-            .when(state.set(), |this| {
+            .child(
-                this.child(
                 v_flex()
                     .gap_1()
                     .child(
@@ -279,7 +318,10 @@ impl Render for EncryptionPanel {
                             .label("Reset")
                             .warning()
                             .small()
-                                .font_semibold(),
+                            .font_semibold()
+                            .on_click(
+                                cx.listener(move |this, _ev, window, cx| this.reset(window, cx)),
+                            ),
                     )
                     .child(
                         div()
@@ -289,6 +331,5 @@ impl Render for EncryptionPanel {
                             .child(SharedString::from(NOTICE)),
                     ),
             )
-            })
     }
 }

crates/coop/src/panels/messaging_relays.rs

@@ -10,7 +10,7 @@ use gpui::{
 };
 use nostr_sdk::prelude::*;
 use smallvec::{smallvec, SmallVec};
-use state::NostrRegistry;
+use state::{NostrRegistry, TIMEOUT};
 use theme::ActiveTheme;
 use ui::button::{Button, ButtonVariants};
 use ui::dock_area::panel::{Panel, PanelEvent};
@@ -170,15 +170,6 @@ impl MessagingRelayPanel {
 
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-        let signer = nostr.read(cx).signer();
-
-        let Some(public_key) = signer.public_key() else {
-            window.push_notification("Public Key not found", cx);
-            return;
-        };
-
-        // Get user's write relays
-        let write_relays = nostr.read(cx).write_relays(&public_key, cx);
 
         // Construct event tags
         let tags: Vec<Tag> = self
@@ -191,14 +182,16 @@ impl MessagingRelayPanel {
         self.set_updating(true, cx);
 
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
-            let urls = write_relays.await;
-
             // Construct nip17 event builder
             let builder = EventBuilder::new(Kind::InboxRelays, "").tags(tags);
             let event = client.sign_event_builder(builder).await?;
 
             // Set messaging relays
-            client.send_event(&event).to(urls).await?;
+            client
+                .send_event(&event)
+                .to_nip65()
+                .ok_timeout(Duration::from_secs(TIMEOUT))
+                .await?;
 
             Ok(())
         });

crates/coop/src/workspace.rs

@@ -2,6 +2,7 @@ use std::sync::Arc;
 
 use ::settings::AppSettings;
 use chat::{ChatEvent, ChatRegistry, InboxState};
+use device::DeviceRegistry;
 use gpui::prelude::FluentBuilder;
 use gpui::{
     div, px, rems, Action, App, AppContext, Axis, Context, Entity, InteractiveElement, IntoElement,
@@ -36,6 +37,7 @@ enum Command {
 
     RefreshRelayList,
     RefreshMessagingRelays,
+    RefreshEncryption,
 
     ShowRelayList,
     ShowMessaging,
@@ -260,6 +262,12 @@ impl Workspace {
                     );
                 });
             }
+            Command::RefreshEncryption => {
+                let device = DeviceRegistry::global(cx);
+                device.update(cx, |this, cx| {
+                    this.get_announcement(cx);
+                });
+            }
             Command::RefreshRelayList => {
                 let nostr = NostrRegistry::global(cx);
                 nostr.update(cx, |this, cx| {
@@ -440,8 +448,19 @@ impl Workspace {
                     .tooltip("Decoupled encryption key")
                     .small()
                     .ghost()
-                    .on_click(|_ev, window, cx| {
+                    .dropdown_menu(|this, _window, _cx| {
-                        window.dispatch_action(Box::new(Command::ShowEncryption), cx);
+                        this.min_w(px(260.))
+                            .label("Encryption")
+                            .menu_with_icon(
+                                "Reload",
+                                IconName::Refresh,
+                                Box::new(Command::RefreshEncryption),
+                            )
+                            .menu_with_icon(
+                                "View encryption",
+                                IconName::Settings,
+                                Box::new(Command::ShowEncryption),
+                            )
                     }),
             )
             .child(
@@ -563,47 +582,6 @@ impl Workspace {
                             .dropdown_menu(move |this, _window, _cx| {
                                 this.min_w(px(260.))
                                     .label("Relays")
-                                    .menu_element_with_disabled(
-                                        Box::new(Command::ShowRelayList),
-                                        true,
-                                        move |_window, cx| {
-                                            let nostr = NostrRegistry::global(cx);
-                                            let urls = nostr.read(cx).read_only_relays(&pkey, cx);
-
-                                            v_flex()
-                                                .gap_1()
-                                                .w_full()
-                                                .items_start()
-                                                .justify_start()
-                                                .children({
-                                                    let mut items = vec![];
-
-                                                    for url in urls.into_iter() {
-                                                        items.push(
-                                                            h_flex()
-                                                                .h_6()
-                                                                .w_full()
-                                                                .gap_2()
-                                                                .px_2()
-                                                                .text_xs()
-                                                                .bg(cx
-                                                                    .theme()
-                                                                    .elevated_surface_background)
-                                                                .rounded(cx.theme().radius)
-                                                                .child(
-                                                                    div()
-                                                                        .size_1()
-                                                                        .rounded_full()
-                                                                        .bg(gpui::green()),
-                                                                )
-                                                                .child(url),
-                                                        );
-                                                    }
-
-                                                    items
-                                                })
-                                        },
-                                    )
                                     .separator()
                                     .menu_with_icon(
                                         "Reload",

crates/device/src/lib.rs

@@ -157,7 +157,7 @@ impl DeviceRegistry {
     }
 
     /// Set the decoupled encryption key for the current user
-    fn set_signer<S>(&mut self, new: S, cx: &mut Context<Self>)
+    pub fn set_signer<S>(&mut self, new: S, cx: &mut Context<Self>)
     where
         S: NostrSigner + 'static,
     {
@@ -248,31 +248,23 @@ impl DeviceRegistry {
     }
 
     /// Get device announcement for current user
-    fn get_announcement(&mut self, cx: &mut Context<Self>) {
+    pub fn get_announcement(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
         let signer = nostr.read(cx).signer();
         let public_key = signer.public_key().unwrap();
 
-        let write_relays = nostr.read(cx).write_relays(&public_key, cx);
-
         let task: Task<Result<Event, Error>> = cx.background_spawn(async move {
-            let urls = write_relays.await;
-
             // Construct the filter for the device announcement event
             let filter = Filter::new()
                 .kind(Kind::Custom(10044))
                 .author(public_key)
                 .limit(1);
 
-            // Construct target for subscription
-            let target: HashMap<&RelayUrl, Filter> =
-                urls.iter().map(|relay| (relay, filter.clone())).collect();
-
             // Stream events from user's write relays
             let mut stream = client
-                .stream_events(target)
+                .stream_events(filter)
                 .timeout(Duration::from_secs(TIMEOUT))
                 .await?;
 
@@ -309,25 +301,16 @@ impl DeviceRegistry {
         }));
     }
 
-    /// Create a new device signer and announce it
+    pub fn create_encryption(&self, cx: &App) -> Task<Result<Keys, Error>> {
-    fn announce(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
-        // Get current user
+        // Generate encryption keys
-        let signer = nostr.read(cx).signer();
-        let public_key = signer.public_key().unwrap();
-
-        // Get user's write relays
-        let write_relays = nostr.read(cx).write_relays(&public_key, cx);
-
         let keys = Keys::generate();
         let secret = keys.secret_key().to_secret_hex();
         let n = keys.public_key();
 
-        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+        cx.background_spawn(async move {
-            let urls = write_relays.await;
-
             // Construct an announcement event
             let event = client
                 .sign_event_builder(EventBuilder::new(Kind::Custom(10044), "").tags(vec![
@@ -337,22 +320,35 @@ impl DeviceRegistry {
                 .await?;
 
             // Publish announcement
-            client.send_event(&event).to(urls).await?;
+            client
+                .send_event(&event)
+                .to_nip65()
+                .ok_timeout(Duration::from_secs(TIMEOUT))
+                .await?;
 
             // Save device keys to the database
             set_keys(&client, &secret).await?;
 
-            Ok(())
+            Ok(keys)
-        });
+        })
+    }
+
+    /// Create a new device signer and announce it
+    fn announce(&mut self, cx: &mut Context<Self>) {
+        let task = self.create_encryption(cx);
 
         self.tasks.push(cx.spawn(async move |this, cx| {
-            if task.await.is_ok() {
+            match task.await {
+                Ok(keys) => {
                     this.update(cx, |this, cx| {
                         this.set_signer(keys, cx);
                         this.listen_request(cx);
                     })?;
                 }
-
+                Err(e) => {
+                    log::error!("Failed to create encryption key: {}", e);
+                }
+            }
             Ok(())
         }));
     }
@@ -401,30 +397,22 @@ impl DeviceRegistry {
     }
 
     /// Listen for device key requests on user's write relays
-    fn listen_request(&mut self, cx: &mut Context<Self>) {
+    pub fn listen_request(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
 
         let signer = nostr.read(cx).signer();
         let public_key = signer.public_key().unwrap();
 
-        let write_relays = nostr.read(cx).write_relays(&public_key, cx);
-
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
-            let urls = write_relays.await;
-
             // Construct a filter for device key requests
             let filter = Filter::new()
                 .kind(Kind::Custom(4454))
                 .author(public_key)
                 .since(Timestamp::now());
 
-            // Construct target for subscription
-            let target: HashMap<&RelayUrl, Filter> =
-                urls.iter().map(|relay| (relay, filter.clone())).collect();
-
             // Subscribe to the device key requests on user's write relays
-            client.subscribe(target).await?;
+            client.subscribe(filter).await?;
 
             Ok(())
         });
@@ -440,23 +428,15 @@ impl DeviceRegistry {
         let signer = nostr.read(cx).signer();
         let public_key = signer.public_key().unwrap();
 
-        let write_relays = nostr.read(cx).write_relays(&public_key, cx);
-
         self.tasks.push(cx.background_spawn(async move {
-            let urls = write_relays.await;
-
             // Construct a filter for device key requests
             let filter = Filter::new()
                 .kind(Kind::Custom(4455))
                 .author(public_key)
                 .since(Timestamp::now());
 
-            // Construct target for subscription
-            let target: HashMap<&RelayUrl, Filter> =
-                urls.iter().map(|relay| (relay, filter.clone())).collect();
-
             // Subscribe to the device key requests on user's write relays
-            client.subscribe(target).await?;
+            client.subscribe(filter).await?;
 
             Ok(())
         }));
@@ -466,11 +446,7 @@ impl DeviceRegistry {
     fn request(&mut self, cx: &mut Context<Self>) {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-
         let signer = nostr.read(cx).signer();
-        let public_key = signer.public_key().unwrap();
-
-        let write_relays = nostr.read(cx).write_relays(&public_key, cx);
 
         let app_keys = nostr.read(cx).app_keys().clone();
         let app_pubkey = app_keys.public_key();
@@ -502,18 +478,20 @@ impl DeviceRegistry {
                     Ok(Some(keys))
                 }
                 None => {
-                    let urls = write_relays.await;
-
                     // Construct an event for device key request
                     let event = client
                         .sign_event_builder(EventBuilder::new(Kind::Custom(4454), "").tags(vec![
-                            Tag::client(app_name()),
                             Tag::custom(TagKind::custom("P"), vec![app_pubkey]),
+                            Tag::client(app_name()),
                         ]))
                         .await?;
 
                     // Send the event to write relays
-                    client.send_event(&event).to(urls).await?;
+                    client
+                        .send_event(&event)
+                        .to_nip65()
+                        .ok_timeout(Duration::from_secs(TIMEOUT))
+                        .await?;
 
                     Ok(None)
                 }
@@ -580,18 +558,12 @@ impl DeviceRegistry {
     pub fn approve(&self, event: &Event, cx: &App) -> Task<Result<(), Error>> {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
-
-        // Get current user
         let signer = nostr.read(cx).signer();
-        let public_key = signer.public_key().unwrap();
 
         // Get user's write relays
-        let write_relays = nostr.read(cx).write_relays(&public_key, cx);
         let event = event.clone();
 
         cx.background_spawn(async move {
-            let urls = write_relays.await;
-
             // Get device keys
             let keys = get_keys(&client).await?;
             let secret = keys.secret_key().to_secret_hex();
@@ -619,7 +591,11 @@ impl DeviceRegistry {
                 .await?;
 
             // Send the response event to the user's relay list
-            client.send_event(&event).to(urls).await?;
+            client
+                .send_event(&event)
+                .to_nip65()
+                .ok_timeout(Duration::from_secs(TIMEOUT))
+                .await?;
 
             Ok(())
         })
@@ -671,6 +647,8 @@ async fn get_keys(client: &Client) -> Result<Keys, Error> {
         let secret = SecretKey::parse(&content)?;
         let keys = Keys::new(secret);
 
+        log::info!("Encryption keys retrieved successfully");
+
         Ok(keys)
     } else {
         Err(anyhow!("Key not found"))

crates/person/src/lib.rs

@@ -198,7 +198,7 @@ impl PersonRegistry {
         loop {
             match flume::Selector::new()
                 .recv(rx, |result| result.ok())
-                .wait_timeout(Duration::from_secs(2))
+                .wait_timeout(Duration::from_secs(TIMEOUT))
             {
                 Ok(Some(public_key)) => {
                     batch.insert(public_key);
@@ -307,16 +307,22 @@ where
         .timeout(Some(Duration::from_secs(TIMEOUT)));
 
     // Construct the filter for metadata
-    let filter = Filter::new()
+    let metadata = Filter::new()
         .kind(Kind::Metadata)
+        .authors(authors.clone())
+        .limit(limit);
+
+    // Construct the filter for relay list
+    let gossip = Filter::new()
+        .kind(Kind::RelayList)
         .authors(authors)
         .limit(limit);
 
     // Construct target for subscription
-    let target = BOOTSTRAP_RELAYS
+    let target: HashMap<&str, Vec<Filter>> = BOOTSTRAP_RELAYS
         .into_iter()
-        .map(|relay| (relay, vec![filter.clone()]))
+        .map(|relay| (relay, vec![metadata.clone(), gossip.clone()]))
-        .collect::<HashMap<_, _>>();
+        .collect();
 
     client.subscribe(target).close_on(opts).await?;
 

crates/state/Cargo.toml

@@ -11,6 +11,7 @@ nostr.workspace = true
 nostr-sdk.workspace = true
 nostr-lmdb.workspace = true
 nostr-connect.workspace = true
+nostr-gossip-sqlite.workspace = true
 nostr-blossom.workspace = true
 
 gpui.workspace = true

crates/state/src/constants.rs

@@ -12,8 +12,8 @@ pub const APP_ID: &str = "su.reya.coop";
 /// Keyring name
 pub const KEYRING: &str = "Coop Safe Storage";
 
-/// Default timeout for subscription
+/// Default timeout in second for subscription
-pub const TIMEOUT: u64 = 3;
+pub const TIMEOUT: u64 = 2;
 
 /// Default delay for searching
 pub const FIND_DELAY: u64 = 600;

crates/state/src/gossip.rs

@@ -1,83 +0,0 @@
-use std::collections::{HashMap, HashSet};
-
-use gpui::SharedString;
-use nostr_sdk::prelude::*;
-
-/// Gossip
-#[derive(Debug, Clone, Default)]
-pub struct Gossip {
-    relays: HashMap<PublicKey, HashSet<(RelayUrl, Option<RelayMetadata>)>>,
-}
-
-impl Gossip {
-    pub fn read_only_relays(&self, public_key: &PublicKey) -> Vec<SharedString> {
-        self.relays
-            .get(public_key)
-            .map(|relays| {
-                relays
-                    .iter()
-                    .map(|(url, _)| url.to_string().into())
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
-    /// Get read relays for a given public key
-    pub fn read_relays(&self, public_key: &PublicKey) -> Vec<RelayUrl> {
-        self.relays
-            .get(public_key)
-            .map(|relays| {
-                relays
-                    .iter()
-                    .filter_map(|(url, metadata)| {
-                        if metadata.is_none() || metadata == &Some(RelayMetadata::Read) {
-                            Some(url.to_owned())
-                        } else {
-                            None
-                        }
-                    })
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
-    /// Get write relays for a given public key
-    pub fn write_relays(&self, public_key: &PublicKey) -> Vec<RelayUrl> {
-        self.relays
-            .get(public_key)
-            .map(|relays| {
-                relays
-                    .iter()
-                    .filter_map(|(url, metadata)| {
-                        if metadata.is_none() || metadata == &Some(RelayMetadata::Write) {
-                            Some(url.to_owned())
-                        } else {
-                            None
-                        }
-                    })
-                    .collect()
-            })
-            .unwrap_or_default()
-    }
-
-    /// Insert gossip relays for a public key
-    pub fn insert_relays(&mut self, event: &Event) {
-        self.relays.entry(event.pubkey).or_default().extend(
-            event
-                .tags
-                .iter()
-                .filter_map(|tag| {
-                    if let Some(TagStandard::RelayMetadata {
-                        relay_url,
-                        metadata,
-                    }) = tag.clone().to_standardized()
-                    {
-                        Some((relay_url, metadata))
-                    } else {
-                        None
-                    }
-                })
-                .take(3),
-        );
-    }
-}

crates/state/src/lib.rs

@@ -1,26 +1,25 @@
-use std::collections::{HashMap, HashSet};
+use std::collections::HashMap;
 use std::os::unix::fs::PermissionsExt;
 use std::sync::Arc;
 use std::time::Duration;
 
 use anyhow::{anyhow, Context as AnyhowContext, Error};
 use common::config_dir;
-use gpui::{App, AppContext, Context, Entity, Global, SharedString, Task, Window};
+use gpui::{App, AppContext, Context, Entity, Global, Task, Window};
 use nostr_connect::prelude::*;
+use nostr_gossip_sqlite::prelude::*;
 use nostr_lmdb::prelude::*;
 use nostr_sdk::prelude::*;
 
 mod blossom;
 mod constants;
 mod device;
-mod gossip;
 mod nip05;
 mod signer;
 
 pub use blossom::*;
 pub use constants::*;
 pub use device::*;
-pub use gossip::*;
 pub use nip05::*;
 pub use signer::*;
 
@@ -56,9 +55,6 @@ pub struct NostrRegistry {
     /// Used for Nostr Connect and NIP-4e operations
     app_keys: Keys,
 
-    /// Custom gossip implementation
-    gossip: Entity<Gossip>,
-
     /// Relay list state
     relay_list_state: RelayState,
 
@@ -89,9 +85,6 @@ impl NostrRegistry {
         let app_keys = get_or_init_app_keys().unwrap_or(Keys::generate());
         let signer = Arc::new(CoopSigner::new(app_keys.clone()));
 
-        // Construct the gossip entity
-        let gossip = cx.new(|_| Gossip::default());
-
         // Construct the nostr lmdb instance
         let lmdb = cx.foreground_executor().block_on(async move {
             NostrLmdb::open(config_dir().join("nostr"))
@@ -99,13 +92,21 @@ impl NostrRegistry {
                 .expect("Failed to initialize database")
         });
 
+        // Construct the nostr gossip instance
+        let gossip = cx.foreground_executor().block_on(async move {
+            NostrGossipSqlite::open(config_dir().join("gossip"))
+                .await
+                .expect("Failed to initialize gossip database")
+        });
+
         // Construct the nostr client
         let client = ClientBuilder::default()
             .signer(signer.clone())
             .database(lmdb)
+            .gossip(gossip)
             .automatic_authentication(false)
             .verify_subscriptions(false)
-            .connect_timeout(Duration::from_secs(TIMEOUT))
+            .connect_timeout(Duration::from_secs(5))
             .sleep_when_idle(SleepWhenIdle::Enabled {
                 timeout: Duration::from_secs(600),
             })
@@ -114,14 +115,12 @@ impl NostrRegistry {
         // Run at the end of current cycle
         cx.defer_in(window, |this, _window, cx| {
             this.connect(cx);
-            this.handle_notifications(cx);
         });
 
         Self {
             client,
             signer,
             app_keys,
-            gossip,
             relay_list_state: RelayState::Idle,
             connected: false,
             creating: false,
@@ -146,10 +145,7 @@ impl NostrRegistry {
                     }
 
                     // Connect to all added relays
-                    client
+                    client.connect().and_wait(Duration::from_secs(5)).await;
-                        .connect()
-                        .and_wait(Duration::from_secs(TIMEOUT))
-                        .await;
                 })
                 .await;
 
@@ -163,60 +159,6 @@ impl NostrRegistry {
         }));
     }
 
-    /// Handle nostr notifications
-    fn handle_notifications(&mut self, cx: &mut Context<Self>) {
-        let client = self.client();
-        let gossip = self.gossip.downgrade();
-
-        // Channel for communication between nostr and gpui
-        let (tx, rx) = flume::bounded::<Event>(2048);
-
-        let task: Task<Result<(), Error>> = cx.background_spawn(async move {
-            // Handle nostr notifications
-            let mut notifications = client.notifications();
-            let mut processed_events = HashSet::new();
-
-            while let Some(notification) = notifications.next().await {
-                if let ClientNotification::Message {
-                    message: RelayMessage::Event { event, .. },
-                    ..
-                } = notification
-                {
-                    // Skip if the event has already been processed
-                    if processed_events.insert(event.id) {
-                        match event.kind {
-                            Kind::RelayList => {
-                                tx.send_async(event.into_owned()).await?;
-                            }
-                            Kind::InboxRelays => {
-                                tx.send_async(event.into_owned()).await?;
-                            }
-                            _ => {}
-                        }
-                    }
-                }
-            }
-
-            Ok(())
-        });
-
-        // Run task in the background
-        task.detach();
-
-        self.tasks.push(cx.spawn(async move |_this, cx| {
-            while let Ok(event) = rx.recv_async().await {
-                if let Kind::RelayList = event.kind {
-                    gossip.update(cx, |this, cx| {
-                        this.insert_relays(&event);
-                        cx.notify();
-                    })?;
-                }
-            }
-
-            Ok(())
-        }));
-    }
-
     /// Get the nostr client
     pub fn client(&self) -> Client {
         self.client.clone()
@@ -247,41 +189,6 @@ impl NostrRegistry {
         self.relay_list_state.clone()
     }
 
-    /// Get all relays for a given public key without ensuring connections
-    pub fn read_only_relays(&self, public_key: &PublicKey, cx: &App) -> Vec<SharedString> {
-        self.gossip.read(cx).read_only_relays(public_key)
-    }
-
-    /// Get a list of write relays for a given public key
-    pub fn write_relays(&self, public_key: &PublicKey, cx: &App) -> Task<Vec<RelayUrl>> {
-        let client = self.client();
-        let relays = self.gossip.read(cx).write_relays(public_key);
-
-        cx.background_spawn(async move {
-            // Ensure relay connections
-            for url in relays.iter() {
-                client.add_relay(url).and_connect().await.ok();
-            }
-
-            relays
-        })
-    }
-
-    /// Get a list of read relays for a given public key
-    pub fn read_relays(&self, public_key: &PublicKey, cx: &App) -> Task<Vec<RelayUrl>> {
-        let client = self.client();
-        let relays = self.gossip.read(cx).read_relays(public_key);
-
-        cx.background_spawn(async move {
-            // Ensure relay connections
-            for url in relays.iter() {
-                client.add_relay(url).and_connect().await.ok();
-            }
-
-            relays
-        })
-    }
-
     /// Set the connected status of the client
     fn set_connected(&mut self, cx: &mut Context<Self>) {
         self.connected = true;
@@ -488,16 +395,24 @@ impl NostrRegistry {
         cx.notify();
     }
 
+    /// Set relay list state
+    fn set_relay_list_state(&mut self, state: RelayState, cx: &mut Context<Self>) {
+        self.relay_list_state = state;
+        cx.notify();
+    }
+
     pub fn ensure_relay_list(&mut self, cx: &mut Context<Self>) {
         let task = self.verify_relay_list(cx);
 
+        // Reset state
+        self.set_relay_list_state(RelayState::default(), cx);
+
         self.tasks.push(cx.spawn(async move |this, cx| {
             let result = task.await?;
 
             // Update state
             this.update(cx, |this, cx| {
-                this.relay_list_state = result;
+                this.set_relay_list_state(result, cx);
-                cx.notify();
             })?;
 
             Ok(())