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 signer = match client.signer().await {
-    let public_key = signer.public_key().await.unwrap();
+        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;
+        }
+    };
 
-    if let Ok(events) = client
+    let filter = Filter::new()
-        .get_events_of(
-            vec![Filter::new()
         .author(public_key)
         .kind(Kind::RelayList)
-                .limit(1)],
+        .limit(1);
-            None,
+
-        )
+    if let Ok(events) = client.get_events_of(vec![filter], None).await {
-        .await
-    {
         if let Some(event) = events.first() {
             let relay_list = nip65::extract_relay_list(event);
-            for item in relay_list.into_iter() {
+            for (url, metadata) in relay_list {
-                let relay_url = item.0.to_string();
+                let opts = match metadata {
-                let opts = match item.1 {
+                    Some(RelayMetadata::Read) => RelayOptions::new().read(true).write(false),
-                    Some(val) => {
+                    Some(_) => RelayOptions::new().write(true).read(false),
-                        if val == &RelayMetadata::Read {
-                            RelayOptions::new().read(true).write(false)
-                        } else {
-                            RelayOptions::new().write(true).read(false)
-                        }
-                    }
                     None => RelayOptions::default(),
                 };
-
+                if let Err(e) = client.add_relay_with_opts(&url.to_string(), opts).await {
-                // Add relay to relay pool
+                    eprintln!("Failed to add relay {}: {:?}", url, e);
-                let _ = client
+                }
-                    .add_relay_with_opts(&relay_url, opts)
+                if let Err(e) = client.connect_relay(url.to_string()).await {
-                    .await
+                    eprintln!("Failed to connect to relay {}: {:?}", url, e);
-                    .unwrap_or_default();
+                } else {
-
+                    println!("Connecting to relay: {} - {:?}", url, metadata);
-                // Connect relay
-                client.connect_relay(relay_url).await.unwrap_or_default();
-                println!("connecting to relay: {} - {:?}", item.0, item.1);
                 }
             }
-    };
+        }
+    } 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 signer = client
-    let public_key = signer.public_key().await.unwrap();
+        .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 {
+    match client.get_events_of(vec![filter], None).await {
+        Ok(events) => {
             if let Some(event) = events.first() {
                 let content = event.content();
-            if let Ok(decrypted) = signer.nip44_decrypt(public_key, content).await {
+                match signer.nip44_decrypt(public_key, content).await {
-                match serde_json::from_str(&decrypted) {
+                    Ok(decrypted) => match serde_json::from_str(&decrypted) {
-                    Ok(parsed) => parsed,
+                        Ok(parsed) => Ok(parsed),
                         Err(_) => Err("Could not parse settings payload".into()),
-                }
+                    },
-            } else {
+                    Err(e) => Err(format!("Failed to decrypt settings content: {:?}", e)),
-                Err("Decrypt settings failed.".into())
                 }
             } else {
                 Err("Settings not found.".into())
             }
-    } else {
+        }
-        Err("Settings not found.".into())
+        Err(e) => Err(format!(
+            "Failed to get events for ApplicationSpecificData: {:?}",
+            e
+        )),
     }
 }