438 lines
13 KiB
Rust
438 lines
13 KiB
Rust
use keyring::Entry;
|
|
use keyring_search::{Limit, List, Search};
|
|
use nostr_sdk::prelude::*;
|
|
use serde::{Deserialize, Serialize};
|
|
use specta::Type;
|
|
use std::{collections::HashSet, str::FromStr, time::Duration};
|
|
use tauri::{Emitter, Manager, State};
|
|
use tauri_plugin_notification::NotificationExt;
|
|
|
|
use crate::Nostr;
|
|
|
|
#[derive(Clone, Serialize)]
|
|
pub struct EventPayload {
|
|
event: String, // JSON String
|
|
sender: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Serialize, Deserialize, Type)]
|
|
struct Account {
|
|
password: String,
|
|
nostr_connect: Option<String>,
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn get_metadata(user_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(&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
|
|
{
|
|
Ok(events) => {
|
|
if let Some(event) = events.first() {
|
|
Ok(Metadata::from_json(&event.content).unwrap_or(Metadata::new()).as_json())
|
|
} else {
|
|
Ok(Metadata::new().as_json())
|
|
}
|
|
}
|
|
Err(e) => Err(e.to_string()),
|
|
}
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn get_accounts() -> Vec<String> {
|
|
let search = Search::new().expect("Unexpected.");
|
|
let results = search.by_service("Coop Secret Storage");
|
|
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 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 bech32 = public_key.to_bech32().map_err(|e| e.to_string())?;
|
|
|
|
Ok(bech32)
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn create_account(
|
|
name: String,
|
|
about: String,
|
|
picture: String,
|
|
password: String,
|
|
state: State<'_, Nostr>,
|
|
) -> Result<String, String> {
|
|
let client = &state.client;
|
|
let keys = Keys::generate();
|
|
let npub = keys.public_key().to_bech32().map_err(|e| e.to_string())?;
|
|
let secret_key = keys.secret_key();
|
|
let enc = EncryptedSecretKey::new(secret_key, password, 16, KeySecurity::Medium)
|
|
.map_err(|err| err.to_string())?;
|
|
let enc_bech32 = enc.to_bech32().map_err(|err| err.to_string())?;
|
|
|
|
// Save account
|
|
let keyring = Entry::new("Coop Secret Storage", &npub).map_err(|e| e.to_string())?;
|
|
let account = Account { password: enc_bech32, nostr_connect: None };
|
|
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;
|
|
|
|
let mut metadata =
|
|
Metadata::new().display_name(name.clone()).name(name.to_lowercase()).about(about);
|
|
|
|
if let Ok(url) = Url::parse(&picture) {
|
|
metadata = metadata.picture(url)
|
|
}
|
|
|
|
match client.set_metadata(&metadata).await {
|
|
Ok(_) => Ok(npub),
|
|
Err(e) => Err(e.to_string()),
|
|
}
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn import_account(key: String, password: String) -> Result<String, String> {
|
|
let (npub, enc_bech32) = match key.starts_with("ncryptsec") {
|
|
true => {
|
|
let enc = EncryptedSecretKey::from_bech32(key).map_err(|err| err.to_string())?;
|
|
let enc_bech32 = enc.to_bech32().map_err(|err| err.to_string())?;
|
|
let secret_key = enc.to_secret_key(password).map_err(|err| err.to_string())?;
|
|
let keys = Keys::new(secret_key);
|
|
let npub = keys.public_key().to_bech32().unwrap();
|
|
|
|
(npub, enc_bech32)
|
|
}
|
|
false => {
|
|
let secret_key = SecretKey::from_bech32(key).map_err(|err| err.to_string())?;
|
|
let keys = Keys::new(secret_key.clone());
|
|
let npub = keys.public_key().to_bech32().unwrap();
|
|
|
|
let enc = EncryptedSecretKey::new(&secret_key, password, 16, KeySecurity::Medium)
|
|
.map_err(|err| err.to_string())?;
|
|
|
|
let enc_bech32 = enc.to_bech32().map_err(|err| err.to_string())?;
|
|
|
|
(npub, enc_bech32)
|
|
}
|
|
};
|
|
|
|
let keyring = Entry::new("Coop Secret Storage", &npub).map_err(|e| e.to_string())?;
|
|
|
|
let account = Account { password: enc_bech32, nostr_connect: None };
|
|
|
|
let pwd = serde_json::to_string(&account).map_err(|e| e.to_string())?;
|
|
keyring.set_password(&pwd).map_err(|e| e.to_string())?;
|
|
|
|
Ok(npub)
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn connect_account(uri: String, state: State<'_, Nostr>) -> Result<String, String> {
|
|
let client = &state.client;
|
|
|
|
match NostrConnectURI::parse(uri.clone()) {
|
|
Ok(bunker_uri) => {
|
|
// Local user
|
|
let app_keys = Keys::generate();
|
|
let app_secret = app_keys.secret_key().to_secret_hex();
|
|
|
|
// 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 mut url = Url::parse(&uri).unwrap();
|
|
let query: Vec<(String, String)> = url
|
|
.query_pairs()
|
|
.filter(|(name, _)| name != "secret")
|
|
.map(|(name, value)| (name.into_owned(), value.into_owned()))
|
|
.collect();
|
|
url.query_pairs_mut().clear().extend_pairs(&query);
|
|
|
|
let key = format!("{}_nostrconnect", remote_npub);
|
|
let keyring = Entry::new("Coop Secret Storage", &key).unwrap();
|
|
let account =
|
|
Account { password: app_secret, nostr_connect: Some(url.to_string()) };
|
|
let j = serde_json::to_string(&account).map_err(|e| e.to_string())?;
|
|
let _ = keyring.set_password(&j);
|
|
|
|
// 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 reset_password(key: String, password: String) -> Result<(), String> {
|
|
let secret_key = SecretKey::from_bech32(key).map_err(|err| err.to_string())?;
|
|
let keys = Keys::new(secret_key.clone());
|
|
let npub = keys.public_key().to_bech32().unwrap();
|
|
|
|
let enc = EncryptedSecretKey::new(&secret_key, password, 16, KeySecurity::Medium)
|
|
.map_err(|err| err.to_string())?;
|
|
let enc_bech32 = enc.to_bech32().map_err(|err| err.to_string())?;
|
|
|
|
let keyring = Entry::new("Coop Secret Storage", &npub).map_err(|e| e.to_string())?;
|
|
let account = Account { password: enc_bech32, nostr_connect: None };
|
|
let j = serde_json::to_string(&account).map_err(|e| e.to_string())?;
|
|
let _ = keyring.set_password(&j);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub fn delete_account(id: String) -> Result<(), String> {
|
|
let keyring = Entry::new("Coop Secret Storage", &id).map_err(|e| e.to_string())?;
|
|
let _ = keyring.delete_credential();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
#[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(contacts) => {
|
|
let list = contacts.into_iter().map(|c| c.public_key.to_hex()).collect::<Vec<_>>();
|
|
Ok(list)
|
|
}
|
|
Err(e) => Err(e.to_string()),
|
|
}
|
|
}
|
|
|
|
#[tauri::command]
|
|
#[specta::specta]
|
|
pub async fn login(
|
|
account: String,
|
|
password: String,
|
|
state: State<'_, Nostr>,
|
|
handle: tauri::AppHandle,
|
|
) -> Result<String, String> {
|
|
let client = &state.client;
|
|
let keyring = Entry::new("Coop Secret Storage", &account).map_err(|e| e.to_string())?;
|
|
|
|
let account = match keyring.get_password() {
|
|
Ok(pw) => {
|
|
let account: Account = serde_json::from_str(&pw).map_err(|e| e.to_string())?;
|
|
account
|
|
}
|
|
Err(e) => return Err(e.to_string()),
|
|
};
|
|
|
|
let public_key = match account.nostr_connect {
|
|
None => {
|
|
let ncryptsec =
|
|
EncryptedSecretKey::from_bech32(account.password).map_err(|e| e.to_string())?;
|
|
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;
|
|
|
|
public_key
|
|
}
|
|
Some(bunker) => {
|
|
let uri = NostrConnectURI::parse(bunker).map_err(|e| e.to_string())?;
|
|
let public_key = uri.signer_public_key().unwrap();
|
|
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).await {
|
|
Ok(signer) => {
|
|
// Update signer
|
|
client.set_signer(Some(signer.into())).await;
|
|
public_key
|
|
}
|
|
Err(e) => return Err(e.to_string()),
|
|
}
|
|
}
|
|
};
|
|
|
|
let inbox = Filter::new().kind(Kind::Custom(10050)).author(public_key).limit(1);
|
|
|
|
if let Ok(events) =
|
|
client.get_events_of(vec![inbox], EventSource::relays(Some(Duration::from_secs(3)))).await
|
|
{
|
|
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<_>>();
|
|
|
|
for url in urls.iter() {
|
|
if let Err(e) = client.add_relay(url).await {
|
|
println!("Connect relay failed: {}", e)
|
|
}
|
|
}
|
|
|
|
// Workaround for https://github.com/rust-nostr/nostr/issues/509
|
|
// TODO: remove this
|
|
let _ = client
|
|
.get_events_from(
|
|
urls.clone(),
|
|
vec![Filter::new().kind(Kind::TextNote).limit(0)],
|
|
Some(Duration::from_secs(5)),
|
|
)
|
|
.await;
|
|
|
|
let mut inbox_relays = state.inbox_relays.lock().await;
|
|
inbox_relays.insert(public_key, urls);
|
|
} else {
|
|
return Err("404".into());
|
|
}
|
|
}
|
|
|
|
let sub_id = SubscriptionId::new("inbox");
|
|
let new_message = Filter::new().kind(Kind::GiftWrap).pubkey(public_key).limit(0);
|
|
|
|
if client.subscription(&sub_id).await.is_some() {
|
|
// Remove old subscriotion
|
|
client.unsubscribe(sub_id.clone()).await;
|
|
// Resubscribe new message for current user
|
|
let _ = client.subscribe_with_id(sub_id.clone(), vec![new_message], None).await;
|
|
} else {
|
|
let _ = client.subscribe_with_id(sub_id.clone(), vec![new_message], None).await;
|
|
}
|
|
|
|
tauri::async_runtime::spawn(async move {
|
|
let state = handle.state::<Nostr>();
|
|
let client = &state.client;
|
|
|
|
let filter = Filter::new().kind(Kind::GiftWrap).pubkey(public_key);
|
|
|
|
// Generate a fake sig for rumor event.
|
|
// TODO: Find better way to save unsigned event to database.
|
|
let fake_sig = Signature::from_str("f9e79d141c004977192d05a86f81ec7c585179c371f7350a5412d33575a2a356433f58e405c2296ed273e2fe0aafa25b641e39cc4e1f3f261ebf55bce0cbac83").unwrap();
|
|
|
|
if let Ok(events) = client
|
|
.pool()
|
|
.get_events_of(
|
|
vec![filter],
|
|
Duration::from_secs(12),
|
|
FilterOptions::WaitDurationAfterEOSE(Duration::from_secs(20)),
|
|
)
|
|
.await
|
|
{
|
|
for event in events.iter() {
|
|
if let Ok(UnwrappedGift { rumor, .. }) = client.unwrap_gift_wrap(event).await {
|
|
let rumor_clone = rumor.clone();
|
|
let ev = Event::new(
|
|
rumor_clone.id.unwrap(),
|
|
rumor_clone.pubkey,
|
|
rumor_clone.created_at,
|
|
rumor_clone.kind,
|
|
rumor_clone.tags,
|
|
rumor_clone.content,
|
|
fake_sig,
|
|
);
|
|
|
|
if let Err(e) = client.database().save_event(&ev).await {
|
|
println!("Error: {}", e)
|
|
}
|
|
}
|
|
}
|
|
handle.emit("synchronized", ()).unwrap();
|
|
}
|
|
|
|
client
|
|
.handle_notifications(|notification| async {
|
|
if let RelayPoolNotification::Message { message, .. } = notification {
|
|
if let RelayMessage::Event { event, subscription_id, .. } = message {
|
|
if subscription_id == sub_id && event.kind == Kind::GiftWrap {
|
|
if let Ok(UnwrappedGift { rumor, sender }) =
|
|
client.unwrap_gift_wrap(&event).await
|
|
{
|
|
let rumor_clone = rumor.clone();
|
|
let ev = Event::new(
|
|
rumor_clone.id.unwrap(),
|
|
rumor_clone.pubkey,
|
|
rumor_clone.created_at,
|
|
rumor_clone.kind,
|
|
rumor_clone.tags,
|
|
rumor_clone.content,
|
|
fake_sig,
|
|
);
|
|
|
|
// Save rumor to database to further query
|
|
if let Err(e) = client.database().save_event(&ev).await {
|
|
println!("[save event] error: {}", e)
|
|
}
|
|
|
|
// Emit new event to frontend
|
|
if let Err(e) = handle.emit(
|
|
"event",
|
|
EventPayload {
|
|
event: rumor.as_json(),
|
|
sender: sender.to_hex(),
|
|
},
|
|
) {
|
|
println!("[emit] error: {}", e)
|
|
}
|
|
|
|
if sender != public_key {
|
|
if let Some(window) = handle.get_webview_window("main") {
|
|
if !window.is_focused().unwrap() {
|
|
if let Err(e) = handle
|
|
.notification()
|
|
.builder()
|
|
.body("You have a new message")
|
|
.title("Coop")
|
|
.show()
|
|
{
|
|
println!("[notification] error: {}", e);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
println!("relay message: {}", message.as_json())
|
|
}
|
|
}
|
|
Ok(false)
|
|
})
|
|
.await
|
|
});
|
|
|
|
Ok(public_key.to_hex())
|
|
}
|