638 lines
23 KiB
Rust
638 lines
23 KiB
Rust
#![cfg_attr(
|
|
all(not(debug_assertions), target_os = "windows"),
|
|
windows_subsystem = "windows"
|
|
)]
|
|
|
|
#[cfg(target_os = "macos")]
|
|
use border::WebviewWindowExt as BorderWebviewWindowExt;
|
|
use commands::{account::*, event::*, metadata::*, relay::*, window::*};
|
|
use common::{get_all_accounts, parse_event};
|
|
use nostr_sdk::prelude::{Profile as DatabaseProfile, *};
|
|
use serde::{Deserialize, Serialize};
|
|
use specta::Type;
|
|
use specta_typescript::Typescript;
|
|
use std::{collections::HashSet, fs, str::FromStr, time::Duration};
|
|
use tauri::{
|
|
menu::{Menu, MenuItem},
|
|
Emitter, EventTarget, Listener, Manager, WebviewWindowBuilder,
|
|
};
|
|
use tauri_plugin_decorum::WebviewWindowExt;
|
|
use tauri_plugin_notification::{NotificationExt, PermissionState};
|
|
use tauri_plugin_store::StoreExt;
|
|
use tauri_specta::{collect_commands, Builder};
|
|
use tokio::{sync::RwLock, time::sleep};
|
|
|
|
pub mod commands;
|
|
pub mod common;
|
|
|
|
pub struct Nostr {
|
|
client: Client,
|
|
queue: RwLock<HashSet<PublicKey>>,
|
|
settings: RwLock<Settings>,
|
|
}
|
|
|
|
#[derive(Serialize, Deserialize, Debug)]
|
|
pub struct Payload {
|
|
id: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
|
pub struct Settings {
|
|
resize_service: bool,
|
|
content_warning: bool,
|
|
display_avatar: bool,
|
|
display_zap_button: bool,
|
|
display_repost_button: bool,
|
|
display_media: bool,
|
|
}
|
|
|
|
impl Default for Settings {
|
|
fn default() -> Self {
|
|
Self {
|
|
content_warning: true,
|
|
resize_service: true,
|
|
display_avatar: true,
|
|
display_zap_button: true,
|
|
display_repost_button: true,
|
|
display_media: true,
|
|
}
|
|
}
|
|
}
|
|
|
|
pub const DEFAULT_DIFFICULTY: u8 = 0;
|
|
pub const FETCH_LIMIT: usize = 50;
|
|
pub const QUEUE_DELAY: u64 = 150;
|
|
pub const NOTIFICATION_SUB_ID: &str = "lume_notification";
|
|
// Will be removed when almost relays support negentropy
|
|
pub const BOOTSTRAP_RELAYS: [&str; 5] = [
|
|
"wss://relay.damus.io",
|
|
"wss://relay.primal.net",
|
|
"wss://nostr.fmt.wiz.biz",
|
|
"wss://directory.yabu.me",
|
|
"wss://purplepag.es",
|
|
];
|
|
|
|
fn main() {
|
|
tracing_subscriber::fmt::init();
|
|
|
|
let builder = Builder::<tauri::Wry>::new().commands(collect_commands![
|
|
get_all_relays,
|
|
get_all_relay_lists,
|
|
is_relay_connected,
|
|
connect_relay,
|
|
remove_relay,
|
|
get_accounts,
|
|
watch_account,
|
|
import_account,
|
|
connect_account,
|
|
get_private_key,
|
|
delete_account,
|
|
reset_password,
|
|
has_signer,
|
|
set_signer,
|
|
get_profile,
|
|
set_profile,
|
|
get_contact_list,
|
|
set_contact_list,
|
|
is_contact,
|
|
toggle_contact,
|
|
get_all_profiles,
|
|
set_group,
|
|
get_group,
|
|
get_all_newsfeeds,
|
|
get_all_local_newsfeeds,
|
|
set_interest,
|
|
get_interest,
|
|
get_all_interests,
|
|
get_all_local_interests,
|
|
get_relay_list,
|
|
set_wallet,
|
|
load_wallet,
|
|
remove_wallet,
|
|
zap_profile,
|
|
zap_event,
|
|
copy_friend,
|
|
get_notifications,
|
|
verify_nip05,
|
|
get_meta_from_event,
|
|
get_event,
|
|
get_replies,
|
|
get_all_events_by_author,
|
|
get_all_events_by_authors,
|
|
get_all_events_by_hashtags,
|
|
get_all_events_from,
|
|
get_all_events_by_kind,
|
|
get_all_providers,
|
|
request_events_from_provider,
|
|
get_all_events_by_request,
|
|
get_local_events,
|
|
get_global_events,
|
|
search,
|
|
publish,
|
|
reply,
|
|
repost,
|
|
is_reposted,
|
|
request_delete,
|
|
is_deleted_event,
|
|
event_to_bech32,
|
|
user_to_bech32,
|
|
create_column,
|
|
reload_column,
|
|
close_column,
|
|
close_all_columns,
|
|
open_window,
|
|
get_app_settings,
|
|
set_app_settings,
|
|
]);
|
|
|
|
#[cfg(debug_assertions)]
|
|
builder
|
|
.export(Typescript::default(), "../src/commands.gen.ts")
|
|
.expect("Failed to export typescript bindings");
|
|
|
|
let tauri_builder = tauri::Builder::default();
|
|
let mut ctx = tauri::generate_context!();
|
|
|
|
tauri_builder
|
|
.invoke_handler(builder.invoke_handler())
|
|
.setup(move |app| {
|
|
let handle = app.handle();
|
|
let handle_clone = handle.clone();
|
|
let handle_clone_child = handle_clone.clone();
|
|
let handle_clone_event = handle_clone_child.clone();
|
|
let main_window = app.get_webview_window("main").unwrap();
|
|
|
|
let config_dir = handle
|
|
.path()
|
|
.app_config_dir()
|
|
.expect("Error: app config directory not found.");
|
|
|
|
let _ = fs::create_dir_all(&config_dir);
|
|
|
|
// Set custom decoration for Windows
|
|
#[cfg(target_os = "windows")]
|
|
main_window.create_overlay_titlebar().unwrap();
|
|
|
|
// Restore native border
|
|
#[cfg(target_os = "macos")]
|
|
main_window.add_border(None);
|
|
|
|
// Set a custom inset to the traffic lights
|
|
#[cfg(target_os = "macos")]
|
|
main_window.set_traffic_lights_inset(7.0, 10.0).unwrap();
|
|
|
|
// Setup tray menu item
|
|
let open_i = MenuItem::with_id(app, "open", "Open Lume", true, None::<&str>)?;
|
|
let quit_i = MenuItem::with_id(app, "quit", "Quit", true, None::<&str>)?;
|
|
// Create tray menu
|
|
let menu = Menu::with_items(app, &[&open_i, &quit_i])?;
|
|
// Get main tray
|
|
let tray = app.tray_by_id("main").unwrap();
|
|
// Set menu
|
|
tray.set_menu(Some(menu)).unwrap();
|
|
// Listen to tray events
|
|
tray.on_menu_event(|handle, event| match event.id().as_ref() {
|
|
"open" => {
|
|
if let Some(window) = handle.get_window("main") {
|
|
if window.is_visible().unwrap_or_default() {
|
|
let _ = window.set_focus();
|
|
} else {
|
|
let _ = window.show();
|
|
let _ = window.set_focus();
|
|
};
|
|
} else {
|
|
let window = WebviewWindowBuilder::from_config(
|
|
handle,
|
|
handle.config().app.windows.first().unwrap(),
|
|
)
|
|
.unwrap()
|
|
.build()
|
|
.unwrap();
|
|
|
|
// Set decoration
|
|
#[cfg(target_os = "windows")]
|
|
window.create_overlay_titlebar().unwrap();
|
|
|
|
// Restore native border
|
|
#[cfg(target_os = "macos")]
|
|
window.add_border(None);
|
|
|
|
// Set a custom inset to the traffic lights
|
|
#[cfg(target_os = "macos")]
|
|
window.set_traffic_lights_inset(7.0, 10.0).unwrap();
|
|
}
|
|
}
|
|
"quit" => {
|
|
std::process::exit(0);
|
|
}
|
|
_ => {}
|
|
});
|
|
|
|
let client = tauri::async_runtime::block_on(async move {
|
|
// Setup database
|
|
let database = NostrLMDB::open(config_dir.join("nostr"))
|
|
.expect("Error: cannot create database.");
|
|
|
|
// Config
|
|
let opts = Options::new()
|
|
.gossip(true)
|
|
.max_avg_latency(Duration::from_millis(500))
|
|
.timeout(Duration::from_secs(5));
|
|
|
|
// Setup nostr client
|
|
let client = ClientBuilder::default()
|
|
.database(database)
|
|
.opts(opts)
|
|
.build();
|
|
|
|
/* Get bootstrap relays
|
|
if let Ok(path) = handle
|
|
.path()
|
|
.resolve("resources/relays.txt", BaseDirectory::Resource)
|
|
{
|
|
let file = std::fs::File::open(&path).unwrap();
|
|
let lines = io::BufReader::new(file).lines();
|
|
|
|
// Add bootstrap relays to relay pool
|
|
for line in lines.map_while(Result::ok) {
|
|
if let Some((relay, option)) = line.split_once(',') {
|
|
match RelayMetadata::from_str(option) {
|
|
Ok(meta) => {
|
|
let opts = if meta == RelayMetadata::Read {
|
|
RelayOptions::new().read(true).write(false)
|
|
} else {
|
|
RelayOptions::new().write(true).read(false)
|
|
};
|
|
let _ = client.pool().add_relay(relay, opts).await;
|
|
}
|
|
Err(_) => {
|
|
let _ = client.add_relay(relay).await;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
*/
|
|
|
|
for relay in BOOTSTRAP_RELAYS {
|
|
let _ = client.add_relay(relay).await;
|
|
}
|
|
|
|
let _ = client.add_discovery_relay("wss://user.kindpag.es/").await;
|
|
|
|
// Connect
|
|
client.connect().await;
|
|
|
|
client
|
|
});
|
|
|
|
// Load app settings
|
|
let store = app.store(".data")?;
|
|
|
|
// Parse app settings if exist
|
|
let settings = if let Some(data) = store.get("tanstack-query-[\"settings\"]") {
|
|
if let Some(str) = data.as_str() {
|
|
let v: Value = serde_json::from_str(str).unwrap();
|
|
let data = v["state"]["data"].clone();
|
|
let parse: Settings = serde_json::from_value(data).unwrap();
|
|
|
|
RwLock::new(parse)
|
|
} else {
|
|
RwLock::new(Settings::default())
|
|
}
|
|
} else {
|
|
RwLock::new(Settings::default())
|
|
};
|
|
|
|
// Create global state
|
|
app.manage(Nostr {
|
|
client,
|
|
settings,
|
|
queue: RwLock::new(HashSet::new()),
|
|
});
|
|
|
|
// Listen for request metadata
|
|
app.listen_any("request_metadata", move |event| {
|
|
let payload = event.payload();
|
|
let parsed_payload: Payload = serde_json::from_str(payload).expect("Parse failed");
|
|
let handle = handle_clone_child.clone();
|
|
|
|
tauri::async_runtime::spawn(async move {
|
|
let state = handle.state::<Nostr>();
|
|
let client = &state.client;
|
|
|
|
if let Ok(public_key) = PublicKey::parse(parsed_payload.id) {
|
|
let mut write_queue = state.queue.write().await;
|
|
write_queue.insert(public_key);
|
|
};
|
|
|
|
// Wait for [QUEUE_DELAY]
|
|
sleep(Duration::from_millis(QUEUE_DELAY)).await;
|
|
|
|
let read_queue = state.queue.read().await;
|
|
|
|
if !read_queue.is_empty() {
|
|
let authors: HashSet<PublicKey> = read_queue.iter().copied().collect();
|
|
|
|
let filter = Filter::new()
|
|
.authors(authors)
|
|
.kind(Kind::Metadata)
|
|
.limit(200);
|
|
|
|
let opts = SubscribeAutoCloseOptions::default()
|
|
.filter(FilterOptions::WaitDurationAfterEOSE(Duration::from_secs(2)));
|
|
|
|
// Drop queue, you don't need it at this time anymore
|
|
drop(read_queue);
|
|
// Clear queue
|
|
let mut write_queue = state.queue.write().await;
|
|
write_queue.clear();
|
|
|
|
if let Err(e) = client.subscribe(vec![filter], Some(opts)).await {
|
|
println!("Subscribe error: {}", e);
|
|
}
|
|
}
|
|
});
|
|
});
|
|
|
|
// Run a thread for negentropy
|
|
tauri::async_runtime::spawn(async move {
|
|
let state = handle_clone_event.state::<Nostr>();
|
|
let client = &state.client;
|
|
|
|
// Use default sync options
|
|
let opts = SyncOptions::default();
|
|
|
|
// Set interval
|
|
let mut interval = tokio::time::interval(tokio::time::Duration::from_secs(600));
|
|
|
|
loop {
|
|
interval.tick().await;
|
|
|
|
let accounts = get_all_accounts();
|
|
let public_keys: Vec<PublicKey> = accounts
|
|
.iter()
|
|
.filter_map(|acc| PublicKey::from_str(acc).ok())
|
|
.collect();
|
|
|
|
if !public_keys.is_empty() {
|
|
// Create filter for notification
|
|
//
|
|
let filter = Filter::new().pubkeys(public_keys.clone()).kinds(vec![
|
|
Kind::TextNote,
|
|
Kind::Repost,
|
|
Kind::Reaction,
|
|
Kind::ZapReceipt,
|
|
]);
|
|
|
|
// Sync notification
|
|
//
|
|
if let Ok(output) = client.sync_with(BOOTSTRAP_RELAYS, filter, &opts).await
|
|
{
|
|
println!("Received: {}", output.received.len())
|
|
}
|
|
|
|
// Create filter for contact list
|
|
//
|
|
let filter = Filter::new()
|
|
.authors(public_keys)
|
|
.kinds(vec![Kind::ContactList, Kind::FollowSet]);
|
|
|
|
// Sync events for contact list
|
|
//
|
|
if let Ok(events) = client.database().query(vec![filter]).await {
|
|
// Get unique public keys
|
|
let public_keys: HashSet<PublicKey> = events
|
|
.iter()
|
|
.flat_map(|ev| ev.tags.public_keys().copied())
|
|
.collect();
|
|
|
|
// Convert to vector
|
|
let public_keys: Vec<PublicKey> = public_keys.into_iter().collect();
|
|
|
|
for chunk in public_keys.chunks(1000) {
|
|
if chunk.is_empty() {
|
|
return;
|
|
}
|
|
|
|
let authors = chunk.to_owned();
|
|
|
|
// Create filter for metadata
|
|
//
|
|
let filter = Filter::new().authors(authors.clone()).kinds(vec![
|
|
Kind::Metadata,
|
|
Kind::FollowSet,
|
|
Kind::Interests,
|
|
Kind::InterestSet,
|
|
]);
|
|
|
|
// Sync metadata
|
|
//
|
|
if let Ok(output) =
|
|
client.sync_with(BOOTSTRAP_RELAYS, filter, &opts).await
|
|
{
|
|
println!("Received: {}", output.received.len())
|
|
}
|
|
|
|
// Create filter for text note
|
|
//
|
|
let filter = Filter::new()
|
|
.authors(authors)
|
|
.kinds(vec![Kind::TextNote, Kind::Repost, Kind::EventDeletion])
|
|
.limit(100);
|
|
|
|
// Sync text note
|
|
//
|
|
if let Ok(output) =
|
|
client.sync_with(BOOTSTRAP_RELAYS, filter, &opts).await
|
|
{
|
|
println!("Received: {}", output.received.len())
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
});
|
|
|
|
// Run a thread for handle notification
|
|
tauri::async_runtime::spawn(async move {
|
|
let state = handle_clone.state::<Nostr>();
|
|
let client = &state.client;
|
|
let accounts = get_all_accounts();
|
|
|
|
if !accounts.is_empty() {
|
|
let subscription_id = SubscriptionId::new(NOTIFICATION_SUB_ID);
|
|
|
|
let public_keys: Vec<PublicKey> = accounts
|
|
.iter()
|
|
.filter_map(|acc| PublicKey::from_str(acc).ok())
|
|
.collect();
|
|
|
|
let filter = Filter::new()
|
|
.pubkeys(public_keys)
|
|
.kinds(vec![
|
|
Kind::TextNote,
|
|
Kind::Repost,
|
|
Kind::Reaction,
|
|
Kind::ZapReceipt,
|
|
Kind::Custom(1111),
|
|
])
|
|
.since(Timestamp::now());
|
|
|
|
// Subscribe for new notification
|
|
if let Err(e) = client
|
|
.subscribe_with_id(subscription_id, vec![filter], None)
|
|
.await
|
|
{
|
|
println!("Subscribe error: {}", e)
|
|
}
|
|
}
|
|
|
|
let allow_notification = match handle_clone.notification().request_permission() {
|
|
Ok(_) => {
|
|
if let Ok(perm) = handle_clone.notification().permission_state() {
|
|
PermissionState::Granted == perm
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
Err(_) => false,
|
|
};
|
|
|
|
let notification_id = SubscriptionId::new(NOTIFICATION_SUB_ID);
|
|
|
|
let _ = client
|
|
.handle_notifications(|notification| async {
|
|
#[allow(clippy::collapsible_match)]
|
|
if let RelayPoolNotification::Message { message, .. } = notification {
|
|
if let RelayMessage::Event {
|
|
event,
|
|
subscription_id,
|
|
..
|
|
} = message
|
|
{
|
|
if subscription_id == notification_id {
|
|
// Send native notification
|
|
if allow_notification {
|
|
let author = client
|
|
.database()
|
|
.profile(event.pubkey)
|
|
.await
|
|
.unwrap_or_else(|_| {
|
|
DatabaseProfile::new(event.pubkey, Metadata::new())
|
|
});
|
|
|
|
send_event_notification(
|
|
&event,
|
|
author.metadata(),
|
|
&handle_clone,
|
|
);
|
|
}
|
|
} else if event.kind == Kind::Metadata {
|
|
if let Err(e) = handle_clone.emit("metadata", event.as_json()) {
|
|
println!("Emit error: {}", e)
|
|
}
|
|
} else if event.kind == Kind::TextNote {
|
|
let payload = RichEvent {
|
|
raw: event.as_json(),
|
|
parsed: if event.kind == Kind::TextNote {
|
|
Some(parse_event(&event.content).await)
|
|
} else {
|
|
None
|
|
},
|
|
};
|
|
|
|
if let Err(e) = handle_clone.emit_to(
|
|
EventTarget::labeled(subscription_id.to_string()),
|
|
"event",
|
|
payload,
|
|
) {
|
|
println!("Emit error: {}", e)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
Ok(false)
|
|
})
|
|
.await;
|
|
});
|
|
|
|
Ok(())
|
|
})
|
|
.plugin(prevent_default())
|
|
.plugin(tauri_plugin_theme::init(ctx.config_mut()))
|
|
.plugin(tauri_plugin_decorum::init())
|
|
.plugin(tauri_plugin_store::Builder::default().build())
|
|
.plugin(tauri_plugin_clipboard_manager::init())
|
|
.plugin(tauri_plugin_dialog::init())
|
|
.plugin(tauri_plugin_fs::init())
|
|
.plugin(tauri_plugin_http::init())
|
|
.plugin(tauri_plugin_notification::init())
|
|
.plugin(tauri_plugin_os::init())
|
|
.plugin(tauri_plugin_process::init())
|
|
.plugin(tauri_plugin_shell::init())
|
|
.plugin(tauri_plugin_upload::init())
|
|
.plugin(tauri_plugin_updater::Builder::new().build())
|
|
.plugin(tauri_plugin_window_state::Builder::default().build())
|
|
.build(ctx)
|
|
.expect("error while running tauri application")
|
|
.run(|_app_handle, event| {
|
|
if let tauri::RunEvent::ExitRequested { api, .. } = event {
|
|
api.prevent_exit();
|
|
}
|
|
});
|
|
}
|
|
|
|
#[cfg(debug_assertions)]
|
|
fn prevent_default() -> tauri::plugin::TauriPlugin<tauri::Wry> {
|
|
use tauri_plugin_prevent_default::Flags;
|
|
|
|
tauri_plugin_prevent_default::Builder::new()
|
|
.with_flags(Flags::all().difference(Flags::CONTEXT_MENU))
|
|
.build()
|
|
}
|
|
|
|
#[cfg(not(debug_assertions))]
|
|
fn prevent_default() -> tauri::plugin::TauriPlugin<tauri::Wry> {
|
|
tauri_plugin_prevent_default::Builder::new().build()
|
|
}
|
|
|
|
fn send_event_notification(event: &Event, author: Metadata, handle: &tauri::AppHandle) {
|
|
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!("Error: {}", 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!("Error: {}", 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!("Error: {}", e);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|