feat: upgrade to tauri v2 rc

src-tauri/src/commands/event.rs

@@ -0,0 +1,685 @@
+use futures::future::join_all;
+use nostr_sdk::prelude::*;
+use serde::Serialize;
+use specta::Type;
+use std::{str::FromStr, time::Duration};
+use tauri::State;
+
+use crate::common::{create_event_tags, dedup_event, parse_event, Meta};
+use crate::{Nostr, FETCH_LIMIT};
+
+#[derive(Debug, Clone, Serialize, Type)]
+pub struct RichEvent {
+    pub raw: String,
+    pub parsed: Option<Meta>,
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_event_meta(content: &str) -> Result<Meta, ()> {
+    let meta = parse_event(content).await;
+    Ok(meta)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_event(id: &str, state: State<'_, Nostr>) -> Result<RichEvent, String> {
+    let client = &state.client;
+
+    let event_id = match Nip19::from_bech32(id) {
+        Ok(val) => match val {
+            Nip19::EventId(id) => id,
+            Nip19::Event(event) => event.event_id,
+            _ => return Err("Event ID is not valid.".into()),
+        },
+        Err(_) => match EventId::from_hex(id) {
+            Ok(id) => id,
+            Err(_) => return Err("Event ID is not valid.".into()),
+        },
+    };
+
+    match client
+        .get_events_of(vec![Filter::new().id(event_id)], None)
+        .await
+    {
+        Ok(events) => {
+            if let Some(event) = events.first() {
+                let raw = event.as_json();
+                let parsed = if event.kind == Kind::TextNote {
+                    Some(parse_event(&event.content).await)
+                } else {
+                    None
+                };
+
+                Ok(RichEvent { raw, parsed })
+            } else {
+                Err("Cannot found this event with current relay list".into())
+            }
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_event_from(
+    id: &str,
+    relay_hint: &str,
+    state: State<'_, Nostr>,
+) -> Result<RichEvent, String> {
+    let client = &state.client;
+    let settings = state
+        .settings
+        .lock()
+        .map_err(|err| err.to_string())?
+        .clone();
+
+    let event_id = match Nip19::from_bech32(id) {
+        Ok(val) => match val {
+            Nip19::EventId(id) => id,
+            Nip19::Event(event) => event.event_id,
+            _ => return Err("Event ID is not valid.".into()),
+        },
+        Err(_) => match EventId::from_hex(id) {
+            Ok(id) => id,
+            Err(_) => return Err("Event ID is not valid.".into()),
+        },
+    };
+
+    if !settings.use_relay_hint {
+        match client
+            .get_events_of(vec![Filter::new().id(event_id)], None)
+            .await
+        {
+            Ok(events) => {
+                if let Some(event) = events.first() {
+                    let raw = event.as_json();
+                    let parsed = if event.kind == Kind::TextNote {
+                        Some(parse_event(&event.content).await)
+                    } else {
+                        None
+                    };
+
+                    Ok(RichEvent { raw, parsed })
+                } else {
+                    Err("Cannot found this event with current relay list".into())
+                }
+            }
+            Err(err) => Err(err.to_string()),
+        }
+    } else {
+        // Add relay hint to relay pool
+        if let Err(err) = client.add_relay(relay_hint).await {
+            return Err(err.to_string());
+        }
+
+        if client.connect_relay(relay_hint).await.is_ok() {
+            match client
+                .get_events_from(vec![relay_hint], vec![Filter::new().id(event_id)], None)
+                .await
+            {
+                Ok(events) => {
+                    if let Some(event) = events.first() {
+                        let raw = event.as_json();
+                        let parsed = if event.kind == Kind::TextNote {
+                            Some(parse_event(&event.content).await)
+                        } else {
+                            None
+                        };
+
+                        Ok(RichEvent { raw, parsed })
+                    } else {
+                        Err("Cannot found this event with current relay list".into())
+                    }
+                }
+                Err(err) => Err(err.to_string()),
+            }
+        } else {
+            Err("Relay connection failed.".into())
+        }
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_replies(id: &str, state: State<'_, Nostr>) -> Result<Vec<RichEvent>, String> {
+    let client = &state.client;
+
+    let event_id = match EventId::from_hex(id) {
+        Ok(id) => id,
+        Err(err) => return Err(err.to_string()),
+    };
+
+    let filter = Filter::new().kinds(vec![Kind::TextNote]).event(event_id);
+
+    match client.get_events_of(vec![filter], None).await {
+        Ok(events) => {
+            let futures = events.into_iter().map(|ev| async move {
+                let raw = ev.as_json();
+                let parsed = if ev.kind == Kind::TextNote {
+                    Some(parse_event(&ev.content).await)
+                } else {
+                    None
+                };
+
+                RichEvent { raw, parsed }
+            });
+            let rich_events = join_all(futures).await;
+
+            Ok(rich_events)
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn listen_event_reply(id: &str, state: State<'_, Nostr>) -> Result<(), String> {
+    let client = &state.client;
+
+    let mut label = "event-".to_owned();
+    label.push_str(id);
+
+    let sub_id = SubscriptionId::new(label);
+    let event_id = match EventId::from_hex(id) {
+        Ok(id) => id,
+        Err(err) => return Err(err.to_string()),
+    };
+    let filter = Filter::new()
+        .kinds(vec![Kind::TextNote])
+        .event(event_id)
+        .since(Timestamp::now());
+
+    // Subscribe
+    let _ = client.subscribe_with_id(sub_id, vec![filter], None).await;
+
+    Ok(())
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_events_by(
+    public_key: &str,
+    as_of: Option<&str>,
+    state: State<'_, Nostr>,
+) -> Result<Vec<RichEvent>, String> {
+    let client = &state.client;
+
+    match PublicKey::from_str(public_key) {
+        Ok(author) => {
+            let until = match as_of {
+                Some(until) => Timestamp::from_str(until).map_err(|err| err.to_string())?,
+                None => Timestamp::now(),
+            };
+            let filter = Filter::new()
+                .kinds(vec![Kind::TextNote, Kind::Repost])
+                .author(author)
+                .limit(FETCH_LIMIT)
+                .until(until);
+
+            match client.get_events_of(vec![filter], None).await {
+                Ok(events) => {
+                    let futures = events.into_iter().map(|ev| async move {
+                        let raw = ev.as_json();
+                        let parsed = if ev.kind == Kind::TextNote {
+                            Some(parse_event(&ev.content).await)
+                        } else {
+                            None
+                        };
+
+                        RichEvent { raw, parsed }
+                    });
+                    let rich_events = join_all(futures).await;
+
+                    Ok(rich_events)
+                }
+                Err(err) => Err(err.to_string()),
+            }
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_local_events(
+    until: Option<&str>,
+    state: State<'_, Nostr>,
+) -> Result<Vec<RichEvent>, String> {
+    let client = &state.client;
+    let contact_list = state
+        .contact_list
+        .lock()
+        .map_err(|err| err.to_string())?
+        .clone();
+
+    let as_of = match until {
+        Some(until) => Timestamp::from_str(until).map_err(|err| err.to_string())?,
+        None => Timestamp::now(),
+    };
+
+    let authors: Vec<PublicKey> = contact_list.into_iter().map(|f| f.public_key).collect();
+
+    let filter = Filter::new()
+        .kinds(vec![Kind::TextNote, Kind::Repost])
+        .limit(64)
+        .until(as_of)
+        .authors(authors);
+
+    match client.database().query(vec![filter], Order::Desc).await {
+        Ok(events) => {
+            let dedup = dedup_event(&events);
+            let futures = dedup.into_iter().map(|ev| async move {
+                let raw = ev.as_json();
+                let parsed = if ev.kind == Kind::TextNote {
+                    Some(parse_event(&ev.content).await)
+                } else {
+                    None
+                };
+
+                RichEvent { raw, parsed }
+            });
+            let rich_events = join_all(futures).await;
+
+            Ok(rich_events)
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn listen_local_event(label: &str, state: State<'_, Nostr>) -> Result<(), String> {
+    let client = &state.client;
+
+    let contact_list = state
+        .contact_list
+        .lock()
+        .map_err(|err| err.to_string())?
+        .clone();
+
+    let authors: Vec<PublicKey> = contact_list.into_iter().map(|f| f.public_key).collect();
+    let sub_id = SubscriptionId::new(label);
+
+    let filter = Filter::new()
+        .kinds(vec![Kind::TextNote, Kind::Repost])
+        .authors(authors)
+        .since(Timestamp::now());
+
+    // Subscribe
+    let _ = client.subscribe_with_id(sub_id, vec![filter], None).await;
+
+    Ok(())
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_group_events(
+    public_keys: Vec<&str>,
+    until: Option<&str>,
+    state: State<'_, Nostr>,
+) -> Result<Vec<RichEvent>, String> {
+    let client = &state.client;
+
+    let as_of = match until {
+        Some(until) => Timestamp::from_str(until).map_err(|err| err.to_string())?,
+        None => Timestamp::now(),
+    };
+
+    let authors: Vec<PublicKey> = public_keys
+        .into_iter()
+        .map(|p| {
+            if p.starts_with("npub1") {
+                PublicKey::from_bech32(p).map_err(|err| err.to_string())
+            } else {
+                PublicKey::from_hex(p).map_err(|err| err.to_string())
+            }
+        })
+        .collect::<Result<Vec<_>, _>>()?;
+
+    let filter = Filter::new()
+        .kinds(vec![Kind::TextNote, Kind::Repost])
+        .limit(FETCH_LIMIT)
+        .until(as_of)
+        .authors(authors);
+
+    match client
+        .get_events_of(vec![filter], Some(Duration::from_secs(10)))
+        .await
+    {
+        Ok(events) => {
+            let dedup = dedup_event(&events);
+
+            let futures = dedup.into_iter().map(|ev| async move {
+                let raw = ev.as_json();
+                let parsed = if ev.kind == Kind::TextNote {
+                    Some(parse_event(&ev.content).await)
+                } else {
+                    None
+                };
+
+                RichEvent { raw, parsed }
+            });
+
+            let rich_events = join_all(futures).await;
+
+            Ok(rich_events)
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_global_events(
+    until: Option<&str>,
+    state: State<'_, Nostr>,
+) -> Result<Vec<RichEvent>, String> {
+    let client = &state.client;
+    let as_of = match until {
+        Some(until) => Timestamp::from_str(until).map_err(|err| err.to_string())?,
+        None => Timestamp::now(),
+    };
+
+    let filter = Filter::new()
+        .kinds(vec![Kind::TextNote, Kind::Repost])
+        .limit(FETCH_LIMIT)
+        .until(as_of);
+
+    match client
+        .get_events_of(vec![filter], Some(Duration::from_secs(8)))
+        .await
+    {
+        Ok(events) => {
+            let dedup = dedup_event(&events);
+            let futures = dedup.into_iter().map(|ev| async move {
+                let raw = ev.as_json();
+                let parsed = if ev.kind == Kind::TextNote {
+                    Some(parse_event(&ev.content).await)
+                } else {
+                    None
+                };
+
+                RichEvent { raw, parsed }
+            });
+            let rich_events = join_all(futures).await;
+
+            Ok(rich_events)
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_hashtag_events(
+    hashtags: Vec<&str>,
+    until: Option<&str>,
+    state: State<'_, Nostr>,
+) -> Result<Vec<RichEvent>, String> {
+    let client = &state.client;
+    let as_of = match until {
+        Some(until) => Timestamp::from_str(until).map_err(|err| err.to_string())?,
+        None => Timestamp::now(),
+    };
+    let filter = Filter::new()
+        .kinds(vec![Kind::TextNote, Kind::Repost])
+        .limit(FETCH_LIMIT)
+        .until(as_of)
+        .hashtags(hashtags);
+
+    match client.get_events_of(vec![filter], None).await {
+        Ok(events) => {
+            let dedup = dedup_event(&events);
+            let futures = dedup.into_iter().map(|ev| async move {
+                let raw = ev.as_json();
+                let parsed = if ev.kind == Kind::TextNote {
+                    Some(parse_event(&ev.content).await)
+                } else {
+                    None
+                };
+
+                RichEvent { raw, parsed }
+            });
+            let rich_events = join_all(futures).await;
+
+            Ok(rich_events)
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn publish(
+    content: String,
+    warning: Option<String>,
+    difficulty: Option<u8>,
+    state: State<'_, Nostr>,
+) -> Result<String, String> {
+    let client = &state.client;
+
+    // Create tags from content
+    let mut tags = create_event_tags(&content);
+
+    // Add content-warning tag if present
+    if let Some(reason) = warning {
+        let t = TagStandard::ContentWarning {
+            reason: Some(reason),
+        };
+        let tag = Tag::from(t);
+        tags.push(tag)
+    };
+
+    // Get signer
+    let signer = match client.signer().await {
+        Ok(signer) => signer,
+        Err(_) => return Err("Signer is required.".into()),
+    };
+
+    // Get public key
+    let public_key = signer.public_key().await.map_err(|err| err.to_string())?;
+
+    // Create unsigned event
+    let unsigned_event = match difficulty {
+        Some(num) => EventBuilder::text_note(content, tags).to_unsigned_pow_event(public_key, num),
+        None => EventBuilder::text_note(content, tags).to_unsigned_event(public_key),
+    };
+
+    // Publish
+    match signer.sign_event(unsigned_event).await {
+        Ok(event) => match client.send_event(event).await {
+            Ok(event_id) => Ok(event_id.to_bech32().map_err(|err| err.to_string())?),
+            Err(err) => Err(err.to_string()),
+        },
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn reply(
+    content: String,
+    to: String,
+    root: Option<String>,
+    state: State<'_, Nostr>,
+) -> Result<String, String> {
+    let client = &state.client;
+    let database = client.database();
+
+    // Create tags from content
+    let mut tags = create_event_tags(&content);
+
+    let reply_id = match EventId::from_hex(to) {
+        Ok(val) => val,
+        Err(_) => return Err("Event is not valid.".into()),
+    };
+
+    match database
+        .query(vec![Filter::new().id(reply_id)], Order::Desc)
+        .await
+    {
+        Ok(events) => {
+            if let Some(event) = events.into_iter().next() {
+                let relay_hint = if let Some(relays) = database
+                    .event_seen_on_relays(event.id)
+                    .await
+                    .map_err(|err| err.to_string())?
+                {
+                    relays.into_iter().next().map(UncheckedUrl::new)
+                } else {
+                    None
+                };
+                let t = TagStandard::Event {
+                    event_id: event.id,
+                    relay_url: relay_hint,
+                    marker: Some(Marker::Reply),
+                    public_key: Some(event.pubkey),
+                };
+                let tag = Tag::from(t);
+                tags.push(tag)
+            } else {
+                return Err("Reply event is not found.".into());
+            }
+        }
+        Err(err) => return Err(err.to_string()),
+    };
+
+    if let Some(id) = root {
+        let root_id = match EventId::from_hex(id) {
+            Ok(val) => val,
+            Err(_) => return Err("Event is not valid.".into()),
+        };
+
+        if let Ok(events) = database
+            .query(vec![Filter::new().id(root_id)], Order::Desc)
+            .await
+        {
+            if let Some(event) = events.into_iter().next() {
+                let relay_hint = if let Some(relays) = database
+                    .event_seen_on_relays(event.id)
+                    .await
+                    .map_err(|err| err.to_string())?
+                {
+                    relays.into_iter().next().map(UncheckedUrl::new)
+                } else {
+                    None
+                };
+                let t = TagStandard::Event {
+                    event_id: event.id,
+                    relay_url: relay_hint,
+                    marker: Some(Marker::Root),
+                    public_key: Some(event.pubkey),
+                };
+                let tag = Tag::from(t);
+                tags.push(tag)
+            }
+        }
+    };
+
+    match client.publish_text_note(content, tags).await {
+        Ok(event_id) => Ok(event_id.to_bech32().map_err(|err| err.to_string())?),
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn repost(raw: &str, state: State<'_, Nostr>) -> Result<String, String> {
+    let client = &state.client;
+    let event = Event::from_json(raw).map_err(|err| err.to_string())?;
+
+    match client.repost(&event, None).await {
+        Ok(event_id) => Ok(event_id.to_string()),
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn event_to_bech32(id: &str, state: State<'_, Nostr>) -> Result<String, String> {
+    let client = &state.client;
+
+    let event_id = match EventId::from_hex(id) {
+        Ok(id) => id,
+        Err(_) => return Err("ID is not valid.".into()),
+    };
+
+    let seens = client
+        .database()
+        .event_seen_on_relays(event_id)
+        .await
+        .map_err(|err| err.to_string())?;
+
+    match seens {
+        Some(set) => {
+            let relays = set.into_iter().collect::<Vec<_>>();
+            let event = Nip19Event::new(event_id, relays);
+
+            match event.to_bech32() {
+                Ok(id) => Ok(id),
+                Err(err) => Err(err.to_string()),
+            }
+        }
+        None => match event_id.to_bech32() {
+            Ok(id) => Ok(id),
+            Err(err) => Err(err.to_string()),
+        },
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn user_to_bech32(user: &str, state: State<'_, Nostr>) -> Result<String, String> {
+    let client = &state.client;
+
+    let public_key = match PublicKey::from_str(user) {
+        Ok(pk) => pk,
+        Err(_) => return Err("Public Key is not valid.".into()),
+    };
+
+    match client
+        .get_events_of(
+            vec![Filter::new()
+                .author(public_key)
+                .kind(Kind::RelayList)
+                .limit(1)],
+            Some(Duration::from_secs(10)),
+        )
+        .await
+    {
+        Ok(events) => match events.first() {
+            Some(event) => {
+                let relay_list = nip65::extract_relay_list(event);
+                let relays = relay_list
+                    .into_iter()
+                    .map(|i| i.0.to_string())
+                    .collect::<Vec<_>>();
+                let profile =
+                    Nip19Profile::new(public_key, relays).map_err(|err| err.to_string())?;
+
+                Ok(profile.to_bech32().map_err(|err| err.to_string())?)
+            }
+            None => match public_key.to_bech32() {
+                Ok(pk) => Ok(pk),
+                Err(err) => Err(err.to_string()),
+            },
+        },
+        Err(_) => match public_key.to_bech32() {
+            Ok(pk) => Ok(pk),
+            Err(err) => Err(err.to_string()),
+        },
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn unlisten(id: &str, state: State<'_, Nostr>) -> Result<(), ()> {
+    let client = &state.client;
+    let sub_id = SubscriptionId::new(id);
+
+    // Remove subscription
+    client.unsubscribe(sub_id).await;
+
+    Ok(())
+}

src-tauri/src/commands/fns.rs

@@ -1,174 +0,0 @@
-use std::ffi::CString;
-
-use tauri::{AppHandle, Emitter, Listener, Manager, WebviewWindow};
-use tauri_nspanel::{
-    block::ConcreteBlock,
-    cocoa::{
-        appkit::{NSMainMenuWindowLevel, NSView, NSWindow, NSWindowCollectionBehavior},
-        base::{id, nil},
-        foundation::{NSPoint, NSRect},
-    },
-    objc::{class, msg_send, runtime::NO, sel, sel_impl},
-    panel_delegate, ManagerExt, WebviewWindowExt,
-};
-
-#[allow(non_upper_case_globals)]
-const NSWindowStyleMaskNonActivatingPanel: i32 = 1 << 7;
-
-pub fn swizzle_to_menubar_panel(app_handle: &tauri::AppHandle) {
-    let panel_delegate = panel_delegate!(SpotlightPanelDelegate {
-        window_did_resign_key
-    });
-
-    let window = app_handle.get_webview_window("panel").unwrap();
-
-    let panel = window.to_panel().unwrap();
-
-    let handle = app_handle.clone();
-
-    panel_delegate.set_listener(Box::new(move |delegate_name: String| {
-        if delegate_name.as_str() == "window_did_resign_key" {
-            let _ = handle.emit("menubar_panel_did_resign_key", ());
-        }
-    }));
-
-    panel.set_level(NSMainMenuWindowLevel + 1);
-
-    panel.set_style_mask(NSWindowStyleMaskNonActivatingPanel);
-
-    panel.set_collection_behaviour(
-        NSWindowCollectionBehavior::NSWindowCollectionBehaviorCanJoinAllSpaces
-            | NSWindowCollectionBehavior::NSWindowCollectionBehaviorStationary
-            | NSWindowCollectionBehavior::NSWindowCollectionBehaviorFullScreenAuxiliary,
-    );
-
-    panel.set_delegate(panel_delegate);
-}
-
-pub fn setup_menubar_panel_listeners(app_handle: &AppHandle) {
-    fn hide_menubar_panel(app_handle: &tauri::AppHandle) {
-        if check_menubar_frontmost() {
-            return;
-        }
-
-        let panel = app_handle.get_webview_panel("panel").unwrap();
-
-        panel.order_out(None);
-    }
-
-    let handle = app_handle.clone();
-
-    app_handle.listen_any("menubar_panel_did_resign_key", move |_| {
-        hide_menubar_panel(&handle);
-    });
-
-    let handle = app_handle.clone();
-
-    let callback = Box::new(move || {
-        hide_menubar_panel(&handle);
-    });
-
-    register_workspace_listener(
-        "NSWorkspaceDidActivateApplicationNotification".into(),
-        callback.clone(),
-    );
-
-    register_workspace_listener(
-        "NSWorkspaceActiveSpaceDidChangeNotification".into(),
-        callback,
-    );
-}
-
-pub fn set_corner_radius(window: &WebviewWindow, radius: f64) {
-    let win: id = window.ns_window().unwrap() as _;
-
-    unsafe {
-        let view: id = win.contentView();
-
-        view.wantsLayer();
-
-        let layer: id = view.layer();
-
-        let _: () = msg_send![layer, setCornerRadius: radius];
-    }
-}
-
-pub fn position_menubar_panel(app_handle: &tauri::AppHandle, padding_top: f64) {
-    let window = app_handle.get_webview_window("panel").unwrap();
-
-    let monitor = monitor::get_monitor_with_cursor().unwrap();
-
-    let scale_factor = monitor.scale_factor();
-
-    let visible_area = monitor.visible_area();
-
-    let monitor_pos = visible_area.position().to_logical::<f64>(scale_factor);
-
-    let monitor_size = visible_area.size().to_logical::<f64>(scale_factor);
-
-    let mouse_location: NSPoint = unsafe { msg_send![class!(NSEvent), mouseLocation] };
-
-    let handle: id = window.ns_window().unwrap() as _;
-
-    let mut win_frame: NSRect = unsafe { msg_send![handle, frame] };
-
-    win_frame.origin.y = (monitor_pos.y + monitor_size.height) - win_frame.size.height;
-
-    win_frame.origin.y -= padding_top;
-
-    win_frame.origin.x = {
-        let top_right = mouse_location.x + (win_frame.size.width / 2.0);
-
-        let is_offscreen = top_right > monitor_pos.x + monitor_size.width;
-
-        if !is_offscreen {
-            mouse_location.x - (win_frame.size.width / 2.0)
-        } else {
-            let diff = top_right - (monitor_pos.x + monitor_size.width);
-
-            mouse_location.x - (win_frame.size.width / 2.0) - diff
-        }
-    };
-
-    let _: () = unsafe { msg_send![handle, setFrame: win_frame display: NO] };
-}
-
-fn register_workspace_listener(name: String, callback: Box<dyn Fn()>) {
-    let workspace: id = unsafe { msg_send![class!(NSWorkspace), sharedWorkspace] };
-    let notification_center: id = unsafe { msg_send![workspace, notificationCenter] };
-
-    let block = ConcreteBlock::new(move |_notif: id| {
-        callback();
-    });
-
-    let block = block.copy();
-
-    let name: id =
-        unsafe { msg_send![class!(NSString), stringWithCString: CString::new(name).unwrap()] };
-
-    unsafe {
-        let _: () = msg_send![
-            notification_center,
-            addObserverForName: name object: nil queue: nil usingBlock: block
-        ];
-    }
-}
-
-fn app_pid() -> i32 {
-    let process_info: id = unsafe { msg_send![class!(NSProcessInfo), processInfo] };
-    let pid: i32 = unsafe { msg_send![process_info, processIdentifier] };
-
-    pid
-}
-
-fn get_frontmost_app_pid() -> i32 {
-    let workspace: id = unsafe { msg_send![class!(NSWorkspace), sharedWorkspace] };
-    let frontmost_application: id = unsafe { msg_send![workspace, frontmostApplication] };
-    let pid: i32 = unsafe { msg_send![frontmost_application, processIdentifier] };
-
-    pid
-}
-
-pub fn check_menubar_frontmost() -> bool {
-    get_frontmost_app_pid() == app_pid()
-}

src-tauri/src/commands/keys.rs

@@ -0,0 +1,422 @@
+#[cfg(target_os = "macos")]
+use crate::commands::tray::create_tray_panel;
+use crate::common::{get_user_settings, init_nip65, parse_event};
+use crate::{Nostr, RichEvent, NEWSFEED_NEG_LIMIT, NOTIFICATION_NEG_LIMIT};
+
+use keyring::Entry;
+use keyring_search::{Limit, List, Search};
+use nostr_sdk::prelude::*;
+use serde::Serialize;
+use specta::Type;
+use std::collections::HashSet;
+use std::time::Duration;
+use tauri::{Emitter, EventTarget, Manager, State};
+use tauri_plugin_notification::NotificationExt;
+
+#[derive(Serialize, Type)]
+pub struct Account {
+    npub: String,
+    nsec: String,
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn get_accounts() -> Vec<String> {
+    let search = Search::new().expect("Unexpected.");
+    let results = search.by_service("Lume");
+    let list = List::list_credentials(&results, Limit::All);
+    let accounts: HashSet<String> = list
+        .split_whitespace()
+        .filter(|v| v.starts_with("npub1"))
+        .map(String::from)
+        .collect();
+
+    accounts.into_iter().collect()
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn create_account() -> Result<Account, String> {
+    let keys = Keys::generate();
+    let public_key = keys.public_key();
+    let secret_key = keys.secret_key().unwrap();
+
+    let result = Account {
+        npub: public_key.to_bech32().unwrap(),
+        nsec: secret_key.to_bech32().unwrap(),
+    };
+
+    Ok(result)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn get_private_key(npub: &str) -> Result<String, String> {
+    let keyring = Entry::new("Lume", npub).unwrap();
+
+    if let Ok(nsec) = keyring.get_password() {
+        let secret_key = SecretKey::from_bech32(nsec).unwrap();
+        Ok(secret_key.to_bech32().unwrap())
+    } else {
+        Err("Key not found".into())
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn save_account(
+    nsec: &str,
+    password: &str,
+    state: State<'_, Nostr>,
+) -> Result<String, String> {
+    let secret_key = if nsec.starts_with("ncryptsec") {
+        let encrypted_key = EncryptedSecretKey::from_bech32(nsec).unwrap();
+        encrypted_key
+            .to_secret_key(password)
+            .map_err(|err| err.to_string())
+    } else {
+        SecretKey::from_bech32(nsec).map_err(|err| err.to_string())
+    };
+
+    match secret_key {
+        Ok(val) => {
+            let nostr_keys = Keys::new(val);
+            let npub = nostr_keys.public_key().to_bech32().unwrap();
+            let nsec = nostr_keys.secret_key().unwrap().to_bech32().unwrap();
+
+            let keyring = Entry::new("Lume", &npub).unwrap();
+            let _ = keyring.set_password(&nsec);
+
+            let signer = NostrSigner::Keys(nostr_keys);
+            let client = &state.client;
+
+            // Update client's signer
+            client.set_signer(Some(signer)).await;
+
+            Ok(npub)
+        }
+        Err(msg) => Err(msg),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn connect_remote_account(uri: &str, state: State<'_, Nostr>) -> Result<String, String> {
+    let client = &state.client;
+
+    match NostrConnectURI::parse(uri) {
+        Ok(bunker_uri) => {
+            let app_keys = Keys::generate();
+            let app_secret = app_keys.secret_key().unwrap().to_string();
+
+            // Get remote user
+            let remote_user = bunker_uri.signer_public_key().unwrap();
+            let remote_npub = remote_user.to_bech32().unwrap();
+
+            match Nip46Signer::new(bunker_uri, app_keys, Duration::from_secs(120), None).await {
+                Ok(signer) => {
+                    let keyring = Entry::new("Lume", &remote_npub).unwrap();
+                    let _ = keyring.set_password(&app_secret);
+
+                    // Update signer
+                    let _ = client.set_signer(Some(signer.into())).await;
+
+                    Ok(remote_npub)
+                }
+                Err(err) => Err(err.to_string()),
+            }
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_encrypted_key(npub: &str, password: &str) -> Result<String, String> {
+    let keyring = Entry::new("Lume", npub).unwrap();
+
+    if let Ok(nsec) = keyring.get_password() {
+        let secret_key = SecretKey::from_bech32(nsec).unwrap();
+        let new_key = EncryptedSecretKey::new(&secret_key, password, 16, KeySecurity::Medium);
+
+        if let Ok(key) = new_key {
+            Ok(key.to_bech32().unwrap())
+        } else {
+            Err("Encrypt key failed".into())
+        }
+    } else {
+        Err("Key not found".into())
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn load_account(
+    npub: &str,
+    bunker: Option<&str>,
+    state: State<'_, Nostr>,
+    app: tauri::AppHandle,
+) -> Result<bool, String> {
+    let handle = app.clone();
+    let client = &state.client;
+    let keyring = Entry::new("Lume", npub).unwrap();
+
+    let password = match keyring.get_password() {
+        Ok(pw) => pw,
+        Err(_) => return Err("Cancelled".into()),
+    };
+
+    match bunker {
+        Some(uri) => {
+            let app_keys =
+                Keys::parse(password).expect("Secret Key is modified, please check again.");
+
+            match NostrConnectURI::parse(uri) {
+                Ok(bunker_uri) => {
+                    match Nip46Signer::new(bunker_uri, app_keys, Duration::from_secs(30), None)
+                        .await
+                    {
+                        Ok(signer) => client.set_signer(Some(signer.into())).await,
+                        Err(err) => return Err(err.to_string()),
+                    }
+                }
+                Err(err) => return Err(err.to_string()),
+            }
+        }
+        None => {
+            let keys = Keys::parse(password).expect("Secret Key is modified, please check again.");
+            let signer = NostrSigner::Keys(keys);
+
+            // Update signer
+            client.set_signer(Some(signer)).await;
+        }
+    }
+
+    // Connect to user's relay (NIP-65)
+    init_nip65(client).await;
+
+    // Create tray (macOS)
+    #[cfg(target_os = "macos")]
+    create_tray_panel(npub, &handle);
+
+    // Get user's contact list
+    if let Ok(contacts) = client.get_contact_list(None).await {
+        *state.contact_list.lock().unwrap() = contacts
+    };
+
+    // Get user's settings
+    if let Ok(settings) = get_user_settings(client).await {
+        *state.settings.lock().unwrap() = settings
+    };
+
+    tauri::async_runtime::spawn(async move {
+        let window = handle.get_window("main").unwrap();
+
+        let state = window.state::<Nostr>();
+        let client = &state.client;
+        let contact_list = state.contact_list.lock().unwrap().clone();
+
+        let signer = client.signer().await.unwrap();
+        let public_key = signer.public_key().await.unwrap();
+
+        if !contact_list.is_empty() {
+            let authors: Vec<PublicKey> = contact_list.into_iter().map(|f| f.public_key).collect();
+
+            match client
+                .reconcile(
+                    Filter::new()
+                        .authors(authors)
+                        .kinds(vec![Kind::TextNote, Kind::Repost])
+                        .limit(NEWSFEED_NEG_LIMIT),
+                    NegentropyOptions::default(),
+                )
+                .await
+            {
+                Ok(_) => {
+                    if handle.emit_to(EventTarget::Any, "synced", true).is_err() {
+                        println!("Emit event failed.")
+                    }
+                }
+                Err(_) => println!("Sync newsfeed failed."),
+            }
+        };
+
+        match client
+            .reconcile(
+                Filter::new()
+                    .pubkey(public_key)
+                    .kinds(vec![
+                        Kind::TextNote,
+                        Kind::Repost,
+                        Kind::Reaction,
+                        Kind::ZapReceipt,
+                    ])
+                    .limit(NOTIFICATION_NEG_LIMIT),
+                NegentropyOptions::default(),
+            )
+            .await
+        {
+            Ok(_) => {
+                if handle.emit_to(EventTarget::Any, "synced", true).is_err() {
+                    println!("Emit event failed.")
+                }
+            }
+            Err(_) => println!("Sync notification failed."),
+        };
+
+        let subscription_id = SubscriptionId::new("notification");
+        let subscription = Filter::new()
+            .pubkey(public_key)
+            .kinds(vec![
+                Kind::TextNote,
+                Kind::Repost,
+                Kind::Reaction,
+                Kind::ZapReceipt,
+            ])
+            .since(Timestamp::now());
+
+        // Subscribing for new notification...
+        let _ = client
+            .subscribe_with_id(subscription_id, vec![subscription], None)
+            .await;
+
+        // Handle notifications
+        client
+            .handle_notifications(|notification| async {
+                if let RelayPoolNotification::Message { message, .. } = notification {
+                    if let RelayMessage::Event {
+                        subscription_id,
+                        event,
+                    } = message
+                    {
+                        let id = subscription_id.to_string();
+
+                        if id.starts_with("notification") {
+                            if app
+                                .emit_to(
+                                    EventTarget::window("panel"),
+                                    "notification",
+                                    event.as_json(),
+                                )
+                                .is_err()
+                            {
+                                println!("Emit new notification failed.")
+                            }
+
+                            let handle = app.app_handle();
+                            let author = client.metadata(event.pubkey).await.unwrap();
+
+                            match event.kind() {
+                                Kind::TextNote => {
+                                    if let Err(e) = handle
+                                        .notification()
+                                        .builder()
+                                        .body("Mentioned you in a thread.")
+                                        .title(
+                                            author
+                                                .display_name
+                                                .unwrap_or_else(|| "Lume".to_string()),
+                                        )
+                                        .show()
+                                    {
+                                        println!("Failed to show notification: {:?}", e);
+                                    }
+                                }
+                                Kind::Repost => {
+                                    if let Err(e) = handle
+                                        .notification()
+                                        .builder()
+                                        .body("Reposted your note.")
+                                        .title(
+                                            author
+                                                .display_name
+                                                .unwrap_or_else(|| "Lume".to_string()),
+                                        )
+                                        .show()
+                                    {
+                                        println!("Failed to show notification: {:?}", e);
+                                    }
+                                }
+                                Kind::Reaction => {
+                                    let content = event.content();
+                                    if let Err(e) = handle
+                                        .notification()
+                                        .builder()
+                                        .body(content)
+                                        .title(
+                                            author
+                                                .display_name
+                                                .unwrap_or_else(|| "Lume".to_string()),
+                                        )
+                                        .show()
+                                    {
+                                        println!("Failed to show notification: {:?}", e);
+                                    }
+                                }
+                                Kind::ZapReceipt => {
+                                    if let Err(e) = handle
+                                        .notification()
+                                        .builder()
+                                        .body("Zapped you.")
+                                        .title(
+                                            author
+                                                .display_name
+                                                .unwrap_or_else(|| "Lume".to_string()),
+                                        )
+                                        .show()
+                                    {
+                                        println!("Failed to show notification: {:?}", e);
+                                    }
+                                }
+                                _ => {}
+                            }
+                        } else if id.starts_with("event-") {
+                            let raw = event.as_json();
+                            let parsed = if event.kind == Kind::TextNote {
+                                Some(parse_event(&event.content).await)
+                            } else {
+                                None
+                            };
+
+                            if app
+                                .emit_to(
+                                    EventTarget::window(id),
+                                    "new_reply",
+                                    RichEvent { raw, parsed },
+                                )
+                                .is_err()
+                            {
+                                println!("Emit new notification failed.")
+                            }
+                        } else if id.starts_with("column-") {
+                            let raw = event.as_json();
+                            let parsed = if event.kind == Kind::TextNote {
+                                Some(parse_event(&event.content).await)
+                            } else {
+                                None
+                            };
+
+                            if app
+                                .emit_to(
+                                    EventTarget::window(id),
+                                    "new_event",
+                                    RichEvent { raw, parsed },
+                                )
+                                .is_err()
+                            {
+                                println!("Emit new notification failed.")
+                            }
+                        } else {
+                            println!("new event: {}", event.as_json())
+                        }
+                    } else {
+                        println!("new message: {}", message.as_json())
+                    }
+                }
+                Ok(false)
+            })
+            .await
+    });
+
+    Ok(true)
+}

src-tauri/src/commands/metadata.rs

@@ -0,0 +1,595 @@
+use keyring::Entry;
+use nostr_sdk::prelude::*;
+use std::{str::FromStr, time::Duration};
+use tauri::State;
+
+use crate::common::get_latest_event;
+use crate::{Nostr, Settings};
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_current_profile(state: State<'_, Nostr>) -> Result<String, String> {
+    let client = &state.client;
+
+    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);
+
+    let events_result = client
+        .get_events_of(vec![filter], Some(Duration::from_secs(10)))
+        .await;
+
+    match events_result {
+        Ok(events) => {
+            if let Some(event) = get_latest_event(&events) {
+                match Metadata::from_json(&event.content) {
+                    Ok(metadata) => Ok(metadata.as_json()),
+                    Err(_) => Err("Failed to parse metadata.".into()),
+                }
+            } else {
+                Err("No matching events found.".into())
+            }
+        }
+        Err(err) => Err(format!("Failed to get events: {}", err)),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_profile(id: &str, state: State<'_, Nostr>) -> Result<String, String> {
+    let client = &state.client;
+    let public_key: Option<PublicKey> = match Nip19::from_bech32(id) {
+        Ok(val) => match val {
+            Nip19::Pubkey(key) => Some(key),
+            Nip19::Profile(profile) => {
+                let relays = profile.relays;
+                for relay in relays.into_iter() {
+                    let _ = client.add_relay(&relay).await.unwrap_or_default();
+                    client.connect_relay(&relay).await.unwrap_or_default();
+                }
+                Some(profile.public_key)
+            }
+            _ => None,
+        },
+        Err(_) => match PublicKey::from_str(id) {
+            Ok(val) => Some(val),
+            Err(_) => None,
+        },
+    };
+
+    if let Some(author) = public_key {
+        let filter = Filter::new().author(author).kind(Kind::Metadata).limit(1);
+        let query = client
+            .get_events_of(vec![filter], Some(Duration::from_secs(10)))
+            .await;
+
+        if let Ok(events) = query {
+            if let Some(event) = events.first() {
+                if let Ok(metadata) = Metadata::from_json(&event.content) {
+                    Ok(metadata.as_json())
+                } else {
+                    Err("Parse metadata failed".into())
+                }
+            } else {
+                let rand_metadata = Metadata::new();
+                Ok(rand_metadata.as_json())
+            }
+        } else {
+            Err("Get metadata failed".into())
+        }
+    } else {
+        Err("Public Key is not valid".into())
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn set_contact_list(
+    public_keys: Vec<&str>,
+    state: State<'_, Nostr>,
+) -> Result<bool, String> {
+    let client = &state.client;
+    let contact_list: Vec<Contact> = public_keys
+        .into_iter()
+        .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 {
+        Ok(_) => Ok(true),
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_contact_list(state: State<'_, Nostr>) -> Result<Vec<String>, String> {
+    let client = &state.client;
+
+    match client.get_contact_list(Some(Duration::from_secs(10))).await {
+        Ok(contact_list) => {
+            if !contact_list.is_empty() {
+                let list = contact_list
+                    .into_iter()
+                    .map(|f| f.public_key.to_hex())
+                    .collect();
+
+                Ok(list)
+            } else {
+                Err("Empty.".into())
+            }
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn create_profile(
+    name: &str,
+    display_name: &str,
+    about: &str,
+    picture: &str,
+    banner: &str,
+    nip05: &str,
+    lud16: &str,
+    website: &str,
+    state: State<'_, Nostr>,
+) -> Result<String, String> {
+    let client = &state.client;
+    let mut metadata = Metadata::new()
+        .name(name)
+        .display_name(display_name)
+        .about(about)
+        .nip05(nip05)
+        .lud16(lud16);
+
+    if let Ok(url) = Url::parse(picture) {
+        metadata = metadata.picture(url)
+    }
+
+    if let Ok(url) = Url::parse(banner) {
+        metadata = metadata.banner(url)
+    }
+
+    if let Ok(url) = Url::parse(website) {
+        metadata = metadata.website(url)
+    }
+
+    if let Ok(event_id) = client.set_metadata(&metadata).await {
+        Ok(event_id.to_string())
+    } else {
+        Err("Create profile failed".into())
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn is_contact_list_empty(state: State<'_, Nostr>) -> Result<bool, ()> {
+    let contact_list = state.contact_list.lock().unwrap();
+    Ok(contact_list.is_empty())
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn check_contact(hex: &str, state: State<'_, Nostr>) -> Result<bool, String> {
+    let contact_list = state.contact_list.lock().unwrap();
+
+    match PublicKey::from_str(hex) {
+        Ok(public_key) => match contact_list.iter().position(|x| x.public_key == public_key) {
+            Some(_) => Ok(true),
+            None => Ok(false),
+        },
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn toggle_contact(
+    hex: &str,
+    alias: Option<&str>,
+    state: State<'_, Nostr>,
+) -> Result<String, String> {
+    let client = &state.client;
+
+    match client.get_contact_list(None).await {
+        Ok(mut contact_list) => {
+            let public_key = PublicKey::from_str(hex).unwrap();
+
+            match contact_list.iter().position(|x| x.public_key == public_key) {
+                Some(index) => {
+                    // Remove contact
+                    contact_list.remove(index);
+                }
+                None => {
+                    // TODO: Add relay_url
+                    let new_contact = Contact::new(public_key, None, alias);
+                    // Add new contact
+                    contact_list.push(new_contact);
+                }
+            }
+
+            // Update local state
+            state.contact_list.lock().unwrap().clone_from(&contact_list);
+
+            // Publish
+            match client.set_contact_list(contact_list).await {
+                Ok(event_id) => Ok(event_id.to_string()),
+                Err(err) => Err(err.to_string()),
+            }
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn set_nstore(
+    key: &str,
+    content: &str,
+    state: State<'_, Nostr>,
+) -> Result<String, String> {
+    let client = &state.client;
+
+    match client.signer().await {
+        Ok(signer) => {
+            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]);
+
+            match client.send_event_builder(builder).await {
+                Ok(event_id) => Ok(event_id.to_string()),
+                Err(err) => Err(err.to_string()),
+            }
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_nstore(key: &str, state: State<'_, Nostr>) -> Result<String, String> {
+    let client = &state.client;
+
+    if let Ok(signer) = client.signer().await {
+        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::ApplicationSpecificData)
+            .identifier(key)
+            .limit(1);
+
+        match client
+            .get_events_of(vec![filter], Some(Duration::from_secs(5)))
+            .await
+        {
+            Ok(events) => {
+                if let Some(event) = events.first() {
+                    let content = event.content();
+                    match signer.nip44_decrypt(public_key, content).await {
+                        Ok(decrypted) => Ok(decrypted),
+                        Err(_) => Err(event.content.to_string()),
+                    }
+                } else {
+                    Err("Value not found".into())
+                }
+            }
+            Err(err) => Err(err.to_string()),
+        }
+    } else {
+        Err("Signer is required".into())
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn set_wallet(uri: &str, state: State<'_, Nostr>) -> Result<bool, String> {
+    let client = &state.client;
+
+    if let Ok(nwc_uri) = NostrWalletConnectURI::from_str(uri) {
+        let nwc = NWC::new(nwc_uri);
+        let keyring = Entry::new("Lume Secret", "Bitcoin Connect").map_err(|e| e.to_string())?;
+        keyring.set_password(uri).map_err(|e| e.to_string())?;
+        client.set_zapper(nwc).await;
+
+        Ok(true)
+    } else {
+        Err("Set NWC failed".into())
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn load_wallet(state: State<'_, Nostr>) -> Result<String, String> {
+    let client = &state.client;
+    let keyring = Entry::new("Lume Secret", "Bitcoin Connect").unwrap();
+
+    match keyring.get_password() {
+        Ok(val) => {
+            let uri = NostrWalletConnectURI::from_str(&val).unwrap();
+            let nwc = NWC::new(uri);
+
+            // Get current balance
+            let balance = nwc.get_balance().await;
+
+            // Update zapper
+            client.set_zapper(nwc).await;
+
+            match balance {
+                Ok(val) => Ok(val.to_string()),
+                Err(_) => Err("Get balance failed.".into()),
+            }
+        }
+        Err(_) => Err("NWC not found.".into()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn remove_wallet(state: State<'_, Nostr>) -> Result<(), ()> {
+    let client = &state.client;
+    let keyring = Entry::new("Lume Secret", "Bitcoin Connect").unwrap();
+
+    match keyring.delete_credential() {
+        Ok(_) => {
+            client.unset_zapper().await;
+            Ok(())
+        }
+        Err(_) => Err(()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn zap_profile(
+    id: &str,
+    amount: &str,
+    message: &str,
+    state: State<'_, Nostr>,
+) -> Result<bool, String> {
+    let client = &state.client;
+    let public_key = match Nip19::from_bech32(id) {
+        Ok(val) => match val {
+            Nip19::Pubkey(key) => key,
+            Nip19::Profile(profile) => profile.public_key,
+            _ => return Err("Public Key is not valid.".into()),
+        },
+        Err(_) => match PublicKey::from_str(id) {
+            Ok(val) => val,
+            Err(_) => return Err("Public Key is not valid.".into()),
+        },
+    };
+
+    let details = ZapDetails::new(ZapType::Private).message(message);
+    let num = match amount.parse::<u64>() {
+        Ok(val) => val,
+        Err(_) => return Err("Invalid amount.".into()),
+    };
+
+    if client.zap(public_key, num, Some(details)).await.is_ok() {
+        Ok(true)
+    } else {
+        Err("Zap profile failed".into())
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn zap_event(
+    id: &str,
+    amount: &str,
+    message: &str,
+    state: State<'_, Nostr>,
+) -> Result<bool, String> {
+    let client = &state.client;
+    let event_id = match Nip19::from_bech32(id) {
+        Ok(val) => match val {
+            Nip19::EventId(id) => id,
+            Nip19::Event(event) => event.event_id,
+            _ => return Err("Event ID is invalid.".into()),
+        },
+        Err(_) => match EventId::from_hex(id) {
+            Ok(val) => val,
+            Err(_) => return Err("Event ID is invalid.".into()),
+        },
+    };
+
+    let details = ZapDetails::new(ZapType::Private).message(message);
+    let num = match amount.parse::<u64>() {
+        Ok(val) => val,
+        Err(_) => return Err("Invalid amount.".into()),
+    };
+
+    if client.zap(event_id, num, Some(details)).await.is_ok() {
+        Ok(true)
+    } else {
+        Err("Zap event failed".into())
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn friend_to_friend(npub: &str, state: State<'_, Nostr>) -> Result<bool, String> {
+    let client = &state.client;
+
+    match PublicKey::from_bech32(npub) {
+        Ok(author) => {
+            let mut contact_list: Vec<Contact> = Vec::new();
+            let contact_list_filter = Filter::new()
+                .author(author)
+                .kind(Kind::ContactList)
+                .limit(1);
+
+            if let Ok(contact_list_events) =
+                client.get_events_of(vec![contact_list_filter], None).await
+            {
+                for event in contact_list_events.into_iter() {
+                    for tag in event.into_iter_tags() {
+                        if let Some(TagStandard::PublicKey {
+                            public_key,
+                            relay_url,
+                            alias,
+                            uppercase: false,
+                        }) = tag.to_standardized()
+                        {
+                            contact_list.push(Contact::new(public_key, relay_url, alias))
+                        }
+                    }
+                }
+            }
+
+            match client.set_contact_list(contact_list).await {
+                Ok(_) => Ok(true),
+                Err(err) => Err(err.to_string()),
+            }
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+pub async fn get_following(
+    state: State<'_, Nostr>,
+    public_key: &str,
+    timeout: Option<u64>,
+) -> Result<Vec<String>, String> {
+    let client = &state.client;
+    let public_key = match PublicKey::from_str(public_key) {
+        Ok(val) => val,
+        Err(err) => return Err(err.to_string()),
+    };
+    let duration = timeout.map(Duration::from_secs);
+    let filter = Filter::new().kind(Kind::ContactList).author(public_key);
+    let events = match client.get_events_of(vec![filter], duration).await {
+        Ok(events) => events,
+        Err(err) => return Err(err.to_string()),
+    };
+    let mut ret: Vec<String> = vec![];
+    if let Some(latest_event) = events.iter().max_by_key(|event| event.created_at()) {
+        ret.extend(latest_event.tags().iter().filter_map(|tag| {
+            if let Some(TagStandard::PublicKey {
+                uppercase: false, ..
+            }) = <nostr_sdk::Tag as Clone>::clone(tag).to_standardized()
+            {
+                tag.content().map(String::from)
+            } else {
+                None
+            }
+        }));
+    }
+    Ok(ret)
+}
+
+pub async fn get_followers(
+    state: State<'_, Nostr>,
+    public_key: &str,
+    timeout: Option<u64>,
+) -> Result<Vec<String>, String> {
+    let client = &state.client;
+    let public_key = match PublicKey::from_str(public_key) {
+        Ok(val) => val,
+        Err(err) => return Err(err.to_string()),
+    };
+    let duration = timeout.map(Duration::from_secs);
+
+    let filter = Filter::new().kind(Kind::ContactList).custom_tag(
+        SingleLetterTag::lowercase(Alphabet::P),
+        vec![public_key.to_hex()],
+    );
+    let events = match client.get_events_of(vec![filter], duration).await {
+        Ok(events) => events,
+        Err(err) => return Err(err.to_string()),
+    };
+    let ret: Vec<String> = events
+        .into_iter()
+        .map(|event| event.author().to_hex())
+        .collect();
+    Ok(ret)
+    // TODO: get more than 500 events
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_notifications(state: State<'_, Nostr>) -> Result<Vec<String>, String> {
+    let client = &state.client;
+
+    match client.signer().await {
+        Ok(signer) => {
+            let public_key = signer.public_key().await.unwrap();
+            let filter = Filter::new()
+                .pubkey(public_key)
+                .kinds(vec![
+                    Kind::TextNote,
+                    Kind::Repost,
+                    Kind::Reaction,
+                    Kind::ZapReceipt,
+                ])
+                .limit(200);
+
+            match client
+                .database()
+                .query(vec![filter], Order::default())
+                .await
+            {
+                Ok(events) => Ok(events.into_iter().map(|ev| ev.as_json()).collect()),
+                Err(err) => Err(err.to_string()),
+            }
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_settings(state: State<'_, Nostr>) -> Result<Settings, ()> {
+    let settings = state.settings.lock().unwrap().clone();
+    Ok(settings)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn set_new_settings(settings: &str, state: State<'_, Nostr>) -> Result<(), ()> {
+    let parsed: Settings =
+        serde_json::from_str(settings).expect("Could not parse settings payload");
+    *state.settings.lock().unwrap() = parsed;
+
+    Ok(())
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn verify_nip05(key: &str, nip05: &str) -> Result<bool, String> {
+    match PublicKey::from_str(key) {
+        Ok(public_key) => {
+            let status = nip05::verify(&public_key, nip05, None).await;
+            Ok(status.is_ok())
+        }
+        Err(err) => Err(err.to_string()),
+    }
+}

src-tauri/src/commands/mod.rs

@@ -1,5 +1,7 @@
-#[cfg(target_os = "macos")]
-pub mod fns;
+pub mod event;
+pub mod keys;
+pub mod metadata;
+pub mod relay;
 #[cfg(target_os = "macos")]
 pub mod tray;
 pub mod window;

src-tauri/src/commands/relay.rs

@@ -0,0 +1,157 @@
+use crate::Nostr;
+use nostr_sdk::prelude::*;
+use serde::Serialize;
+use specta::Type;
+use std::{
+    fs::OpenOptions,
+    io::{self, BufRead, Write},
+};
+use tauri::{path::BaseDirectory, Manager, State};
+
+#[derive(Serialize, Type)]
+pub struct Relays {
+    connected: Vec<String>,
+    read: Option<Vec<String>>,
+    write: Option<Vec<String>>,
+    both: Option<Vec<String>>,
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_relays(state: State<'_, Nostr>) -> Result<Relays, String> {
+    let client = &state.client;
+
+    let connected_relays = client
+        .relays()
+        .await
+        .into_keys()
+        .map(|url| url.to_string())
+        .collect::<Vec<_>>();
+
+    let signer = client.signer().await.map_err(|e| e.to_string())?;
+    let public_key = signer.public_key().await.map_err(|e| e.to_string())?;
+
+    let filter = Filter::new()
+        .author(public_key)
+        .kind(Kind::RelayList)
+        .limit(1);
+
+    match client.get_events_of(vec![filter], None).await {
+        Ok(events) => {
+            if let Some(event) = events.first() {
+                let nip65_list = nip65::extract_relay_list(event).collect::<Vec<_>>();
+
+                let read = nip65_list
+                    .iter()
+                    .filter_map(|(url, meta)| {
+                        if let Some(RelayMetadata::Read) = meta {
+                            Some(url.to_string())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect();
+
+                let write = nip65_list
+                    .iter()
+                    .filter_map(|(url, meta)| {
+                        if let Some(RelayMetadata::Write) = meta {
+                            Some(url.to_string())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect();
+
+                let both = nip65_list
+                    .iter()
+                    .filter_map(|(url, meta)| {
+                        if meta.is_none() {
+                            Some(url.to_string())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect();
+
+                Ok(Relays {
+                    connected: connected_relays,
+                    read: Some(read),
+                    write: Some(write),
+                    both: Some(both),
+                })
+            } else {
+                Ok(Relays {
+                    connected: connected_relays,
+                    read: None,
+                    write: None,
+                    both: None,
+                })
+            }
+        }
+        Err(e) => Err(e.to_string()),
+    }
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn connect_relay(relay: &str, state: State<'_, Nostr>) -> Result<bool, String> {
+    let client = &state.client;
+    let status = client.add_relay(relay).await.map_err(|e| e.to_string())?;
+    if status {
+        println!("Connecting to relay: {}", relay);
+        client
+            .connect_relay(relay)
+            .await
+            .map_err(|e| e.to_string())?;
+    }
+    Ok(status)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn remove_relay(relay: &str, state: State<'_, Nostr>) -> Result<bool, String> {
+    let client = &state.client;
+    client
+        .remove_relay(relay)
+        .await
+        .map_err(|e| e.to_string())?;
+    client
+        .disconnect_relay(relay)
+        .await
+        .map_err(|e| e.to_string())?;
+    Ok(true)
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn get_bootstrap_relays(app: tauri::AppHandle) -> Result<Vec<String>, String> {
+    let relays_path = app
+        .path()
+        .resolve("resources/relays.txt", BaseDirectory::Resource)
+        .map_err(|e| e.to_string())?;
+
+    let file = std::fs::File::open(relays_path).map_err(|e| e.to_string())?;
+    let reader = io::BufReader::new(file);
+
+    reader
+        .lines()
+        .collect::<Result<Vec<String>, io::Error>>()
+        .map_err(|e| e.to_string())
+}
+
+#[tauri::command]
+#[specta::specta]
+pub fn save_bootstrap_relays(relays: &str, app: tauri::AppHandle) -> Result<(), String> {
+    let relays_path = app
+        .path()
+        .resolve("resources/relays.txt", BaseDirectory::Resource)
+        .map_err(|e| e.to_string())?;
+
+    let mut file = OpenOptions::new()
+        .write(true)
+        .open(relays_path)
+        .map_err(|e| e.to_string())?;
+
+    file.write_all(relays.as_bytes()).map_err(|e| e.to_string())
+}

src-tauri/src/commands/tray.rs

@@ -7,7 +7,7 @@ use tauri::{
 use tauri::{AppHandle, Manager, WebviewUrl};
 use tauri_nspanel::ManagerExt;
 
-use super::fns::{
+use crate::macos::{
     position_menubar_panel, set_corner_radius, setup_menubar_panel_listeners,
     swizzle_to_menubar_panel,
 };