reya/coop
1
0
Fork 0
Code Issues Pull Requests Releases Activity

fix: inbox relay isn't connect when send message in compose dialog

Browse Source
This commit is contained in:
reya
2024-08-06 10:05:52 +07:00
parent c3334d91cf
commit 01284db42e
14 changed files with 193 additions and 111 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
src-tauri/src/commands/account.rs
View File

@@ -27,12 +27,12 @@ pub fn get_accounts() -> Vec<String> {
#[tauri::command]
#[specta::specta]
pub async fn get_metadata(id: String, state: State<'_, Nostr>) -> Result<String, String> {
pub async fn get_metadata(user_id: String, state: State<'_, Nostr>) -> Result<String, String> {
let client = &state.client;
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_of(vec![filter], Some(Duration::from_secs(3))).await {
match client.get_events_of(vec![filter], Some(Duration::from_secs(2))).await {
Ok(events) => {
if let Some(event) = events.first() {
Ok(Metadata::from_json(&event.content).unwrap_or(Metadata::new()).as_json())

66
src-tauri/src/commands/chat.rs
View File

@@ -1,7 +1,6 @@
use itertools::Itertools;
use nostr_sdk::prelude::*;
use std::cmp::Reverse;
use std::time::Duration;
use tauri::State;
use crate::Nostr;
@@ -54,62 +53,6 @@ pub async fn get_chat_messages(id: String, state: State<'_, Nostr>) -> Result<Ve
}
}
#[tauri::command]
#[specta::specta]
pub async fn connect_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 mut inbox_relays = state.inbox_relays.lock().await;
if let Some(relays) = inbox_relays.get(&public_key) {
for relay in relays {
let _ = client.connect_relay(relay).await;
}
return Ok(relays.to_owned());
}
let inbox = Filter::new().kind(Kind::Custom(10050)).author(public_key).limit(1);
match client.get_events_of(vec![inbox], Some(Duration::from_secs(2))).await {
Ok(events) => {
let mut relays = Vec::new();
if let Some(event) = events.into_iter().next() {
for tag in &event.tags {
if let Some(TagStandard::Relay(relay)) = tag.as_standardized() {
let url = relay.to_string();
let _ = client.add_relay(&url).await;
let _ = client.connect_relay(&url).await;
relays.push(url)
}
}
inbox_relays.insert(public_key, relays.clone());
}
Ok(relays)
}
Err(e) => Err(e.to_string()),
}
}
#[tauri::command]
#[specta::specta]
pub async fn disconnect_inbox(id: String, state: State<'_, Nostr>) -> Result<(), String> {
let client = &state.client;
let public_key = PublicKey::parse(&id).map_err(|e| e.to_string())?;
let inbox_relays = state.inbox_relays.lock().await;
if let Some(relays) = inbox_relays.get(&public_key) {
for relay in relays {
let _ = client.disconnect_relay(relay).await;
}
}
Ok(())
}
#[tauri::command]
#[specta::specta]
pub async fn send_message(
@@ -126,24 +69,27 @@ pub async fn send_message(
// TODO: Add support reply_to
let rumor = EventBuilder::private_msg_rumor(receiver, message, None);
// Get inbox relays
// Get inbox state
let relays = state.inbox_relays.lock().await;
// Get inbox relays per member
let outbox = relays.get(&receiver);
let inbox = relays.get(&public_key);
let outbox_urls = match outbox {
Some(relays) => relays,
None => return Err("User's didn't have inbox relays to receive message.".into()),
None => return Err("Receiver didn't have inbox relays to receive message.".into()),
};
let inbox_urls = match inbox {
Some(relays) => relays,
None => return Err("User's didn't have inbox relays to receive message.".into()),
None => return Err("Please config inbox relays to backup your message.".into()),
};
// Send message to [receiver]
match client.gift_wrap_to(outbox_urls, receiver, rumor.clone(), None).await {
Ok(_) => {
// Send message to [yourself]
if let Err(e) = client.gift_wrap_to(inbox_urls, public_key, rumor, None).await {
return Err(e.to_string());
}

98
src-tauri/src/commands/relay.rs
View File

@@ -2,11 +2,27 @@ use nostr_sdk::prelude::*;
use std::{
fs::OpenOptions,
io::{self, BufRead, Write},
time::Duration,
};
use tauri::{Manager, State};
use crate::Nostr;
async fn get_nip65_list(public_key: PublicKey, client: &Client) -> Vec<String> {
let filter = Filter::new().author(public_key).kind(Kind::RelayList).limit(1);
let mut relay_list: Vec<String> = Vec::new();
if let Ok(events) = client.get_events_of(vec![filter], Some(Duration::from_secs(10))).await {
if let Some(event) = events.first() {
for (url, ..) in nip65::extract_relay_list(event) {
relay_list.push(url.to_string())
}
}
};
relay_list
}
#[tauri::command]
#[specta::specta]
pub fn get_bootstrap_relays(app: tauri::AppHandle) -> Result<Vec<String>, String> {
@@ -80,3 +96,85 @@ pub async fn set_inbox_relays(relays: Vec<String>, state: State<'_, Nostr>) -> R
Err(e) => Err(e.to_string()),
}
}
#[tauri::command]
#[specta::specta]
pub async fn connect_inbox_relays(
user_id: String,
ignore_cache: bool,
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 mut inbox_relays = state.inbox_relays.lock().await;
if !ignore_cache {
if let Some(relays) = inbox_relays.get(&public_key) {
for relay in relays {
let _ = client.connect_relay(relay).await;
}
return Ok(relays.to_owned());
};
};
let inbox = Filter::new().kind(Kind::Custom(10050)).author(public_key).limit(1);
match client.get_events_of(vec![inbox], Some(Duration::from_secs(2))).await {
Ok(events) => {
let mut relays = Vec::new();
if let Some(event) = events.into_iter().next() {
for tag in &event.tags {
if let Some(TagStandard::Relay(relay)) = tag.as_standardized() {
let url = relay.to_string();
let _ = client.add_relay(&url).await;
let _ = client.connect_relay(&url).await;
relays.push(url)
}
}
inbox_relays.insert(public_key, relays.clone());
}
// Workaround for https://github.com/rust-nostr/nostr/issues/509
// TODO: remove this
// let relays_clone = relays.clone();
/*tauri::async_runtime::spawn(async move {
let state = handle.state::<Nostr>();
let client = &state.client;
client
.get_events_from(
relays_clone,
vec![Filter::new().kind(Kind::TextNote).limit(0)],
Some(Duration::from_secs(5)),
)
.await
});
*/
Ok(relays)
}
Err(e) => Err(e.to_string()),
}
}
#[tauri::command]
#[specta::specta]
pub async fn disconnect_inbox_relays(
user_id: String,
state: State<'_, Nostr>,
) -> Result<(), String> {
let client = &state.client;
let public_key = PublicKey::parse(&user_id).map_err(|e| e.to_string())?;
let inbox_relays = state.inbox_relays.lock().await;
if let Some(relays) = inbox_relays.get(&public_key) {
for relay in relays {
let _ = client.disconnect_relay(relay).await;
}
}
Ok(())
}

4
src-tauri/src/main.rs
View File

@@ -31,6 +31,8 @@ fn main() {
set_bootstrap_relays,
get_inbox_relays,
set_inbox_relays,
connect_inbox_relays,
disconnect_inbox_relays,
login,
delete_account,
create_account,
@@ -41,8 +43,6 @@ fn main() {
get_contact_list,
get_chats,
get_chat_messages,
connect_inbox,
disconnect_inbox,
send_message,
]);