505 lines
16 KiB
Rust
505 lines
16 KiB
Rust
use std::time::Duration;
|
|
|
|
use anyhow::{Error, anyhow};
|
|
use gpui::{App, AppContext, Context, Entity, EventEmitter, Global, Task};
|
|
use nostr_connect::prelude::*;
|
|
use nostr_sdk::prelude::*;
|
|
use signed_core::filters;
|
|
use signed_nostr::{NostrBackend, SignedAuthUrlHandler, UniversalSigner, Update};
|
|
|
|
/// Keyring entry holding the user credential (`nsec1...` or `bunker://...`).
|
|
pub const USER_KEYRING: &str = "su.reya.signed#user";
|
|
/// Keyring entry holding the locally generated key for NIP-46 sessions.
|
|
pub const MASTER_KEYRING: &str = "su.reya.signed#master";
|
|
/// Timeout for NIP-46 signer responses.
|
|
pub const NOSTR_CONNECT_TIMEOUT: u64 = 60;
|
|
|
|
/// Relays connected at startup, before any user-specific relay config is known.
|
|
pub const BOOTSTRAP_RELAYS: [&str; 4] = [
|
|
"wss://relay.primal.net",
|
|
"wss://relay.ditto.pub",
|
|
"wss://index.ngit.dev",
|
|
"wss://profiles.nostr1.com",
|
|
];
|
|
|
|
/// Relays used for indexing user's relay list (NIP-65).
|
|
pub const INDEXER_RELAYS: [&str; 3] = [
|
|
"wss://indexer.coracle.social",
|
|
"wss://purplepag.es",
|
|
"wss://user.kindpag.es",
|
|
];
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum BackendEvent {
|
|
/// User has no signer configured.
|
|
SignerRequired,
|
|
/// The signer has changed (login/logout/account switch).
|
|
SignerChanged,
|
|
/// Relay bootstrap finished.
|
|
Connected,
|
|
/// A new event was received from a relay and stored in the database.
|
|
NostrUpdate(Update),
|
|
/// An event built locally was signed, broadcast and stored.
|
|
Published(Box<Event>),
|
|
/// An error occurred.
|
|
Error(String),
|
|
}
|
|
|
|
impl BackendEvent {
|
|
pub fn error<T>(error: T) -> Self
|
|
where
|
|
T: Into<String>,
|
|
{
|
|
Self::Error(error.into())
|
|
}
|
|
}
|
|
|
|
/// Global backend entity: owns the nostr client, the signer and the
|
|
/// notification pump. Stores subscribe to [`BackendEvent`] and re-query the
|
|
/// local database when relevant updates arrive.
|
|
pub struct Backend {
|
|
inner: NostrBackend,
|
|
current_user: Option<PublicKey>,
|
|
tasks: Vec<Task<Result<(), Error>>>,
|
|
}
|
|
|
|
struct GlobalBackend(Entity<Backend>);
|
|
|
|
impl Global for GlobalBackend {}
|
|
|
|
impl EventEmitter<BackendEvent> for Backend {}
|
|
|
|
impl Backend {
|
|
/// Retrieve the global backend.
|
|
pub fn global(cx: &App) -> Entity<Self> {
|
|
cx.global::<GlobalBackend>().0.clone()
|
|
}
|
|
|
|
pub(crate) fn set_global(entity: Entity<Self>, cx: &mut App) {
|
|
cx.set_global(GlobalBackend(entity));
|
|
}
|
|
|
|
pub(crate) fn new(inner: NostrBackend, cx: &mut Context<Self>) -> Self {
|
|
let client = inner.client();
|
|
|
|
let pump = cx.spawn(async move |this, cx| {
|
|
let mut notifications = client.notifications();
|
|
|
|
while let Some(notification) = notifications.next().await {
|
|
let ClientNotification::Event { event, .. } = notification else {
|
|
continue;
|
|
};
|
|
|
|
let update = Update::from_event(&event);
|
|
|
|
if this
|
|
.update(cx, |_, cx| cx.emit(BackendEvent::NostrUpdate(update)))
|
|
.is_err()
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
});
|
|
|
|
let mut this = Self {
|
|
inner,
|
|
current_user: None,
|
|
tasks: vec![pump],
|
|
};
|
|
|
|
this.bootstrap(cx);
|
|
this
|
|
}
|
|
|
|
/// Bootstrap the client: connect to the default relays (indexers as
|
|
/// discovery-only) and restore the saved session, if any.
|
|
fn bootstrap(&mut self, cx: &mut Context<Self>) {
|
|
let backend = self.inner.clone();
|
|
|
|
let task = cx.background_spawn(async move {
|
|
for url in BOOTSTRAP_RELAYS {
|
|
backend.add_relay(url).await?;
|
|
}
|
|
for url in INDEXER_RELAYS {
|
|
backend.add_discovery_relay(url).await?;
|
|
}
|
|
backend.connect().await;
|
|
Ok::<(), Error>(())
|
|
});
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
match task.await {
|
|
Ok(()) => {
|
|
this.update(cx, |_this, cx| cx.emit(BackendEvent::Connected))?;
|
|
}
|
|
Err(e) => {
|
|
this.update(cx, |_this, cx| cx.emit(BackendEvent::error(e.to_string())))?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}));
|
|
|
|
self.restore_session(cx);
|
|
}
|
|
|
|
/// Restore the saved session from the keyring. Emits
|
|
/// [`BackendEvent::SignerRequired`] if no credential is stored.
|
|
pub fn restore_session(&mut self, cx: &mut Context<Self>) {
|
|
if cfg!(target_arch = "wasm32") {
|
|
cx.emit(BackendEvent::SignerRequired);
|
|
return;
|
|
}
|
|
|
|
let user = cx.read_credentials(USER_KEYRING);
|
|
let master = self.master_key(cx);
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
let content = match user.await {
|
|
Ok(Some((_username, secret))) => String::from_utf8(secret)?,
|
|
_ => {
|
|
this.update(cx, |_, cx| cx.emit(BackendEvent::SignerRequired))?;
|
|
return Ok(());
|
|
}
|
|
};
|
|
|
|
let result = async {
|
|
if content.starts_with("nsec1") {
|
|
let keys = Keys::new(SecretKey::parse(&content)?);
|
|
this.update(cx, |this, cx| this.set_signer(keys, cx))?;
|
|
} else if content.starts_with("bunker://") {
|
|
let uri = NostrConnectUri::parse(&content)?;
|
|
let mut signer = NostrConnect::new(
|
|
uri,
|
|
master.await,
|
|
Duration::from_secs(NOSTR_CONNECT_TIMEOUT),
|
|
None,
|
|
)?;
|
|
signer.auth_url_handler(SignedAuthUrlHandler);
|
|
this.update(cx, |this, cx| this.set_signer(signer, cx))?;
|
|
} else {
|
|
this.update(cx, |_, cx| cx.emit(BackendEvent::SignerRequired))?;
|
|
}
|
|
|
|
Ok::<_, Error>(())
|
|
}
|
|
.await;
|
|
|
|
if let Err(e) = result {
|
|
this.update(cx, |_, cx| {
|
|
cx.emit(BackendEvent::error(e.to_string()));
|
|
cx.emit(BackendEvent::SignerRequired);
|
|
})?;
|
|
}
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Login with an `nsec1...` secret key. The credential is verified by
|
|
/// the signer flow and persisted in the keyring.
|
|
pub fn login_with_nsec(&mut self, nsec: &str, cx: &mut Context<Self>) {
|
|
let nsec = nsec.trim().to_owned();
|
|
|
|
let keys = match SecretKey::parse(&nsec) {
|
|
Ok(secret) => Keys::new(secret),
|
|
Err(e) => {
|
|
cx.emit(BackendEvent::error(e.to_string()));
|
|
return;
|
|
}
|
|
};
|
|
|
|
let write =
|
|
cx.write_credentials(USER_KEYRING, &keys.public_key().to_hex(), nsec.as_bytes());
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
if let Err(e) = write.await {
|
|
this.update(cx, |_, cx| cx.emit(BackendEvent::error(e.to_string())))?;
|
|
return Ok(());
|
|
}
|
|
|
|
this.update(cx, |this, cx| this.set_signer(keys, cx))?;
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Login with a `bunker://...` URI (NIP-46). The auth URL, if any, is
|
|
/// opened in the default browser. The credential is persisted in the
|
|
/// keyring after the signer proves reachable.
|
|
pub fn login_with_bunker(&mut self, uri: &str, cx: &mut Context<Self>) {
|
|
let uri_string = uri.trim().to_owned();
|
|
|
|
let connect_uri = match NostrConnectUri::parse(&uri_string) {
|
|
Ok(uri) => uri,
|
|
Err(e) => {
|
|
cx.emit(BackendEvent::error(e.to_string()));
|
|
return;
|
|
}
|
|
};
|
|
|
|
let master = self.master_key(cx);
|
|
let write = cx.write_credentials(USER_KEYRING, "bunker", uri_string.as_bytes());
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
let result = async {
|
|
let mut signer = NostrConnect::new(
|
|
connect_uri,
|
|
master.await,
|
|
Duration::from_secs(NOSTR_CONNECT_TIMEOUT),
|
|
None,
|
|
)?;
|
|
signer.auth_url_handler(SignedAuthUrlHandler);
|
|
|
|
// Verify the signer before persisting the credential.
|
|
signer.get_public_key_async().await?;
|
|
write.await?;
|
|
|
|
this.update(cx, |this, cx| this.set_signer(signer, cx))?;
|
|
|
|
Ok::<_, Error>(())
|
|
}
|
|
.await;
|
|
|
|
if let Err(e) = result {
|
|
this.update(cx, |_, cx| cx.emit(BackendEvent::error(e.to_string())))?;
|
|
}
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Remove the saved credential and reset to an anonymous session.
|
|
pub fn logout(&mut self, cx: &mut Context<Self>) {
|
|
let delete = cx.delete_credentials(USER_KEYRING);
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
delete.await.ok();
|
|
|
|
this.update(cx, |this, cx| {
|
|
this.inner.signer().swap_inner(Keys::generate());
|
|
this.current_user = None;
|
|
cx.emit(BackendEvent::SignerChanged);
|
|
cx.emit(BackendEvent::SignerRequired);
|
|
cx.notify();
|
|
})?;
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Get (or generate and persist) the key used for NIP-46 sessions.
|
|
fn master_key(&self, cx: &App) -> Task<Keys> {
|
|
let task = cx.read_credentials(MASTER_KEYRING);
|
|
|
|
cx.spawn(async move |cx| {
|
|
let (keys, new_key) = match task.await {
|
|
Ok(Some((_user, secret))) => match SecretKey::from_slice(&secret) {
|
|
Ok(secret_key) => (Keys::new(secret_key), false),
|
|
_ => (Keys::generate(), true),
|
|
},
|
|
_ => (Keys::generate(), true),
|
|
};
|
|
|
|
if new_key {
|
|
let username = keys.public_key().to_hex();
|
|
let password = keys.secret_key().to_secret_bytes();
|
|
|
|
cx.update(|cx| {
|
|
let task = cx.write_credentials(MASTER_KEYRING, &username, &password);
|
|
cx.background_spawn(async move { task.await.ok() }).detach();
|
|
});
|
|
}
|
|
|
|
keys
|
|
})
|
|
}
|
|
|
|
/// Fetch the user's grasp list (kind `10317`) and add the listed grasp
|
|
/// servers as relays.
|
|
fn bootstrap_user(&mut self, public_key: PublicKey, cx: &mut Context<Self>) {
|
|
let backend = self.inner.clone();
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
let result = async {
|
|
let events = backend
|
|
.client()
|
|
.fetch_events(filters::grasp_list(public_key))
|
|
.await?;
|
|
|
|
let urls: Vec<String> = events
|
|
.into_iter()
|
|
.max_by_key(|e| e.created_at)
|
|
.map(|e| {
|
|
e.tags
|
|
.iter()
|
|
.filter(|t| t.kind() == "g")
|
|
.filter_map(|t| t.content().map(str::to_owned))
|
|
.collect()
|
|
})
|
|
.unwrap_or_default();
|
|
|
|
for url in urls {
|
|
backend.add_relay(&url).await.ok();
|
|
}
|
|
backend.connect().await;
|
|
|
|
Ok::<_, Error>(())
|
|
}
|
|
.await;
|
|
|
|
if let Err(e) = result {
|
|
this.update(cx, |_, cx| cx.emit(BackendEvent::error(e.to_string())))?;
|
|
}
|
|
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Get the nostr client.
|
|
pub fn client(&self) -> Client {
|
|
self.inner.client()
|
|
}
|
|
|
|
/// Get the current signer.
|
|
pub fn signer(&self) -> UniversalSigner {
|
|
self.inner.signer()
|
|
}
|
|
|
|
/// Get the current user's public key.
|
|
pub fn current_user(&self) -> Option<PublicKey> {
|
|
self.current_user
|
|
}
|
|
|
|
/// Update the signer (any type implementing the async signer traits,
|
|
/// e.g. `Keys`, `NostrConnect`, a browser extension proxy).
|
|
pub fn set_signer<T>(&mut self, new_signer: T, cx: &mut Context<Self>)
|
|
where
|
|
T: AsyncGetPublicKey + AsyncSignEvent + AsyncNip44 + 'static,
|
|
<T as AsyncGetPublicKey>::Error: std::error::Error + Send + Sync + 'static,
|
|
<T as AsyncSignEvent>::Error: std::error::Error + Send + Sync + 'static,
|
|
<T as AsyncNip44>::Error: std::error::Error + Send + Sync + 'static,
|
|
{
|
|
let task = cx.spawn(async move |this, cx| {
|
|
match new_signer.get_public_key_async().await {
|
|
Ok(public_key) => {
|
|
this.update(cx, |this, cx| {
|
|
this.inner.signer().swap_inner(new_signer);
|
|
this.current_user = Some(public_key);
|
|
this.bootstrap_user(public_key, cx);
|
|
cx.emit(BackendEvent::SignerChanged);
|
|
cx.notify();
|
|
})?;
|
|
}
|
|
Err(e) => {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(BackendEvent::error(e.to_string()));
|
|
})?;
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
});
|
|
self.tasks.push(task);
|
|
}
|
|
|
|
/// Add relays and connect to them.
|
|
pub fn add_relays(&mut self, urls: Vec<String>, cx: &mut Context<Self>) {
|
|
let backend = self.inner.clone();
|
|
|
|
let task = cx.background_spawn(async move {
|
|
for url in urls {
|
|
backend.add_relay(&url).await?;
|
|
}
|
|
backend.connect().await;
|
|
Ok::<(), Error>(())
|
|
});
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
match task.await {
|
|
Ok(()) => {
|
|
this.update(cx, |_this, cx| cx.emit(BackendEvent::Connected))?;
|
|
}
|
|
Err(e) => {
|
|
this.update(cx, |_this, cx| cx.emit(BackendEvent::error(e.to_string())))?;
|
|
}
|
|
}
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Add relays used only for discovery (e.g. NIP-65 indexers) and
|
|
/// connect to them. No subscriptions or writes are routed through them.
|
|
pub fn add_discovery_relays(&mut self, urls: Vec<String>, cx: &mut Context<Self>) {
|
|
let backend = self.inner.clone();
|
|
|
|
let task = cx.background_spawn(async move {
|
|
for url in urls {
|
|
backend.add_discovery_relay(&url).await?;
|
|
}
|
|
backend.connect().await;
|
|
Ok::<(), Error>(())
|
|
});
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
if let Err(e) = task.await {
|
|
this.update(cx, |_this, cx| cx.emit(BackendEvent::error(e.to_string())))?;
|
|
}
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Start a persistent subscription. Matching events are stored in the
|
|
/// database automatically and surface as [`BackendEvent::NostrUpdate`].
|
|
pub fn subscribe(&mut self, filter: Filter, cx: &mut Context<Self>) {
|
|
let backend = self.inner.clone();
|
|
|
|
let task = cx.background_spawn(async move { backend.subscribe(filter).await.map(|_| ()) });
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
if let Err(e) = task.await {
|
|
this.update(cx, |_this, cx| cx.emit(BackendEvent::error(e.to_string())))?;
|
|
}
|
|
Ok(())
|
|
}));
|
|
}
|
|
|
|
/// Sign, broadcast and locally store an event. Emits
|
|
/// [`BackendEvent::Published`] on success so stores can refresh.
|
|
///
|
|
/// The returned receiver yields the outcome of this specific action,
|
|
/// so callers can show inline progress/errors instead of relying on
|
|
/// the global [`BackendEvent::Error`].
|
|
pub fn send(
|
|
&mut self,
|
|
builder: EventBuilder,
|
|
cx: &mut Context<Self>,
|
|
) -> flume::Receiver<Result<Event, Error>> {
|
|
let (tx, rx) = flume::bounded(1);
|
|
|
|
let backend = self.inner.clone();
|
|
let task = cx.background_spawn(async move { backend.send(builder).await });
|
|
|
|
self.tasks.push(cx.spawn(async move |this, cx| {
|
|
let result = task.await;
|
|
|
|
match &result {
|
|
Ok(event) => {
|
|
this.update(cx, |_this, cx| {
|
|
cx.emit(BackendEvent::Published(Box::new(event.clone())));
|
|
})?;
|
|
}
|
|
Err(e) => {
|
|
this.update(cx, |_this, cx| cx.emit(BackendEvent::error(e.to_string())))?;
|
|
}
|
|
}
|
|
|
|
tx.send_async(result)
|
|
.await
|
|
.map_err(|_| anyhow!("action result receiver dropped"))
|
|
}));
|
|
|
|
rx
|
|
}
|
|
}
|