feat: add relay manager

src-tauri/resources/relays.txt

@@ -0,0 +1,4 @@
+wss://purplepag.es/,
+wss://directory.yabu.me/,
+wss://user.kindpag.es/,
+wss://relay.nos.social/,

src-tauri/src/commands/account.rs

@@ -5,7 +5,7 @@ use serde::Serialize;
 use std::{collections::HashSet, str::FromStr, time::Duration};
 use tauri::{Emitter, Manager, State};
 
-use crate::{Nostr, BOOTSTRAP_RELAYS};
+use crate::Nostr;
 
 #[derive(Clone, Serialize)]
 pub struct EventPayload {
@@ -32,8 +32,7 @@ pub async fn get_metadata(id: String, state: State<'_, Nostr>) -> Result<String,
 	let public_key = PublicKey::parse(&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(3))).await
-	{
+	match client.get_events_of(vec![filter], Some(Duration::from_secs(3))).await {
 		Ok(events) => {
 			if let Some(event) = events.first() {
 				Ok(Metadata::from_json(&event.content).unwrap_or(Metadata::new()).as_json())
@@ -171,51 +170,6 @@ pub async fn get_contact_list(state: State<'_, Nostr>) -> Result<Vec<String>, St
 	}
 }
 
-#[tauri::command]
-#[specta::specta]
-pub async fn get_inbox(id: String, state: State<'_, Nostr>) -> Result<Vec<String>, String> {
-	let client = &state.client;
-	let public_key = PublicKey::parse(id).map_err(|e| e.to_string())?;
-	let inbox = Filter::new().kind(Kind::Custom(10050)).author(public_key).limit(1);
-
-	match client.get_events_from(BOOTSTRAP_RELAYS, vec![inbox], None).await {
-		Ok(events) => {
-			if let Some(event) = events.into_iter().next() {
-				let urls = event
-					.tags()
-					.iter()
-					.filter_map(|tag| {
-						if let Some(TagStandard::Relay(relay)) = tag.as_standardized() {
-							Some(relay.to_string())
-						} else {
-							None
-						}
-					})
-					.collect::<Vec<_>>();
-
-				Ok(urls)
-			} else {
-				Ok(Vec::new())
-			}
-		}
-		Err(e) => Err(e.to_string()),
-	}
-}
-
-#[tauri::command]
-#[specta::specta]
-pub async fn set_inbox(relays: Vec<String>, state: State<'_, Nostr>) -> Result<(), String> {
-	let client = &state.client;
-
-	let tags = relays.into_iter().map(|t| Tag::custom(TagKind::Relay, vec![t])).collect::<Vec<_>>();
-	let event = EventBuilder::new(Kind::Custom(10050), "", tags);
-
-	match client.send_event_builder(event).await {
-		Ok(_) => Ok(()),
-		Err(e) => Err(e.to_string()),
-	}
-}
-
 #[tauri::command]
 #[specta::specta]
 pub async fn login(

src-tauri/src/commands/mod.rs

@@ -1,2 +1,3 @@
 pub mod account;
 pub mod chat;
+pub mod relay;

src-tauri/src/commands/relay.rs

@@ -0,0 +1,82 @@
+use nostr_sdk::prelude::*;
+use std::{
+	fs::OpenOptions,
+	io::{self, BufRead, Write},
+};
+use tauri::{Manager, State};
+
+use crate::Nostr;
+
+#[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", tauri::path::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 set_bootstrap_relays(relays: String, app: tauri::AppHandle) -> Result<(), String> {
+	let relays_path = app
+		.path()
+		.resolve("resources/relays.txt", tauri::path::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())
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn get_inbox_relays(
+	user_id: String,
+	state: State<'_, Nostr>,
+) -> Result<Vec<String>, String> {
+	let client = &state.client;
+	let public_key = PublicKey::parse(user_id).map_err(|e| e.to_string())?;
+	let inbox = Filter::new().kind(Kind::Custom(10050)).author(public_key).limit(1);
+
+	match client.get_events_of(vec![inbox], None).await {
+		Ok(events) => {
+			if let Some(event) = events.into_iter().next() {
+				let urls = event
+					.tags()
+					.iter()
+					.filter_map(|tag| {
+						if let Some(TagStandard::Relay(relay)) = tag.as_standardized() {
+							Some(relay.to_string())
+						} else {
+							None
+						}
+					})
+					.collect::<Vec<_>>();
+
+				Ok(urls)
+			} else {
+				Ok(Vec::new())
+			}
+		}
+		Err(e) => Err(e.to_string()),
+	}
+}
+
+#[tauri::command]
+#[specta::specta]
+pub async fn set_inbox_relays(relays: Vec<String>, state: State<'_, Nostr>) -> Result<(), String> {
+	let client = &state.client;
+
+	let tags = relays.into_iter().map(|t| Tag::custom(TagKind::Relay, vec![t])).collect::<Vec<_>>();
+	let event = EventBuilder::new(Kind::Custom(10050), "", tags);
+
+	match client.send_event_builder(event).await {
+		Ok(_) => Ok(()),
+		Err(e) => Err(e.to_string()),
+	}
+}

src-tauri/src/main.rs

@@ -4,12 +4,18 @@
 #[cfg(target_os = "macos")]
 use border::WebviewWindowExt as WebviewWindowExtAlt;
 use nostr_sdk::prelude::*;
-use std::{collections::HashMap, fs, time::Duration};
+use std::{
+	collections::HashMap,
+	fs,
+	io::{self, BufRead},
+	str::FromStr,
+	time::Duration,
+};
 use tauri::{async_runtime::Mutex, Manager};
 #[cfg(not(target_os = "linux"))]
 use tauri_plugin_decorum::WebviewWindowExt;
 
-use commands::{account::*, chat::*};
+use commands::{account::*, chat::*, relay::*};
 
 mod commands;
 
@@ -18,12 +24,13 @@ pub struct Nostr {
 	inbox_relays: Mutex<HashMap<PublicKey, Vec<String>>>,
 }
 
-// TODO: Allow user config bootstrap relays.
-pub const BOOTSTRAP_RELAYS: [&str; 2] = ["wss://relay.damus.io/", "wss://relay.nostr.net/"];
-
 fn main() {
 	let invoke_handler = {
 		let builder = tauri_specta::ts::builder().commands(tauri_specta::collect_commands![
+			get_bootstrap_relays,
+			set_bootstrap_relays,
+			get_inbox_relays,
+			set_inbox_relays,
 			login,
 			delete_account,
 			create_account,
@@ -34,8 +41,6 @@ fn main() {
 			get_contact_list,
 			get_chats,
 			get_chat_messages,
-			get_inbox,
-			set_inbox,
 			connect_inbox,
 			disconnect_inbox,
 			send_message,
@@ -102,8 +107,35 @@ fn main() {
 
 				let client = ClientBuilder::default().opts(opts).database(database).build();
 
-				// Add bootstrap relay
-				let _ = client.add_relays(BOOTSTRAP_RELAYS).await;
+				// Add bootstrap relays
+				if let Ok(path) = handle
+					.path()
+					.resolve("resources/relays.txt", tauri::path::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) => {
+									println!("Connecting to relay...: {} - {}", relay, meta);
+									let opts = if meta == RelayMetadata::Read {
+										RelayOptions::new().read(true).write(false)
+									} else {
+										RelayOptions::new().write(true).read(false)
+									};
+									let _ = client.add_relay_with_opts(relay, opts).await;
+								}
+								Err(_) => {
+									println!("Connecting to relay...: {}", relay);
+									let _ = client.add_relay(relay).await;
+								}
+							}
+						}
+					}
+				}
 
 				// Connect
 				client.connect().await;

src-tauri/tauri.conf.json

@@ -38,6 +38,9 @@
 		"targets": "all",
 		"active": true,
 		"category": "SocialNetworking",
+		"resources": [
+			"resources/*"
+		],
 		"icon": [
 			"icons/32x32.png",
 			"icons/128x128.png",