From 7c99ed39e4929d678ba0268567d3fed9da703b85 Mon Sep 17 00:00:00 2001 From: XIAO YU Date: Sun, 16 Jun 2024 10:11:48 +0900 Subject: [PATCH] chore: handle unwrap err (#210) --- src-tauri/src/nostr/metadata.rs | 129 ++++++++++++++++++++------------ 1 file changed, 81 insertions(+), 48 deletions(-) diff --git a/src-tauri/src/nostr/metadata.rs b/src-tauri/src/nostr/metadata.rs index 3bc0e8f0..84711015 100644 --- a/src-tauri/src/nostr/metadata.rs +++ b/src-tauri/src/nostr/metadata.rs @@ -9,29 +9,38 @@ use tauri::State; #[specta::specta] pub async fn get_current_user_profile(state: State<'_, Nostr>) -> Result { let client = &state.client; - let signer = client.signer().await.unwrap(); - let public_key = signer.public_key().await.unwrap(); + + let signer = match client.signer().await { + Ok(signer) => signer, + Err(err) => return Err(format!("Failed to get signer: {}", err)), + }; + + let public_key = match signer.public_key().await { + Ok(pk) => pk, + Err(err) => return Err(format!("Failed to get public key: {}", err)), + }; + let filter = Filter::new() .author(public_key) .kind(Kind::Metadata) .limit(1); - match client + let events_result = client .get_events_of(vec![filter], Some(Duration::from_secs(10))) - .await - { + .await; + + match events_result { Ok(events) => { if let Some(event) = get_latest_event(&events) { - if let Ok(metadata) = Metadata::from_json(&event.content) { - Ok(metadata.as_json()) - } else { - Err("Parse metadata failed".into()) + match Metadata::from_json(&event.content) { + Ok(metadata) => Ok(metadata.as_json()), + Err(_) => Err("Failed to parse metadata.".into()), } } else { - Err("Not found".into()) + Err("No matching events found.".into()) } } - Err(_) => Err("Not found".into()), + Err(err) => Err(format!("Failed to get events: {}", err)), } } @@ -89,7 +98,10 @@ pub async fn set_contact_list(pubkeys: Vec<&str>, state: State<'_, Nostr>) -> Re let client = &state.client; let contact_list: Vec = pubkeys .into_iter() - .map(|p| Contact::new(PublicKey::from_hex(p).unwrap(), None, Some(""))) + .filter_map(|p| match PublicKey::from_hex(p) { + Ok(pk) => Some(Contact::new(pk, None, Some(""))), + Err(_) => None, + }) .collect(); match client.set_contact_list(contact_list).await { @@ -168,11 +180,14 @@ pub async fn follow( state: State<'_, Nostr>, ) -> Result { let client = &state.client; - let public_key = PublicKey::from_str(id).unwrap(); - let contact = Contact::new(public_key, None, alias); // #TODO: Add relay_url - let contact_list = client.get_contact_list(Some(Duration::from_secs(10))).await; + let public_key = match PublicKey::from_str(id) { + Ok(pk) => pk, + Err(_) => return Err("Invalid public key.".into()), + }; + let contact = Contact::new(public_key, None, alias); // TODO: Add relay_url + let contact_list_result = client.get_contact_list(Some(Duration::from_secs(10))).await; - match contact_list { + match contact_list_result { Ok(mut old_list) => { old_list.push(contact); let new_list = old_list.into_iter(); @@ -190,20 +205,21 @@ pub async fn follow( #[specta::specta] pub async fn unfollow(id: &str, state: State<'_, Nostr>) -> Result { let client = &state.client; - let public_key = PublicKey::from_str(id).unwrap(); - let contact_list = client.get_contact_list(Some(Duration::from_secs(10))).await; + let public_key = match PublicKey::from_str(id) { + Ok(pk) => pk, + Err(_) => return Err("Invalid public key.".into()), + }; - match contact_list { - Ok(mut old_list) => { - let index = old_list - .iter() - .position(|x| x.public_key == public_key) - .unwrap(); - old_list.remove(index); + let contact_list_result = client.get_contact_list(Some(Duration::from_secs(10))).await; - let new_list = old_list.into_iter(); + match contact_list_result { + Ok(old_list) => { + let contacts: Vec = old_list + .into_iter() + .filter(|contact| contact.public_key != public_key) + .collect(); - match client.set_contact_list(new_list).await { + match client.set_contact_list(contacts).await { Ok(event_id) => Ok(event_id.to_string()), Err(err) => Err(err.to_string()), } @@ -223,8 +239,15 @@ pub async fn set_nstore( match client.signer().await { Ok(signer) => { - let public_key = signer.public_key().await.unwrap(); - let encrypted = signer.nip44_encrypt(public_key, content).await.unwrap(); + let public_key = match signer.public_key().await { + Ok(pk) => pk, + Err(err) => return Err(format!("Failed to get public key: {}", err)), + }; + + let encrypted = match signer.nip44_encrypt(public_key, content).await { + Ok(enc) => enc, + Err(err) => return Err(format!("Encryption failed: {}", err)), + }; let tag = Tag::identifier(key); let builder = EventBuilder::new(Kind::ApplicationSpecificData, encrypted, vec![tag]); @@ -244,7 +267,11 @@ pub async fn get_nstore(key: &str, state: State<'_, Nostr>) -> Result pk, + Err(err) => return Err(format!("Failed to get public key: {}", err)), + }; + let filter = Filter::new() .author(public_key) .kind(Kind::ApplicationSpecificData) @@ -280,9 +307,9 @@ pub async fn set_nwc(uri: &str, state: State<'_, Nostr>) -> Result if let Ok(nwc_uri) = NostrWalletConnectURI::from_str(uri) { let nwc = NWC::new(nwc_uri); - let keyring = Entry::new("Lume Secret Storage", "NWC").unwrap(); - let _ = keyring.set_password(uri); - let _ = client.set_zapper(nwc).await; + let keyring = Entry::new("Lume Secret Storage", "NWC").map_err(|e| e.to_string())?; + keyring.set_password(uri).map_err(|e| e.to_string())?; + client.set_zapper(nwc).await; Ok(true) } else { @@ -294,11 +321,11 @@ pub async fn set_nwc(uri: &str, state: State<'_, Nostr>) -> Result #[specta::specta] pub async fn load_nwc(state: State<'_, Nostr>) -> Result { let client = &state.client; - let keyring = Entry::new("Lume Secret Storage", "NWC").unwrap(); + let keyring = Entry::new("Lume Secret Storage", "NWC").map_err(|e| e.to_string())?; match keyring.get_password() { Ok(val) => { - let uri = NostrWalletConnectURI::from_str(&val).unwrap(); + let uri = NostrWalletConnectURI::from_str(&val).map_err(|e| e.to_string())?; let nwc = NWC::new(uri); client.set_zapper(nwc).await; @@ -311,17 +338,17 @@ pub async fn load_nwc(state: State<'_, Nostr>) -> Result { #[tauri::command] #[specta::specta] pub async fn get_balance() -> Result { - let keyring = Entry::new("Lume Secret Storage", "NWC").unwrap(); + let keyring = Entry::new("Lume Secret Storage", "NWC").map_err(|e| e.to_string())?; match keyring.get_password() { Ok(val) => { - let uri = NostrWalletConnectURI::from_str(&val).unwrap(); + let uri = NostrWalletConnectURI::from_str(&val).map_err(|e| e.to_string())?; let nwc = NWC::new(uri); - if let Ok(balance) = nwc.get_balance().await { - Ok(balance.to_string()) - } else { - Err("Get balance failed".into()) - } + nwc + .get_balance() + .await + .map(|balance| balance.to_string()) + .map_err(|_| "Get balance failed".into()) } Err(_) => Err("Something wrong".into()), } @@ -350,9 +377,12 @@ pub async fn zap_profile( if let Some(recipient) = public_key { let details = ZapDetails::new(ZapType::Public).message(message); - let num = amount.parse::().unwrap(); + let num = match amount.parse::() { + Ok(val) => val, + Err(_) => return Err("Invalid amount.".into()), + }; - if (client.zap(recipient, num, Some(details)).await).is_ok() { + if client.zap(recipient, num, Some(details)).await.is_ok() { Ok(true) } else { Err("Zap profile failed".into()) @@ -385,15 +415,18 @@ pub async fn zap_event( if let Some(recipient) = event_id { let details = ZapDetails::new(ZapType::Public).message(message); - let num = amount.parse::().unwrap(); + let num = match amount.parse::() { + Ok(val) => val, + Err(_) => return Err("Invalid amount.".into()), + }; - if (client.zap(recipient, num, Some(details)).await).is_ok() { + if client.zap(recipient, num, Some(details)).await.is_ok() { Ok(true) } else { Err("Zap event failed".into()) } } else { - Err("Parse public key failed".into()) + Err("Parse event ID failed".into()) } } @@ -492,7 +525,7 @@ pub async fn get_followers( .map(|event| event.author().to_hex()) .collect(); Ok(ret) - //todo: get more than 500 events + // TODO: get more than 500 events } #[tauri::command]