chore: update nostr sdk

src-tauri/Cargo.toml

@@ -7,22 +7,15 @@ repository = "https://github.com/lumehq/coop"
 edition = "2021"
 rust-version = "1.70"
 
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
-
 [build-dependencies]
 tauri-build = { version = "2.0.0", features = [] }
 
 [dependencies]
-nostr-sdk = { git = "https://github.com/rust-nostr/nostr", features = [
-	"lmdb",
-] }
-
 tauri = { version = "2.0.0", features = [
 	"tray-icon",
 	"macos-private-api",
 	"protocol-asset",
 ] }
-tauri-plugin-prevent-default = "0.4"
 tauri-plugin-os = "2.0.0"
 tauri-plugin-clipboard-manager = "2.0.0"
 tauri-plugin-dialog = "2.0.0"
@@ -32,10 +25,14 @@ tauri-plugin-process = "2.0.0"
 tauri-plugin-fs = "2.0.0"
 tauri-plugin-notification = "2.0.0"
 tauri-plugin-decorum = "1.1.0"
+tauri-plugin-prevent-default = "^0.4"
 tauri-specta = { version = "2.0.0-rc", features = ["derive", "typescript"] }
+
+nostr-sdk = { git = "https://github.com/rust-nostr/nostr", features = ["lmdb"] }
+nostr-connect = { git = "https://github.com/rust-nostr/nostr" }
+
 specta = "^2.0.0-rc.20"
 specta-typescript = "0.0.7"
-
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
 itertools = "0.13.0"

src-tauri/src/commands/account.rs

@@ -1,5 +1,6 @@
 use keyring::Entry;
 use keyring_search::{Limit, List, Search};
+use nostr_connect::prelude::*;
 use nostr_sdk::prelude::*;
 use serde::{Deserialize, Serialize};
 use specta::Type;
@@ -23,23 +24,20 @@ struct Account {
 
 #[tauri::command]
 #[specta::specta]
-pub async fn get_metadata(user_id: String, state: State<'_, Nostr>) -> Result<String, String> {
+pub async fn get_metadata(id: String, state: State<'_, Nostr>) -> Result<String, String> {
 	let client = &state.client;
-	let bootstrap_relays = state.bootstrap_relays.lock().await.clone();
+	let public_key = PublicKey::parse(&id).map_err(|e| e.to_string())?;
 
-	let public_key = PublicKey::parse(&user_id).map_err(|e| e.to_string())?;
 	let filter = Filter::new().author(public_key).kind(Kind::Metadata).limit(1);
 
-	match client.get_events_from(bootstrap_relays, vec![filter], Some(Duration::from_secs(2))).await
+	let events = client.database().query(vec![filter]).await.map_err(|e| e.to_string())?;
-	{
+
-		Ok(events) => {
+	match events.first() {
-			if let Some(event) = events.first() {
+		Some(event) => match Metadata::from_json(&event.content) {
-				Ok(Metadata::from_json(&event.content).unwrap_or(Metadata::new()).as_json())
+			Ok(metadata) => Ok(metadata.as_json()),
-			} else {
-				Ok(Metadata::new().as_json())
-			}
-		}
 			Err(e) => Err(e.to_string()),
+		},
+		None => Err("Metadata not found".into()),
 	}
 }
 
@@ -60,7 +58,7 @@ pub fn get_accounts() -> Vec<String> {
 pub async fn get_current_account(state: State<'_, Nostr>) -> Result<String, String> {
 	let client = &state.client;
 	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 public_key = signer.get_public_key().await.map_err(|e| e.to_string())?;
 	let bech32 = public_key.to_bech32().map_err(|e| e.to_string())?;
 
 	Ok(bech32)
@@ -89,10 +87,8 @@ pub async fn create_account(
 	let j = serde_json::to_string(&account).map_err(|e| e.to_string())?;
 	let _ = keyring.set_password(&j);
 
-	let signer = NostrSigner::Keys(keys);
-
 	// Update signer
-	client.set_signer(Some(signer)).await;
+	client.set_signer(keys).await;
 
 	let mut metadata =
 		Metadata::new().display_name(name.clone()).name(name.to_lowercase()).about(about);
@@ -156,10 +152,10 @@ pub async fn connect_account(uri: String, state: State<'_, Nostr>) -> Result<Str
 			let app_secret = app_keys.secret_key().to_secret_hex();
 
 			// Get remote user
-			let remote_user = bunker_uri.signer_public_key().unwrap();
+			let remote_user = bunker_uri.remote_signer_public_key().unwrap();
 			let remote_npub = remote_user.to_bech32().unwrap();
 
-			match Nip46Signer::new(bunker_uri, app_keys, Duration::from_secs(120), None) {
+			match NostrConnect::new(bunker_uri, app_keys, Duration::from_secs(120), None) {
 				Ok(signer) => {
 					let mut url = Url::parse(&uri).unwrap();
 					let query: Vec<(String, String)> = url
@@ -177,7 +173,7 @@ pub async fn connect_account(uri: String, state: State<'_, Nostr>) -> Result<Str
 					let _ = keyring.set_password(&j);
 
 					// Update signer
-					let _ = client.set_signer(Some(signer.into())).await;
+					let _ = client.set_signer(signer).await;
 
 					Ok(remote_npub)
 				}
@@ -256,22 +252,22 @@ pub async fn login(
 			let secret_key = ncryptsec.to_secret_key(password).map_err(|_| "Wrong password.")?;
 			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;
+			client.set_signer(keys).await;
 
 			public_key
 		}
 		Some(bunker) => {
 			let uri = NostrConnectURI::parse(bunker).map_err(|e| e.to_string())?;
-			let public_key = uri.signer_public_key().unwrap();
+			let public_key = uri.remote_signer_public_key().unwrap().clone();
 			let app_keys = Keys::from_str(&account.password).map_err(|e| e.to_string())?;
 
-			match Nip46Signer::new(uri, app_keys, Duration::from_secs(120), None) {
+			match NostrConnect::new(uri, app_keys, Duration::from_secs(120), None) {
 				Ok(signer) => {
 					// Update signer
-					client.set_signer(Some(signer.into())).await;
+					client.set_signer(signer).await;
+					// Return public key
 					public_key
 				}
 				Err(e) => return Err(e.to_string()),

src-tauri/src/commands/chat.rs

@@ -10,7 +10,7 @@ use crate::Nostr;
 pub async fn get_chats(state: State<'_, Nostr>) -> Result<Vec<String>, String> {
 	let client = &state.client;
 	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 public_key = signer.get_public_key().await.map_err(|e| e.to_string())?;
 
 	let filter = Filter::new().kind(Kind::PrivateDirectMessage).pubkey(public_key);
 
@@ -36,7 +36,7 @@ pub async fn get_chat_messages(id: String, state: State<'_, Nostr>) -> Result<Ve
 	let client = &state.client;
 	let signer = client.signer().await.map_err(|e| e.to_string())?;
 
-	let receiver = signer.public_key().await.map_err(|e| e.to_string())?;
+	let receiver = signer.get_public_key().await.map_err(|e| e.to_string())?;
 	let sender = PublicKey::parse(id).map_err(|e| e.to_string())?;
 
 	let recv_filter =
@@ -64,7 +64,7 @@ pub async fn send_message(
 	let relays = state.inbox_relays.lock().await;
 
 	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 public_key = signer.get_public_key().await.map_err(|e| e.to_string())?;
 	let receiver = PublicKey::parse(&to).map_err(|e| e.to_string())?;
 
 	// TODO: Add support reply_to

src-tauri/src/commands/relay.rs

@@ -121,7 +121,7 @@ pub async fn connect_inbox_relays(
 		if let Some(relays) = inbox_relays.get(&public_key) {
 			for url in relays {
 				if let Ok(relay) = client.relay(url).await {
-					if !relay.is_connected().await {
+					if !relay.is_connected() {
 						if let Err(e) = client.connect_relay(url).await {
 							println!("Connect relay failed: {}", e)
 						}

src-tauri/src/main.rs

@@ -11,7 +11,6 @@ use std::{
 	env, fs,
 	io::{self, BufRead},
 	str::FromStr,
-	time::Duration,
 };
 use tauri::{async_runtime::Mutex, Manager};
 #[cfg(not(target_os = "linux"))]
@@ -24,7 +23,6 @@ mod commands;
 
 pub struct Nostr {
 	client: Client,
-	bootstrap_relays: Mutex<Vec<String>>,
 	inbox_relays: Mutex<HashMap<PublicKey, Vec<String>>>,
 }
 
@@ -63,9 +61,6 @@ fn main() {
 	tauri::Builder::default()
 		.invoke_handler(builder.invoke_handler())
 		.setup(move |app| {
-			// This is also required if you want to use events
-			builder.mount_events(app);
-
 			let handle = app.handle();
 			let _ = setup_tray_icon(handle);
 
@@ -80,24 +75,16 @@ fn main() {
 			#[cfg(target_os = "macos")]
 			main_window.set_traffic_lights_inset(12.0, 18.0).unwrap();
 
-			// Workaround for reset traffic light when theme changed
-			#[cfg(target_os = "macos")]
-			let win_ = main_window.clone();
-			#[cfg(target_os = "macos")]
-			main_window.on_window_event(move |event| {
-				if let tauri::WindowEvent::ThemeChanged(_) = event {
-					win_.set_traffic_lights_inset(12.0, 18.0).unwrap();
-				}
-			});
-
 			// Restore native border
 			#[cfg(target_os = "macos")]
 			main_window.add_border(None);
 
-			let (client, bootstrap_relays) = tauri::async_runtime::block_on(async move {
+			let client = tauri::async_runtime::block_on(async move {
-				// Create data folder if not exist
+				// Get config directory
 				let dir =
 					handle.path().app_config_dir().expect("Error: config directory not found.");
+
+				// Create config directory if not exist
 				let _ = fs::create_dir_all(&dir);
 
 				// Setup database
@@ -105,12 +92,7 @@ fn main() {
 					.expect("Error: cannot create database.");
 
 				// Setup nostr client
-				let opts = Options::new()
+				let opts = Options::new().gossip(true).autoconnect(true);
-					.autoconnect(true)
-					.timeout(Duration::from_secs(30))
-					.send_timeout(Some(Duration::from_secs(2)))
-					.connection_timeout(Some(Duration::from_secs(10)));
-
 				let client = ClientBuilder::default().opts(opts).database(database).build();
 
 				// Add bootstrap relays
@@ -141,22 +123,11 @@ fn main() {
 					}
 				}
 
-				let bootstrap_relays = client
+				client
-					.relays()
-					.await
-					.keys()
-					.map(|item| item.to_string())
-					.collect::<Vec<String>>();
-
-				(client, bootstrap_relays)
 			});
 
 			// Create global state
-			app.manage(Nostr {
+			app.manage(Nostr { client, inbox_relays: Mutex::new(HashMap::new()) });
-				client,
-				bootstrap_relays: Mutex::new(bootstrap_relays),
-				inbox_relays: Mutex::new(HashMap::new()),
-			});
 
 			Ok(())
 		})