805 lines
26 KiB
Rust
805 lines
26 KiB
Rust
use std::collections::HashMap;
|
|
use std::path::PathBuf;
|
|
use std::sync::Arc;
|
|
use std::time::Duration;
|
|
|
|
use anyhow::{Context as AnyhowContext, Error, anyhow};
|
|
use common::config_dir;
|
|
use gpui::{App, AppContext, Context, Entity, EventEmitter, Global, SharedString, Task, Window};
|
|
use nostr_connect::prelude::*;
|
|
use nostr_gossip_memory::prelude::*;
|
|
use nostr_lmdb::prelude::*;
|
|
use nostr_sdk::prelude::*;
|
|
|
|
mod blossom;
|
|
mod constants;
|
|
mod device;
|
|
mod nip05;
|
|
mod signer;
|
|
|
|
pub use blossom::*;
|
|
pub use constants::*;
|
|
pub use device::*;
|
|
pub use nip05::*;
|
|
pub use signer::*;
|
|
|
|
pub fn init(window: &mut Window, cx: &mut App) {
|
|
// rustls uses the `aws_lc_rs` provider by default
|
|
// This only errors if the default provider has already
|
|
// been installed. We can ignore this `Result`.
|
|
rustls::crypto::aws_lc_rs::default_provider()
|
|
.install_default()
|
|
.ok();
|
|
|
|
// Initialize the tokio runtime
|
|
gpui_tokio::init(cx);
|
|
|
|
NostrRegistry::set_global(cx.new(|cx| NostrRegistry::new(window, cx)), cx);
|
|
}
|
|
|
|
struct GlobalNostrRegistry(Entity<NostrRegistry>);
|
|
|
|
impl Global for GlobalNostrRegistry {}
|
|
|
|
/// Signer event.
|
|
#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
|
|
pub enum StateEvent {
|
|
/// Connecting to the bootstrapping relay
|
|
Connecting,
|
|
/// Connected to the bootstrapping relay
|
|
Connected,
|
|
/// Creating the signer
|
|
Creating,
|
|
/// Show the identity dialog
|
|
Show,
|
|
/// A new signer has been set
|
|
SignerSet,
|
|
/// An error occurred
|
|
Error(SharedString),
|
|
}
|
|
|
|
impl StateEvent {
|
|
pub fn error<T>(error: T) -> Self
|
|
where
|
|
T: Into<SharedString>,
|
|
{
|
|
Self::Error(error.into())
|
|
}
|
|
}
|
|
|
|
/// Nostr Registry
|
|
#[derive(Debug)]
|
|
pub struct NostrRegistry {
|
|
/// Nostr client
|
|
client: Client,
|
|
|
|
/// Nostr signer
|
|
signer: Arc<CoopSigner>,
|
|
|
|
/// All local stored identities
|
|
npubs: Entity<Vec<PublicKey>>,
|
|
|
|
/// Keys directory
|
|
key_dir: PathBuf,
|
|
|
|
/// Master app keys used for various operations.
|
|
///
|
|
/// Example: Nostr Connect and NIP-4e operations
|
|
app_keys: Keys,
|
|
|
|
/// Tasks for asynchronous operations
|
|
tasks: Vec<Task<Result<(), Error>>>,
|
|
}
|
|
|
|
impl EventEmitter<StateEvent> for NostrRegistry {}
|
|
|
|
impl NostrRegistry {
|
|
/// Retrieve the global nostr state
|
|
pub fn global(cx: &App) -> Entity<Self> {
|
|
cx.global::<GlobalNostrRegistry>().0.clone()
|
|
}
|
|
|
|
/// Set the global nostr instance
|
|
fn set_global(state: Entity<Self>, cx: &mut App) {
|
|
cx.set_global(GlobalNostrRegistry(state));
|
|
}
|
|
|
|
/// Create a new nostr instance
|
|
fn new(window: &mut Window, cx: &mut Context<Self>) -> Self {
|
|
let key_dir = config_dir().join("keys");
|
|
let app_keys = get_or_init_app_keys(cx).unwrap_or(Keys::generate());
|
|
|
|
// Construct the nostr signer
|
|
let signer = Arc::new(CoopSigner::new(app_keys.clone()));
|
|
|
|
// Get all local stored npubs
|
|
let npubs = cx.new(|_| match Self::discover(&key_dir) {
|
|
Ok(npubs) => npubs,
|
|
Err(e) => {
|
|
log::error!("Failed to discover npubs: {e}");
|
|
vec![]
|
|
}
|
|
});
|
|
|
|
// Construct the nostr lmdb instance
|
|
let lmdb = cx.foreground_executor().block_on(async move {
|
|
NostrLmdb::open(config_dir().join("nostr"))
|
|
.await
|
|
.expect("Failed to initialize database")
|
|
});
|
|
|
|
// Construct the nostr client
|
|
let client = ClientBuilder::default()
|
|
.signer(signer.clone())
|
|
.database(lmdb)
|
|
.gossip(NostrGossipMemory::unbounded())
|
|
.automatic_authentication(false)
|
|
.connect_timeout(Duration::from_secs(10))
|
|
.sleep_when_idle(SleepWhenIdle::Enabled {
|
|
timeout: Duration::from_secs(600),
|
|
})
|
|
.build();
|
|
|
|
// Run at the end of current cycle
|
|
cx.defer_in(window, |this, _window, cx| {
|
|
this.connect(cx);
|
|
// Create an identity if none exists
|
|
if this.npubs.read(cx).is_empty() {
|
|
this.create_identity(cx);
|
|
} else {
|
|
// Show the identity dialog
|
|
cx.emit(StateEvent::Show);
|
|
}
|
|
});
|
|
|
|
Self {
|
|
client,
|
|
signer,
|
|
npubs,
|
|
key_dir,
|
|
app_keys,
|
|
tasks: vec![],
|
|
}
|
|
}
|
|
|
|
/// Get the nostr client
|
|
pub fn client(&self) -> Client {
|
|
self.client.clone()
|
|
}
|
|
|
|
/// Get the nostr signer
|
|
pub fn signer(&self) -> Arc<CoopSigner> {
|
|
self.signer.clone()
|
|
}
|
|
|
|
/// Get the npubs entity
|
|
pub fn npubs(&self) -> Entity<Vec<PublicKey>> {
|
|
self.npubs.clone()
|
|
}
|
|
|
|
/// Get the app keys
|
|
pub fn keys(&self) -> Keys {
|
|
self.app_keys.clone()
|
|
}
|
|
|
|
/// Discover all npubs in the keys directory
|
|
fn discover(dir: &PathBuf) -> Result<Vec<PublicKey>, Error> {
|
|
// Ensure keys directory exists
|
|
std::fs::create_dir_all(dir)?;
|
|
|
|
let files = std::fs::read_dir(dir)?;
|
|
let mut entries = Vec::new();
|
|
let mut npubs: Vec<PublicKey> = Vec::new();
|
|
|
|
for file in files.flatten() {
|
|
let metadata = file.metadata()?;
|
|
let modified_time = metadata.modified()?;
|
|
let name = file.file_name().into_string().unwrap().replace(".npub", "");
|
|
entries.push((modified_time, name));
|
|
}
|
|
|
|
// Sort by modification time (most recent first)
|
|
entries.sort_by(|a, b| b.0.cmp(&a.0));
|
|
|
|
for (_, name) in entries {
|
|
let public_key = PublicKey::parse(&name)?;
|
|
npubs.push(public_key);
|
|
}
|
|
|
|
Ok(npubs)
|
|
}
|
|
|
|
/// Connect to the bootstrapping relays
|
|
fn connect(&mut self, cx: &mut Context<Self>) {
|
|
let client = self.client();
|
|
|
|
let task: Task<Result<(), Error>> = cx.background_spawn(async move {
|
|
// Add search relay to the relay pool
|
|
for url in SEARCH_RELAYS.into_iter() {
|
|
client
|
|
.add_relay(url)
|
|
.capabilities(RelayCapabilities::READ)
|
|
.await?;
|
|
}
|
|
|
|
// Add indexer relay to the relay pool
|
|
for url in INDEXER_RELAYS.into_iter() {
|
|
client
|
|
.add_relay(url)
|
|
.capabilities(RelayCapabilities::DISCOVERY)
|
|
.await?;
|
|
}
|
|
|
|
// Add bootstrap relay to the relay pool
|
|
for url in BOOTSTRAP_RELAYS.into_iter() {
|
|
client.add_relay(url).await?;
|
|
}
|
|
|
|
// Connect to all added relays
|
|
client
|
|
.connect()
|
|
.and_wait(Duration::from_secs(TIMEOUT))
|
|
.await;
|
|
|
|
Ok(())
|
|
});
|
|
|
|
// Emit connecting event
|
|
cx.emit(StateEvent::Connecting);
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
if let Err(e) = task.await {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(StateEvent::error(e.to_string()));
|
|
})?;
|
|
} else {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(StateEvent::Connected);
|
|
})?;
|
|
}
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Get the secret for a given npub.
|
|
pub fn get_secret(
|
|
&self,
|
|
public_key: PublicKey,
|
|
cx: &App,
|
|
) -> Task<Result<Arc<dyn NostrSigner>, Error>> {
|
|
let npub = public_key.to_bech32().unwrap();
|
|
let key_path = self.key_dir.join(format!("{}.npub", npub));
|
|
let app_keys = self.app_keys.clone();
|
|
|
|
if let Ok(payload) = std::fs::read_to_string(key_path) {
|
|
if !payload.is_empty() {
|
|
cx.background_spawn(async move {
|
|
let decrypted = app_keys.nip44_decrypt(&public_key, &payload).await?;
|
|
let secret = SecretKey::parse(&decrypted)?;
|
|
let keys = Keys::new(secret);
|
|
|
|
Ok(keys.into_nostr_signer())
|
|
})
|
|
} else {
|
|
self.get_secret_keyring(&npub, cx)
|
|
}
|
|
} else {
|
|
self.get_secret_keyring(&npub, cx)
|
|
}
|
|
}
|
|
|
|
/// Get the secret for a given npub in the OS credentials store.
|
|
#[deprecated = "Use get_secret instead"]
|
|
fn get_secret_keyring(
|
|
&self,
|
|
user: &str,
|
|
cx: &App,
|
|
) -> Task<Result<Arc<dyn NostrSigner>, Error>> {
|
|
let read = cx.read_credentials(user);
|
|
let app_keys = self.app_keys.clone();
|
|
|
|
cx.background_spawn(async move {
|
|
let (_, secret) = read
|
|
.await
|
|
.map_err(|_| anyhow!("Failed to get signer. Please re-import the secret key"))?
|
|
.ok_or_else(|| anyhow!("Failed to get signer. Please re-import the secret key"))?;
|
|
|
|
// Try to parse as a direct secret key first
|
|
if let Ok(secret_key) = SecretKey::from_slice(&secret) {
|
|
return Ok(Keys::new(secret_key).into_nostr_signer());
|
|
}
|
|
|
|
// Convert the secret into string
|
|
let sec = String::from_utf8(secret)
|
|
.map_err(|_| anyhow!("Failed to parse secret as UTF-8"))?;
|
|
|
|
// Try to parse as a NIP-46 URI
|
|
let uri =
|
|
NostrConnectUri::parse(&sec).map_err(|_| anyhow!("Failed to parse NIP-46 URI"))?;
|
|
|
|
let timeout = Duration::from_secs(NOSTR_CONNECT_TIMEOUT);
|
|
let mut nip46 = NostrConnect::new(uri, app_keys, timeout, None)?;
|
|
|
|
// Set the auth URL handler
|
|
nip46.auth_url_handler(CoopAuthUrlHandler);
|
|
|
|
Ok(nip46.into_nostr_signer())
|
|
})
|
|
}
|
|
|
|
/// Add a new npub to the keys directory
|
|
fn write_secret(
|
|
&self,
|
|
public_key: PublicKey,
|
|
secret: String,
|
|
cx: &App,
|
|
) -> Task<Result<(), Error>> {
|
|
let npub = public_key.to_bech32().unwrap();
|
|
let key_path = self.key_dir.join(format!("{}.npub", npub));
|
|
let app_keys = self.app_keys.clone();
|
|
|
|
cx.background_spawn(async move {
|
|
// If the secret starts with "bunker://" (nostr connect), use it directly; otherwise, encrypt it
|
|
let content = if secret.starts_with("bunker://") {
|
|
secret
|
|
} else {
|
|
app_keys.nip44_encrypt(&public_key, &secret).await?
|
|
};
|
|
|
|
// Write the encrypted secret to the keys directory
|
|
smol::fs::write(key_path, &content).await?;
|
|
|
|
Ok(())
|
|
})
|
|
}
|
|
|
|
/// Remove a secret
|
|
pub fn remove_secret(&mut self, public_key: &PublicKey, cx: &mut Context<Self>) {
|
|
let public_key = public_key.to_owned();
|
|
let npub = public_key.to_bech32().unwrap();
|
|
|
|
let keys_dir = config_dir().join("keys");
|
|
let key_path = keys_dir.join(format!("{}.npub", npub));
|
|
|
|
// Remove the secret file from the keys directory
|
|
std::fs::remove_file(key_path).ok();
|
|
|
|
self.npubs.update(cx, |this, cx| {
|
|
this.retain(|k| k != &public_key);
|
|
cx.notify();
|
|
});
|
|
}
|
|
|
|
/// Create a new identity
|
|
pub fn create_identity(&mut self, cx: &mut Context<Self>) {
|
|
let client = self.client();
|
|
let keys = Keys::generate();
|
|
let async_keys = keys.clone();
|
|
|
|
// Emit creating event
|
|
cx.emit(StateEvent::Creating);
|
|
|
|
// Create the write secret task
|
|
let write_secret =
|
|
self.write_secret(keys.public_key(), keys.secret_key().to_secret_hex(), cx);
|
|
|
|
// Run async tasks in background
|
|
let task: Task<Result<(), Error>> = cx.background_spawn(async move {
|
|
let signer = async_keys.into_nostr_signer();
|
|
|
|
// Construct relay list event
|
|
let relay_list = default_relay_list();
|
|
let event = EventBuilder::relay_list(relay_list).sign(&signer).await?;
|
|
|
|
// Publish relay list
|
|
client
|
|
.send_event(&event)
|
|
.to(BOOTSTRAP_RELAYS)
|
|
.ack_policy(AckPolicy::none())
|
|
.await?;
|
|
|
|
// Construct the default metadata
|
|
let name = petname::petname(2, "-").unwrap_or("Cooper".to_string());
|
|
let avatar = Url::parse(&format!("https://avatar.vercel.sh/{name}")).unwrap();
|
|
let metadata = Metadata::new().display_name(&name).picture(avatar);
|
|
let event = EventBuilder::metadata(&metadata).sign(&signer).await?;
|
|
|
|
// Publish metadata event
|
|
client
|
|
.send_event(&event)
|
|
.to_nip65()
|
|
.ack_policy(AckPolicy::none())
|
|
.await?;
|
|
|
|
// Construct the default contact list
|
|
let contacts = vec![Contact::new(PublicKey::parse(COOP_PUBKEY).unwrap())];
|
|
let event = EventBuilder::contact_list(contacts).sign(&signer).await?;
|
|
|
|
// Publish contact list event
|
|
client
|
|
.send_event(&event)
|
|
.to_nip65()
|
|
.ack_policy(AckPolicy::none())
|
|
.await?;
|
|
|
|
// Construct the default messaging relay list
|
|
let relays = default_messaging_relays();
|
|
let event = EventBuilder::nip17_relay_list(relays).sign(&signer).await?;
|
|
|
|
// Publish messaging relay list event
|
|
client.send_event(&event).to_nip65().await?;
|
|
|
|
// Write user's credentials to the system keyring
|
|
write_secret.await?;
|
|
|
|
Ok(())
|
|
});
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
match task.await {
|
|
Ok(_) => {
|
|
this.update(cx, |this, cx| {
|
|
this.set_signer(keys, cx);
|
|
})?;
|
|
}
|
|
Err(e) => {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(StateEvent::error(e.to_string()));
|
|
})?;
|
|
}
|
|
};
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Set the signer for the nostr client and verify the public key
|
|
pub fn set_signer<T>(&mut self, new: T, cx: &mut Context<Self>)
|
|
where
|
|
T: NostrSigner + 'static,
|
|
{
|
|
let client = self.client();
|
|
let signer = self.signer();
|
|
|
|
// Create a task to update the signer and verify the public key
|
|
let task: Task<Result<PublicKey, Error>> = cx.background_spawn(async move {
|
|
// Update signer and unsubscribe
|
|
signer.switch(new).await;
|
|
client.unsubscribe_all().await?;
|
|
|
|
// Verify and get public key
|
|
let signer = client.signer().context("Signer not found")?;
|
|
let public_key = signer.get_public_key().await?;
|
|
|
|
log::info!("Signer's public key: {}", public_key);
|
|
Ok(public_key)
|
|
});
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
match task.await {
|
|
Ok(public_key) => {
|
|
this.update(cx, |this, cx| {
|
|
// Add public key to npubs if not already present
|
|
this.npubs.update(cx, |this, cx| {
|
|
if !this.contains(&public_key) {
|
|
this.push(public_key);
|
|
cx.notify();
|
|
}
|
|
});
|
|
|
|
// Emit signer changed event
|
|
cx.emit(StateEvent::SignerSet);
|
|
})?;
|
|
}
|
|
Err(e) => {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(StateEvent::error(e.to_string()));
|
|
})?;
|
|
}
|
|
};
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Add a key signer to keyring
|
|
pub fn add_key_signer(&mut self, keys: &Keys, cx: &mut Context<Self>) {
|
|
let keys = keys.clone();
|
|
let write_secret =
|
|
self.write_secret(keys.public_key(), keys.secret_key().to_secret_hex(), cx);
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
match write_secret.await {
|
|
Ok(_) => {
|
|
this.update(cx, |this, cx| {
|
|
this.set_signer(keys, cx);
|
|
})?;
|
|
}
|
|
Err(e) => {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(StateEvent::error(e.to_string()));
|
|
})?;
|
|
}
|
|
};
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Add a nostr connect signer to keyring
|
|
pub fn add_nip46_signer(&mut self, nip46: &NostrConnect, cx: &mut Context<Self>) {
|
|
let nip46 = nip46.clone();
|
|
let async_nip46 = nip46.clone();
|
|
|
|
// Connect and verify the remote signer
|
|
let task: Task<Result<(PublicKey, NostrConnectUri), Error>> =
|
|
cx.background_spawn(async move {
|
|
let uri = async_nip46.bunker_uri().await?;
|
|
let public_key = async_nip46.get_public_key().await?;
|
|
|
|
Ok((public_key, uri))
|
|
});
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
match task.await {
|
|
Ok((public_key, uri)) => {
|
|
// Create the write secret task
|
|
let write_secret = this.read_with(cx, |this, cx| {
|
|
this.write_secret(public_key, uri.to_string(), cx)
|
|
})?;
|
|
|
|
match write_secret.await {
|
|
Ok(_) => {
|
|
this.update(cx, |this, cx| {
|
|
this.set_signer(nip46, cx);
|
|
})?;
|
|
}
|
|
Err(e) => {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(StateEvent::error(e.to_string()));
|
|
})?;
|
|
}
|
|
}
|
|
}
|
|
Err(e) => {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(StateEvent::error(e.to_string()));
|
|
})?;
|
|
}
|
|
};
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Get the public key of a NIP-05 address
|
|
pub fn get_address(&self, addr: Nip05Address, cx: &App) -> Task<Result<PublicKey, Error>> {
|
|
let client = self.client();
|
|
let http_client = cx.http_client();
|
|
|
|
cx.background_spawn(async move {
|
|
let profile = addr.profile(&http_client).await?;
|
|
let public_key = profile.public_key;
|
|
|
|
let opts = SubscribeAutoCloseOptions::default()
|
|
.exit_policy(ReqExitPolicy::ExitOnEOSE)
|
|
.timeout(Some(Duration::from_secs(3)));
|
|
|
|
// Construct the filter for the metadata event
|
|
let filter = Filter::new()
|
|
.kind(Kind::Metadata)
|
|
.author(public_key)
|
|
.limit(1);
|
|
|
|
// Construct target for subscription
|
|
let target: HashMap<&str, Vec<Filter>> = BOOTSTRAP_RELAYS
|
|
.into_iter()
|
|
.map(|relay| (relay, vec![filter.clone()]))
|
|
.collect();
|
|
|
|
client.subscribe(target).close_on(opts).await?;
|
|
|
|
Ok(public_key)
|
|
})
|
|
}
|
|
|
|
/// Perform a NIP-50 global search for user profiles based on a given query
|
|
pub fn search(&self, query: &str, cx: &App) -> Task<Result<Vec<PublicKey>, Error>> {
|
|
let client = self.client();
|
|
let query = query.to_string();
|
|
|
|
// Get the address task if the query is a valid NIP-05 address
|
|
let address_task = if let Ok(addr) = Nip05Address::parse(&query) {
|
|
Some(self.get_address(addr, cx))
|
|
} else {
|
|
None
|
|
};
|
|
|
|
cx.background_spawn(async move {
|
|
let mut results: Vec<PublicKey> = Vec::with_capacity(FIND_LIMIT);
|
|
|
|
// Return early if the query is a valid NIP-05 address
|
|
if let Some(task) = address_task
|
|
&& let Ok(public_key) = task.await
|
|
{
|
|
results.push(public_key);
|
|
return Ok(results);
|
|
}
|
|
|
|
// Return early if the query is a valid public key
|
|
if let Ok(public_key) = PublicKey::parse(&query) {
|
|
results.push(public_key);
|
|
return Ok(results);
|
|
}
|
|
|
|
// Construct the filter for the search query
|
|
let filter = Filter::new()
|
|
.search(query.to_lowercase())
|
|
.kind(Kind::Metadata)
|
|
.limit(FIND_LIMIT);
|
|
|
|
// Construct target for subscription
|
|
let target: HashMap<&str, Vec<Filter>> = SEARCH_RELAYS
|
|
.into_iter()
|
|
.map(|relay| (relay, vec![filter.clone()]))
|
|
.collect();
|
|
|
|
// Stream events from the search relays
|
|
let mut stream = client
|
|
.stream_events(target)
|
|
.timeout(Duration::from_secs(TIMEOUT))
|
|
.await?;
|
|
|
|
// Collect the results
|
|
while let Some((_url, res)) = stream.next().await {
|
|
if let Ok(event) = res {
|
|
results.push(event.pubkey);
|
|
}
|
|
}
|
|
|
|
if results.is_empty() {
|
|
return Err(anyhow!("No results for query {query}"));
|
|
}
|
|
|
|
Ok(results)
|
|
})
|
|
}
|
|
|
|
/// Perform a WoT (via Vertex) search for a given query.
|
|
pub fn wot_search(&self, query: &str, cx: &App) -> Task<Result<Vec<PublicKey>, Error>> {
|
|
let client = self.client();
|
|
let query = query.to_string();
|
|
|
|
cx.background_spawn(async move {
|
|
// Construct a vertex request event
|
|
let builder = EventBuilder::new(Kind::Custom(5315), "").tags(vec![
|
|
Tag::custom(TagKind::custom("param"), vec!["search", &query]),
|
|
Tag::custom(TagKind::custom("param"), vec!["limit", "10"]),
|
|
]);
|
|
let event = client.sign_event_builder(builder).await?;
|
|
|
|
// Send the event to vertex relays
|
|
let output = client.send_event(&event).to(WOT_RELAYS).await?;
|
|
|
|
// Construct a filter to get the response or error from vertex
|
|
let filter = Filter::new()
|
|
.kinds(vec![Kind::Custom(6315), Kind::Custom(7000)])
|
|
.event(output.id().to_owned());
|
|
|
|
// Construct target for subscription
|
|
let target: HashMap<&str, Vec<Filter>> = WOT_RELAYS
|
|
.into_iter()
|
|
.map(|relay| (relay, vec![filter.clone()]))
|
|
.collect();
|
|
|
|
// Stream events from the wot relays
|
|
let mut stream = client
|
|
.stream_events(target)
|
|
.timeout(Duration::from_secs(TIMEOUT))
|
|
.await?;
|
|
|
|
while let Some((_url, res)) = stream.next().await {
|
|
if let Ok(event) = res {
|
|
match event.kind {
|
|
Kind::Custom(6315) => {
|
|
let content: serde_json::Value = serde_json::from_str(&event.content)?;
|
|
let pubkeys: Vec<PublicKey> = content
|
|
.as_array()
|
|
.into_iter()
|
|
.flatten()
|
|
.filter_map(|item| item.as_object())
|
|
.filter_map(|obj| obj.get("pubkey").and_then(|v| v.as_str()))
|
|
.filter_map(|pubkey_str| PublicKey::parse(pubkey_str).ok())
|
|
.collect();
|
|
|
|
return Ok(pubkeys);
|
|
}
|
|
Kind::Custom(7000) => {
|
|
return Err(anyhow!("Search error"));
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
}
|
|
|
|
Err(anyhow!("No results for query: {query}"))
|
|
})
|
|
}
|
|
}
|
|
|
|
/// Get or create new app keys
|
|
fn get_or_init_app_keys(cx: &App) -> Result<Keys, Error> {
|
|
let read = cx.read_credentials(CLIENT_NAME);
|
|
let stored_keys: Option<Keys> = cx.foreground_executor().block_on(async move {
|
|
if let Ok(Some((_, secret))) = read.await {
|
|
SecretKey::from_slice(&secret).map(Keys::new).ok()
|
|
} else {
|
|
None
|
|
}
|
|
});
|
|
|
|
if let Some(keys) = stored_keys {
|
|
Ok(keys)
|
|
} else {
|
|
let keys = Keys::generate();
|
|
let user = keys.public_key().to_hex();
|
|
let secret = keys.secret_key().to_secret_bytes();
|
|
let write = cx.write_credentials(CLIENT_NAME, &user, &secret);
|
|
|
|
cx.foreground_executor().block_on(async move {
|
|
if let Err(e) = write.await {
|
|
log::error!("Keyring not available or panic: {e}")
|
|
}
|
|
});
|
|
|
|
Ok(keys)
|
|
}
|
|
}
|
|
|
|
fn default_relay_list() -> Vec<(RelayUrl, Option<RelayMetadata>)> {
|
|
vec![
|
|
(
|
|
RelayUrl::parse("wss://relay.nostr.net").unwrap(),
|
|
Some(RelayMetadata::Write),
|
|
),
|
|
(
|
|
RelayUrl::parse("wss://relay.primal.net").unwrap(),
|
|
Some(RelayMetadata::Write),
|
|
),
|
|
(
|
|
RelayUrl::parse("wss://relay.damus.io").unwrap(),
|
|
Some(RelayMetadata::Read),
|
|
),
|
|
(
|
|
RelayUrl::parse("wss://nos.lol").unwrap(),
|
|
Some(RelayMetadata::Read),
|
|
),
|
|
(
|
|
RelayUrl::parse("wss://nostr.superfriends.online").unwrap(),
|
|
None,
|
|
),
|
|
]
|
|
}
|
|
|
|
fn default_messaging_relays() -> Vec<RelayUrl> {
|
|
vec![
|
|
RelayUrl::parse("wss://nos.lol").unwrap(),
|
|
RelayUrl::parse("wss://nip17.com").unwrap(),
|
|
RelayUrl::parse("wss://auth.nostr1.com").unwrap(),
|
|
]
|
|
}
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub struct CoopAuthUrlHandler;
|
|
|
|
impl AuthUrlHandler for CoopAuthUrlHandler {
|
|
#[allow(mismatched_lifetime_syntaxes)]
|
|
fn on_auth_url(&self, auth_url: Url) -> BoxedFuture<Result<()>> {
|
|
Box::pin(async move {
|
|
webbrowser::open(auth_url.as_str())?;
|
|
Ok(())
|
|
})
|
|
}
|
|
}
|