.

crates/relay_auth/src/lib.rs

@@ -1,14 +1,14 @@
 use std::borrow::Cow;
 use std::cell::Cell;
 use std::collections::HashSet;
-use std::hash::{Hash, Hasher};
+use std::hash::Hash;
 use std::rc::Rc;
 use std::sync::Arc;
 
 use anyhow::{anyhow, Context as AnyhowContext, Error};
 use gpui::{
     App, AppContext, Context, Entity, Global, IntoElement, ParentElement, SharedString, Styled,
-    Subscription, Task, Window,
+    Task, Window,
 };
 use nostr_sdk::prelude::*;
 use settings::{AppSettings, AuthMode};
@@ -27,18 +27,12 @@ pub fn init(window: &mut Window, cx: &mut App) {
 }
 
 /// Authentication request
-#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Clone, Hash, PartialEq, Eq, PartialOrd, Ord)]
 struct AuthRequest {
     url: RelayUrl,
     challenge: String,
 }
 
-impl Hash for AuthRequest {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.challenge.hash(state);
-    }
-}
-
 impl AuthRequest {
     pub fn new(challenge: impl Into<String>, url: RelayUrl) -> Self {
         Self {
@@ -74,9 +68,6 @@ pub struct RelayAuth {
 
     /// Tasks for asynchronous operations
     tasks: SmallVec<[Task<()>; 2]>,
-
-    /// Event subscriptions
-    _subscriptions: SmallVec<[Subscription; 1]>,
 }
 
 impl RelayAuth {
@@ -92,22 +83,13 @@ impl RelayAuth {
 
     /// Create a new relay auth instance
     fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
-        let nostr = NostrRegistry::global(cx);
-        let mut subscriptions = smallvec![];
-
-        subscriptions.push(
-            // Observe the nostr state
-            cx.observe_in(&nostr, window, move |this, state, window, cx| {
-                if state.read(cx).connected() {
-                    this.handle_notifications(window, cx)
-                }
-            }),
-        );
+        cx.defer_in(window, |this, window, cx| {
+            this.handle_notifications(window, cx);
+        });
 
         Self {
             pending_events: HashSet::default(),
             tasks: smallvec![],
-            _subscriptions: subscriptions,
         }
     }
 
@@ -119,7 +101,8 @@ impl RelayAuth {
         // Channel for communication between nostr and gpui
         let (tx, rx) = flume::bounded::<Signal>(256);
 
-        cx.background_spawn(async move {
+        self.tasks.push(cx.background_spawn(async move {
+            log::info!("Started handling nostr notifications");
             let mut notifications = client.notifications();
             let mut challenges: HashSet<Cow<'_, str>> = HashSet::default();
 
@@ -128,8 +111,8 @@ impl RelayAuth {
                     match message {
                         RelayMessage::Auth { challenge } => {
                             if challenges.insert(challenge.clone()) {
-                                let request = AuthRequest::new(challenge, relay_url);
-                                let signal = Signal::Auth(Arc::new(request));
+                                let request = Arc::new(AuthRequest::new(challenge, relay_url));
+                                let signal = Signal::Auth(request);
 
                                 tx.send_async(signal).await.ok();
                             }
@@ -149,8 +132,7 @@ impl RelayAuth {
                     }
                 }
             }
-        })
-        .detach();
+        }));
 
         self.tasks.push(cx.spawn_in(window, async move |this, cx| {
             while let Ok(signal) = rx.recv_async().await {