chore: refactor account and fixes

crates/account/src/lib.rs

@@ -31,6 +31,7 @@ impl Account {
         cx.set_global(GlobalAccount(account));
     }
 
+    /// Login to the account using the given signer.
     pub fn login<S>(&mut self, signer: S, window: &mut Window, cx: &mut Context<Self>)
     where
         S: NostrSigner + 'static,
@@ -56,12 +57,15 @@ impl Account {
 
         cx.spawn_in(window, async move |this, cx| match task.await {
             Ok(profile) => {
-                cx.update(|_, cx| {
+                cx.update(|window, cx| {
                     this.update(cx, |this, cx| {
-                        this.profile = Some(profile);
-                        this.subscribe(cx);
-                        cx.notify();
+                        this.profile(profile, cx);
+
+                        cx.defer_in(window, |this, _, cx| {
+                            this.subscribe(cx);
+                        });
                     })
+                    .ok();
                 })
                 .ok();
             }
@@ -75,28 +79,80 @@ impl Account {
         .detach();
     }
 
+    /// Create a new account with the given metadata.
     pub fn new_account(&mut self, metadata: Metadata, window: &mut Window, cx: &mut Context<Self>) {
-        let client = get_client();
+        const DEFAULT_NIP_65_RELAYS: [&str; 4] = [
+            "wss://relay.damus.io",
+            "wss://relay.primal.net",
+            "wss://relay.nostr.net",
+            "wss://nos.lol",
+        ];
+
+        const DEFAULT_MESSAGING_RELAYS: [&str; 2] =
+            ["wss://auth.nostr1.com", "wss://relay.0xchat.com"];
+
         let keys = Keys::generate();
+        let public_key = keys.public_key();
 
         let task: Task<Result<Profile, Error>> = cx.background_spawn(async move {
-            let public_key = keys.public_key();
+            let client = get_client();
+
             // Update signer
             client.set_signer(keys).await;
+
             // Set metadata
             client.set_metadata(&metadata).await?;
 
+            // Create relay list
+            let tags: Vec<Tag> = DEFAULT_NIP_65_RELAYS
+                .into_iter()
+                .filter_map(|url| {
+                    if let Ok(url) = RelayUrl::parse(url) {
+                        Some(Tag::relay_metadata(url, None))
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            let builder = EventBuilder::new(Kind::RelayList, "").tags(tags);
+
+            if let Err(e) = client.send_event_builder(builder).await {
+                log::error!("Failed to send relay list event: {}", e);
+            };
+
+            // Create messaging relay list
+            let tags: Vec<Tag> = DEFAULT_MESSAGING_RELAYS
+                .into_iter()
+                .filter_map(|url| {
+                    if let Ok(url) = RelayUrl::parse(url) {
+                        Some(Tag::relay(url))
+                    } else {
+                        None
+                    }
+                })
+                .collect();
+
+            let builder = EventBuilder::new(Kind::InboxRelays, "").tags(tags);
+
+            if let Err(e) = client.send_event_builder(builder).await {
+                log::error!("Failed to send messaging relay list event: {}", e);
+            };
+
             Ok(Profile::new(public_key, metadata))
         });
 
         cx.spawn_in(window, async move |this, cx| {
             if let Ok(profile) = task.await {
-                cx.update(|_, cx| {
+                cx.update(|window, cx| {
                     this.update(cx, |this, cx| {
-                        this.profile = Some(profile);
-                        this.subscribe(cx);
-                        cx.notify();
+                        this.profile(profile, cx);
+
+                        cx.defer_in(window, |this, _, cx| {
+                            this.subscribe(cx);
+                        });
                     })
+                    .ok();
                 })
                 .ok();
             } else {
@@ -109,12 +165,18 @@ impl Account {
         .detach();
     }
 
-    pub fn subscribe(&self, cx: &Context<Self>) {
+    /// Sets the profile for the account.
+    pub fn profile(&mut self, profile: Profile, cx: &mut Context<Self>) {
+        self.profile = Some(profile);
+        cx.notify();
+    }
+
+    /// Subscribes to the current account's metadata.
+    pub fn subscribe(&self, cx: &mut Context<Self>) {
         let Some(profile) = self.profile.as_ref() else {
             return;
         };
 
-        let client = get_client();
         let user = profile.public_key();
         let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
 
@@ -145,6 +207,7 @@ impl Account {
         let new_msg = Filter::new().kind(Kind::GiftWrap).pubkey(user).limit(0);
 
         let task: Task<Result<(), Error>> = cx.background_spawn(async move {
+            let client = get_client();
             client.subscribe(metadata, Some(opts)).await?;
             client.subscribe(data, None).await?;