Handle errors when adding and connecting relays in init_nip65 (#227)

src-tauri/src/nostr/internal.rs

@@ -2,52 +2,60 @@ use crate::Settings;
 use nostr_sdk::prelude::*;
 
 pub async fn init_nip65(client: &Client) {
-    let signer = client.signer().await.unwrap();
-    let public_key = signer.public_key().await.unwrap();
-
-    if let Ok(events) = client
-        .get_events_of(
-            vec![Filter::new()
-                .author(public_key)
-                .kind(Kind::RelayList)
-                .limit(1)],
-            None,
-        )
-        .await
-    {
-        if let Some(event) = events.first() {
-            let relay_list = nip65::extract_relay_list(event);
-            for item in relay_list.into_iter() {
-                let relay_url = item.0.to_string();
-                let opts = match item.1 {
-                    Some(val) => {
-                        if val == &RelayMetadata::Read {
-                            RelayOptions::new().read(true).write(false)
-                        } else {
-                            RelayOptions::new().write(true).read(false)
-                        }
-                    }
-                    None => RelayOptions::default(),
-                };
-
-                // Add relay to relay pool
-                let _ = client
-                    .add_relay_with_opts(&relay_url, opts)
-                    .await
-                    .unwrap_or_default();
-
-                // Connect relay
-                client.connect_relay(relay_url).await.unwrap_or_default();
-                println!("connecting to relay: {} - {:?}", item.0, item.1);
-            }
+    let signer = match client.signer().await {
+        Ok(signer) => signer,
+        Err(e) => {
+            eprintln!("Failed to get signer: {:?}", e);
+            return;
         }
     };
+    let public_key = match signer.public_key().await {
+        Ok(public_key) => public_key,
+        Err(e) => {
+            eprintln!("Failed to get public key: {:?}", e);
+            return;
+        }
+    };
+
+    let filter = Filter::new()
+        .author(public_key)
+        .kind(Kind::RelayList)
+        .limit(1);
+
+    if let Ok(events) = client.get_events_of(vec![filter], None).await {
+        if let Some(event) = events.first() {
+            let relay_list = nip65::extract_relay_list(event);
+            for (url, metadata) in relay_list {
+                let opts = match metadata {
+                    Some(RelayMetadata::Read) => RelayOptions::new().read(true).write(false),
+                    Some(_) => RelayOptions::new().write(true).read(false),
+                    None => RelayOptions::default(),
+                };
+                if let Err(e) = client.add_relay_with_opts(&url.to_string(), opts).await {
+                    eprintln!("Failed to add relay {}: {:?}", url, e);
+                }
+                if let Err(e) = client.connect_relay(url.to_string()).await {
+                    eprintln!("Failed to connect to relay {}: {:?}", url, e);
+                } else {
+                    println!("Connecting to relay: {} - {:?}", url, metadata);
+                }
+            }
+        }
+    } else {
+        eprintln!("Failed to get events for RelayList.");
+    }
 }
 
 pub async fn get_user_settings(client: &Client) -> Result<Settings, String> {
     let ident = "lume:settings";
-    let signer = client.signer().await.unwrap();
-    let public_key = signer.public_key().await.unwrap();
+    let signer = client
+        .signer()
+        .await
+        .map_err(|e| format!("Failed to get signer: {:?}", e))?;
+    let public_key = signer
+        .public_key()
+        .await
+        .map_err(|e| format!("Failed to get public key: {:?}", e))?;
 
     let filter = Filter::new()
         .author(public_key)
@@ -55,21 +63,24 @@ pub async fn get_user_settings(client: &Client) -> Result<Settings, String> {
         .identifier(ident)
         .limit(1);
 
-    if let Ok(events) = client.get_events_of(vec![filter], None).await {
-        if let Some(event) = events.first() {
-            let content = event.content();
-            if let Ok(decrypted) = signer.nip44_decrypt(public_key, content).await {
-                match serde_json::from_str(&decrypted) {
-                    Ok(parsed) => parsed,
-                    Err(_) => Err("Could not parse settings payload".into()),
+    match client.get_events_of(vec![filter], None).await {
+        Ok(events) => {
+            if let Some(event) = events.first() {
+                let content = event.content();
+                match signer.nip44_decrypt(public_key, content).await {
+                    Ok(decrypted) => match serde_json::from_str(&decrypted) {
+                        Ok(parsed) => Ok(parsed),
+                        Err(_) => Err("Could not parse settings payload".into()),
+                    },
+                    Err(e) => Err(format!("Failed to decrypt settings content: {:?}", e)),
                 }
             } else {
-                Err("Decrypt settings failed.".into())
+                Err("Settings not found.".into())
             }
-        } else {
-            Err("Settings not found.".into())
         }
-    } else {
-        Err("Settings not found.".into())
+        Err(e) => Err(format!(
+            "Failed to get events for ApplicationSpecificData: {:?}",
+            e
+        )),
     }
 }