feat: add zap command

src-tauri/src/main.rs

@@ -106,6 +106,10 @@ fn main() {
       nostr::metadata::get_interest,
       nostr::metadata::set_settings,
       nostr::metadata::get_settings,
+      nostr::metadata::get_nwc_status,
+      nostr::metadata::set_nwc,
+      nostr::metadata::zap_profile,
+      nostr::metadata::zap_event,
       nostr::event::get_event,
       nostr::event::get_events_from,
       nostr::event::get_local_events,

src-tauri/src/nostr/keys.rs

@@ -3,6 +3,7 @@ use keyring::Entry;
 use nostr_sdk::prelude::*;
 use std::io::{BufReader, Read};
 use std::iter;
+use std::time::Duration;
 use std::{fs::File, io::Write, str::FromStr};
 use tauri::{Manager, State};
 
@@ -139,11 +140,34 @@ pub async fn load_selected_account(
       // Build nostr signer
       let secret_key = SecretKey::from_bech32(nsec_key).expect("Get secret key failed");
       let keys = Keys::new(secret_key);
+      let public_key = keys.public_key();
       let signer = NostrSigner::Keys(keys);
 
       // Update signer
       client.set_signer(Some(signer)).await;
 
+      // Get user's relay list
+      let filter = Filter::new()
+        .author(public_key)
+        .kind(Kind::RelayList)
+        .limit(1);
+      let query = client
+        .get_events_of(vec![filter], Some(Duration::from_secs(10)))
+        .await;
+
+      // Connect user's relay list
+      if let Ok(events) = query {
+        if let Some(event) = events.first() {
+          let list = nip65::extract_relay_list(&event);
+          for item in list.into_iter() {
+            client
+              .connect_relay(item.0.to_string())
+              .await
+              .unwrap_or_default();
+          }
+        }
+      }
+
       Ok(true)
     } else {
       Ok(false)

src-tauri/src/nostr/metadata.rs

@@ -272,3 +272,93 @@ pub async fn get_settings(id: &str, state: State<'_, Nostr>) -> Result<String, S
     Err("Get settings failed".into())
   }
 }
+
+#[tauri::command]
+pub async fn get_nwc_status(state: State<'_, Nostr>) -> Result<bool, ()> {
+  let client = &state.client;
+  let zapper = client.zapper().await.is_ok();
+
+  Ok(zapper)
+}
+
+#[tauri::command]
+pub async fn set_nwc(uri: &str, state: State<'_, Nostr>) -> Result<bool, String> {
+  let client = &state.client;
+
+  if let Ok(uri) = NostrWalletConnectURI::from_str(&uri) {
+    if let Ok(nwc) = NWC::new(uri).await {
+      let _ = client.set_zapper(nwc);
+      Ok(true)
+    } else {
+      Ok(false)
+    }
+  } else {
+    Err("Set NWC failed".into())
+  }
+}
+
+#[tauri::command]
+pub async fn zap_profile(
+  id: &str,
+  amount: u64,
+  message: &str,
+  state: State<'_, Nostr>,
+) -> Result<bool, String> {
+  let client = &state.client;
+  let public_key: Option<PublicKey> = match Nip19::from_bech32(id) {
+    Ok(val) => match val {
+      Nip19::Pubkey(pubkey) => Some(pubkey),
+      Nip19::Profile(profile) => Some(profile.public_key),
+      _ => None,
+    },
+    Err(_) => match PublicKey::from_str(id) {
+      Ok(val) => Some(val),
+      Err(_) => None,
+    },
+  };
+
+  if let Some(recipient) = public_key {
+    let details = ZapDetails::new(ZapType::Public).message(message);
+
+    if let Ok(_) = client.zap(recipient, amount, Some(details)).await {
+      Ok(true)
+    } else {
+      Err("Zap profile failed".into())
+    }
+  } else {
+    Err("Parse public key failed".into())
+  }
+}
+
+#[tauri::command]
+pub async fn zap_event(
+  id: &str,
+  amount: u64,
+  message: &str,
+  state: State<'_, Nostr>,
+) -> Result<bool, String> {
+  let client = &state.client;
+  let event_id: Option<EventId> = match Nip19::from_bech32(id) {
+    Ok(val) => match val {
+      Nip19::EventId(id) => Some(id),
+      Nip19::Event(event) => Some(event.event_id),
+      _ => None,
+    },
+    Err(_) => match EventId::from_hex(id) {
+      Ok(val) => Some(val),
+      Err(_) => None,
+    },
+  };
+
+  if let Some(recipient) = event_id {
+    let details = ZapDetails::new(ZapType::Public).message(message);
+
+    if let Ok(_) = client.zap(recipient, amount, Some(details)).await {
+      Ok(true)
+    } else {
+      Err("Zap event failed".into())
+    }
+  } else {
+    Err("Parse public key failed".into())
+  }
+}