1214 lines
43 KiB
Rust
1214 lines
43 KiB
Rust
use std::borrow::Cow;
|
|
use std::collections::hash_map::DefaultHasher;
|
|
use std::collections::{HashMap, HashSet};
|
|
use std::hash::{Hash, Hasher};
|
|
use std::sync::atomic::{AtomicBool, Ordering};
|
|
use std::time::Duration;
|
|
|
|
use anyhow::{anyhow, Context, Error};
|
|
use nostr_gossip_memory::prelude::*;
|
|
use nostr_lmdb::NostrLMDB;
|
|
use nostr_sdk::prelude::*;
|
|
use smol::lock::RwLock;
|
|
|
|
use crate::constants::{
|
|
BOOTSTRAP_RELAYS, METADATA_BATCH_LIMIT, METADATA_BATCH_TIMEOUT, QUERY_TIMEOUT, SEARCH_RELAYS,
|
|
};
|
|
use crate::paths::config_dir;
|
|
use crate::state::ingester::Ingester;
|
|
use crate::state::tracker::EventTracker;
|
|
use crate::{app_name, INBOX_SUB_ID};
|
|
|
|
mod device;
|
|
mod ingester;
|
|
mod signal;
|
|
mod tracker;
|
|
|
|
pub use device::*;
|
|
pub use signal::*;
|
|
|
|
#[derive(Debug)]
|
|
pub struct AppState {
|
|
/// A client to interact with Nostr
|
|
client: Client,
|
|
|
|
/// Signal channel for communication between Nostr and GPUI
|
|
signal: Signal,
|
|
|
|
/// Ingester channel for processing public keys
|
|
ingester: Ingester,
|
|
|
|
/// Tracks activity related to Nostr events
|
|
event_tracker: RwLock<EventTracker>,
|
|
|
|
/// Cache of messaging relays for each public key
|
|
pub relay_cache: RwLock<HashMap<PublicKey, HashSet<RelayUrl>>>,
|
|
|
|
/// Cache of device announcement for each public key
|
|
pub announcement_cache: RwLock<HashMap<PublicKey, Option<Announcement>>>,
|
|
|
|
/// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
|
|
pub device: RwLock<Device>,
|
|
|
|
/// The timestamp when the application was initialized.
|
|
pub initialized_at: Timestamp,
|
|
|
|
/// Whether gift wrap processing is in progress.
|
|
pub gift_wrap_processing: AtomicBool,
|
|
}
|
|
|
|
impl Default for AppState {
|
|
fn default() -> Self {
|
|
Self::new()
|
|
}
|
|
}
|
|
|
|
impl AppState {
|
|
pub fn new() -> Self {
|
|
// 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();
|
|
|
|
let path = config_dir().join("nostr");
|
|
let lmdb = NostrLMDB::open(path).expect("Failed to initialize database");
|
|
let gossip = NostrGossipMemory::unbounded();
|
|
|
|
// Nostr client options
|
|
let opts = ClientOptions::new()
|
|
.automatic_authentication(false)
|
|
.verify_subscriptions(false)
|
|
.sleep_when_idle(SleepWhenIdle::Enabled {
|
|
timeout: Duration::from_secs(600),
|
|
});
|
|
|
|
// Construct the nostr client
|
|
let client = ClientBuilder::default()
|
|
.gossip(gossip)
|
|
.database(lmdb)
|
|
.opts(opts)
|
|
.build();
|
|
|
|
let device = RwLock::new(Device::default());
|
|
let event_tracker = RwLock::new(EventTracker::default());
|
|
let relay_cache = RwLock::new(HashMap::default());
|
|
let announcement_cache = RwLock::new(HashMap::default());
|
|
|
|
let signal = Signal::default();
|
|
let ingester = Ingester::default();
|
|
|
|
Self {
|
|
client,
|
|
device,
|
|
event_tracker,
|
|
relay_cache,
|
|
announcement_cache,
|
|
signal,
|
|
ingester,
|
|
initialized_at: Timestamp::now(),
|
|
gift_wrap_processing: AtomicBool::new(false),
|
|
}
|
|
}
|
|
|
|
/// Returns a reference to the nostr client
|
|
pub fn client(&'static self) -> &'static Client {
|
|
&self.client
|
|
}
|
|
|
|
/// Returns a reference to the device
|
|
pub fn device(&'static self) -> &'static RwLock<Device> {
|
|
&self.device
|
|
}
|
|
|
|
/// Returns a reference to the event tracker
|
|
pub fn tracker(&'static self) -> &'static RwLock<EventTracker> {
|
|
&self.event_tracker
|
|
}
|
|
|
|
/// Returns a reference to the signal channel
|
|
pub fn signal(&'static self) -> &'static Signal {
|
|
&self.signal
|
|
}
|
|
|
|
/// Returns a reference to the ingester channel
|
|
pub fn ingester(&'static self) -> &'static Ingester {
|
|
&self.ingester
|
|
}
|
|
|
|
/// Observes the signer and notifies the app when it's set
|
|
pub async fn observe_signer(&'static self) {
|
|
let client = self.client();
|
|
let loop_duration = Duration::from_millis(800);
|
|
|
|
loop {
|
|
if let Ok(signer) = client.signer().await {
|
|
if let Ok(public_key) = signer.get_public_key().await {
|
|
// Notify the app that the signer has been set
|
|
self.signal().send(SignalKind::SignerSet(public_key)).await;
|
|
|
|
// Get user's gossip relays
|
|
self.get_nip65(public_key).await.ok();
|
|
|
|
// Initialize the relay and announcement caches
|
|
self.init_cache().await.ok();
|
|
|
|
// Initialize client key
|
|
self.init_client_key().await.ok();
|
|
|
|
// Exit the loop
|
|
break;
|
|
}
|
|
}
|
|
|
|
smol::Timer::after(loop_duration).await;
|
|
}
|
|
}
|
|
|
|
/// Observes the gift wrap status and notifies the app when it's set
|
|
pub async fn observe_giftwrap(&'static self) {
|
|
let client = self.client();
|
|
let loop_duration = Duration::from_secs(20);
|
|
let mut is_start_processing = false;
|
|
let mut total_loops = 0;
|
|
|
|
loop {
|
|
if client.has_signer().await {
|
|
total_loops += 1;
|
|
|
|
if self.gift_wrap_processing.load(Ordering::Acquire) {
|
|
is_start_processing = true;
|
|
|
|
// Reset gift wrap processing flag
|
|
let _ = self.gift_wrap_processing.compare_exchange(
|
|
true,
|
|
false,
|
|
Ordering::Release,
|
|
Ordering::Relaxed,
|
|
);
|
|
|
|
let signal = SignalKind::GiftWrapStatus(UnwrappingStatus::Processing);
|
|
self.signal().send(signal).await;
|
|
} else {
|
|
// Only run further if we are already processing
|
|
// Wait until after 2 loops to prevent exiting early while events are still being processed
|
|
if is_start_processing && total_loops >= 2 {
|
|
let signal = SignalKind::GiftWrapStatus(UnwrappingStatus::Complete);
|
|
self.signal().send(signal).await;
|
|
|
|
// Reset the counter
|
|
is_start_processing = false;
|
|
total_loops = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
smol::Timer::after(loop_duration).await;
|
|
}
|
|
}
|
|
|
|
/// Handles events from the nostr client
|
|
pub async fn handle_notifications(&self) -> Result<(), Error> {
|
|
// Get all bootstrapping relays
|
|
let mut urls = vec![];
|
|
urls.extend(BOOTSTRAP_RELAYS);
|
|
urls.extend(SEARCH_RELAYS);
|
|
|
|
// Add relay to the relay pool
|
|
for url in urls.into_iter() {
|
|
self.client.add_relay(url).await?;
|
|
}
|
|
|
|
// Establish connection to relays
|
|
self.client.connect().await;
|
|
|
|
let mut processed_events: HashSet<EventId> = HashSet::new();
|
|
let mut challenges: HashSet<Cow<'_, str>> = HashSet::new();
|
|
let mut notifications = self.client.notifications();
|
|
|
|
while let Ok(notification) = notifications.recv().await {
|
|
let RelayPoolNotification::Message { message, relay_url } = notification else {
|
|
continue;
|
|
};
|
|
|
|
match message {
|
|
RelayMessage::Event { event, .. } => {
|
|
// Keep track of which relays have seen this event
|
|
{
|
|
let mut event_tracker = self.event_tracker.write().await;
|
|
event_tracker
|
|
.seen_on_relays
|
|
.entry(event.id)
|
|
.or_default()
|
|
.insert(relay_url);
|
|
}
|
|
|
|
// Skip events that have already been processed
|
|
if !processed_events.insert(event.id) {
|
|
continue;
|
|
}
|
|
|
|
match event.kind {
|
|
// Encryption Key announcement event
|
|
Kind::Custom(10044) => {
|
|
if let Ok(announcement) = self.extract_announcement(&event) {
|
|
if self.is_self_authored(&event).await {
|
|
self.signal
|
|
.send(SignalKind::EncryptionSet(announcement.clone()))
|
|
.await;
|
|
}
|
|
|
|
// Cache the announcement for further queries
|
|
let mut announcement_cache = self.announcement_cache.write().await;
|
|
announcement_cache.insert(event.pubkey, Some(announcement));
|
|
}
|
|
}
|
|
// Encryption Key request event
|
|
Kind::Custom(4454) => {
|
|
if self.is_self_authored(&event).await {
|
|
if let Ok(announcement) = self.extract_announcement(&event) {
|
|
self.signal
|
|
.send(SignalKind::EncryptionRequest(announcement))
|
|
.await;
|
|
}
|
|
}
|
|
}
|
|
// Encryption Keys response event
|
|
Kind::Custom(4455) => {
|
|
if self.is_self_authored(&event).await {
|
|
if let Ok(response) = self.extract_response(&event) {
|
|
self.signal
|
|
.send(SignalKind::EncryptionResponse(response))
|
|
.await;
|
|
}
|
|
}
|
|
}
|
|
Kind::RelayList => {
|
|
// Get events if relay list belongs to current user
|
|
if self.is_self_authored(&event).await {
|
|
let author = event.pubkey;
|
|
|
|
// Fetch user's metadata event
|
|
if let Err(e) = self.subscribe(author, Kind::Metadata).await {
|
|
log::error!("Failed to subscribe to metadata event: {e}");
|
|
}
|
|
|
|
// Fetch user's contact list event
|
|
if let Err(e) = self.subscribe(author, Kind::ContactList).await {
|
|
log::error!("Failed to subscribe to contact list event: {e}");
|
|
}
|
|
|
|
// Fetch user's encryption announcement event
|
|
if let Err(e) = self.get_announcement(author).await {
|
|
log::error!("Failed to fetch encryption event: {e}");
|
|
}
|
|
|
|
// Fetch user's messaging relays event
|
|
if let Err(e) = self.get_nip17(author).await {
|
|
log::error!("Failed to fetch messaging relays event: {e}");
|
|
}
|
|
}
|
|
}
|
|
Kind::InboxRelays => {
|
|
// Only get up to 3 relays
|
|
let urls: Vec<RelayUrl> = nip17::extract_relay_list(event.as_ref())
|
|
.take(3)
|
|
.cloned()
|
|
.collect();
|
|
|
|
// Subscribe to gift wrap events if messaging relays belong to the current user
|
|
if self.is_self_authored(&event).await {
|
|
if let Err(e) = self.get_messages(event.pubkey, &urls).await {
|
|
log::error!("Failed to fetch messages: {e}");
|
|
}
|
|
}
|
|
|
|
// Cache the relay list for further queries
|
|
let mut relay_cache = self.relay_cache.write().await;
|
|
relay_cache.entry(event.pubkey).or_default().extend(urls);
|
|
}
|
|
Kind::ContactList => {
|
|
if self.is_self_authored(&event).await {
|
|
let public_keys: HashSet<PublicKey> =
|
|
event.tags.public_keys().copied().collect();
|
|
|
|
if let Err(e) = self.get_metadata_for_list(public_keys).await {
|
|
log::error!("Failed to get metadata for list: {e}");
|
|
}
|
|
}
|
|
}
|
|
Kind::Metadata => {
|
|
let metadata = Metadata::from_json(&event.content).unwrap_or_default();
|
|
let profile = Profile::new(event.pubkey, metadata);
|
|
|
|
self.signal.send(SignalKind::NewProfile(profile)).await;
|
|
}
|
|
Kind::GiftWrap => {
|
|
if let Err(e) = self.extract_rumor(&event).await {
|
|
log::error!("Failed to extract rumor: {e}");
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
RelayMessage::EndOfStoredEvents(subscription_id) => {
|
|
if subscription_id.as_ref() == &SubscriptionId::new(INBOX_SUB_ID) {
|
|
self.signal
|
|
.send(SignalKind::GiftWrapStatus(UnwrappingStatus::Processing))
|
|
.await;
|
|
}
|
|
}
|
|
RelayMessage::Auth { challenge } => {
|
|
if challenges.insert(challenge.clone()) {
|
|
// Send a signal to the ingester to handle the auth request
|
|
self.signal
|
|
.send(SignalKind::Auth(AuthRequest::new(challenge, relay_url)))
|
|
.await;
|
|
}
|
|
}
|
|
RelayMessage::Ok {
|
|
event_id, message, ..
|
|
} => {
|
|
let msg = MachineReadablePrefix::parse(&message);
|
|
let mut tracker = self.event_tracker.write().await;
|
|
|
|
// Keep track of events sent by Coop
|
|
tracker.sent_ids.insert(event_id);
|
|
|
|
// Keep track of events that need to be resend after auth
|
|
if let Some(MachineReadablePrefix::AuthRequired) = msg {
|
|
tracker.resend_queue.insert(event_id, relay_url);
|
|
}
|
|
}
|
|
_ => {}
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Batch metadata requests into a single subscription
|
|
pub async fn handle_metadata_batching(&self) {
|
|
let timeout = Duration::from_millis(METADATA_BATCH_TIMEOUT);
|
|
let mut processed_pubkeys: HashSet<PublicKey> = HashSet::new();
|
|
let mut batch: HashSet<PublicKey> = HashSet::new();
|
|
|
|
/// Internal events for the metadata batching system
|
|
enum BatchEvent {
|
|
PublicKey(PublicKey),
|
|
Timeout,
|
|
Closed,
|
|
}
|
|
|
|
loop {
|
|
let futs = smol::future::or(
|
|
async move {
|
|
if let Ok(public_key) = self.ingester.receiver().recv_async().await {
|
|
BatchEvent::PublicKey(public_key)
|
|
} else {
|
|
BatchEvent::Closed
|
|
}
|
|
},
|
|
async move {
|
|
smol::Timer::after(timeout).await;
|
|
BatchEvent::Timeout
|
|
},
|
|
);
|
|
|
|
match futs.await {
|
|
BatchEvent::PublicKey(public_key) => {
|
|
// Prevent duplicate keys from being processed
|
|
if processed_pubkeys.insert(public_key) {
|
|
batch.insert(public_key);
|
|
}
|
|
|
|
// Process the batch if it's full
|
|
if batch.len() >= METADATA_BATCH_LIMIT {
|
|
self.get_metadata_for_list(std::mem::take(&mut batch))
|
|
.await
|
|
.ok();
|
|
}
|
|
}
|
|
BatchEvent::Timeout => {
|
|
self.get_metadata_for_list(std::mem::take(&mut batch))
|
|
.await
|
|
.ok();
|
|
}
|
|
BatchEvent::Closed => {
|
|
self.get_metadata_for_list(std::mem::take(&mut batch))
|
|
.await
|
|
.ok();
|
|
|
|
// Exit the current loop
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// Encrypt and store a key in the local database.
|
|
pub async fn set_keys(&self, kind: impl Into<String>, value: String) -> Result<(), Error> {
|
|
let signer = self.client.signer().await?;
|
|
let public_key = signer.get_public_key().await?;
|
|
|
|
// Encrypt the value
|
|
let content = signer.nip44_encrypt(&public_key, value.as_ref()).await?;
|
|
|
|
// Construct the application data event
|
|
let event = EventBuilder::new(Kind::ApplicationSpecificData, content)
|
|
.tag(Tag::identifier(format!("coop:{}", kind.into())))
|
|
.build(public_key)
|
|
.sign(&Keys::generate())
|
|
.await?;
|
|
|
|
// Save the event to the database
|
|
self.client.database().save_event(&event).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Get and decrypt a key from the local database.
|
|
pub async fn get_keys(&self, kind: impl Into<String>) -> Result<Keys, Error> {
|
|
let signer = self.client.signer().await?;
|
|
let public_key = signer.get_public_key().await?;
|
|
|
|
let filter = Filter::new()
|
|
.kind(Kind::ApplicationSpecificData)
|
|
.identifier(format!("coop:{}", kind.into()));
|
|
|
|
if let Some(event) = self.client.database().query(filter).await?.first() {
|
|
let content = signer.nip44_decrypt(&public_key, &event.content).await?;
|
|
let secret = SecretKey::parse(&content)?;
|
|
let keys = Keys::new(secret);
|
|
|
|
Ok(keys)
|
|
} else {
|
|
Err(anyhow!("Key not found"))
|
|
}
|
|
}
|
|
|
|
/// Check if event is published by current user
|
|
async fn is_self_authored(&self, event: &Event) -> bool {
|
|
if let Ok(signer) = self.client.signer().await {
|
|
if let Ok(public_key) = signer.get_public_key().await {
|
|
return public_key == event.pubkey;
|
|
}
|
|
}
|
|
false
|
|
}
|
|
|
|
/// Subscribe for events that match the given kind for a given author
|
|
pub async fn subscribe(&self, author: PublicKey, kind: Kind) -> Result<(), Error> {
|
|
let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
|
|
let filter = Filter::new().author(author).kind(kind).limit(1);
|
|
|
|
// Subscribe to filters from the user's write relays
|
|
self.client.subscribe(filter, Some(opts)).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Get metadata for a list of public keys
|
|
pub async fn get_metadata_for_list<I>(&self, public_keys: I) -> Result<(), Error>
|
|
where
|
|
I: IntoIterator<Item = PublicKey>,
|
|
{
|
|
let authors: Vec<PublicKey> = public_keys.into_iter().collect();
|
|
let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
|
|
let kinds = vec![Kind::Metadata, Kind::ContactList, Kind::RelayList];
|
|
|
|
// Return if the list is empty
|
|
if authors.is_empty() {
|
|
return Err(anyhow!("You need at least one public key".to_string(),));
|
|
}
|
|
|
|
let filter = Filter::new()
|
|
.limit(authors.len() * kinds.len() + 10)
|
|
.authors(authors)
|
|
.kinds(kinds);
|
|
|
|
// Subscribe to filters to the bootstrap relays
|
|
self.client
|
|
.subscribe_to(BOOTSTRAP_RELAYS, filter, Some(opts))
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Get and verify NIP-65 relays for a given public key
|
|
pub async fn get_nip65(&self, public_key: PublicKey) -> Result<(), Error> {
|
|
let timeout = Duration::from_secs(QUERY_TIMEOUT);
|
|
let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
|
|
|
|
let filter = Filter::new()
|
|
.kind(Kind::RelayList)
|
|
.author(public_key)
|
|
.limit(1);
|
|
|
|
// Subscribe to events from the bootstrapping relays
|
|
self.client
|
|
.subscribe_to(BOOTSTRAP_RELAYS, filter.clone(), Some(opts))
|
|
.await?;
|
|
|
|
let tx = self.signal.sender().clone();
|
|
let database = self.client.database().clone();
|
|
|
|
// Verify the received data after a timeout
|
|
smol::spawn(async move {
|
|
smol::Timer::after(timeout).await;
|
|
|
|
if database.count(filter).await.unwrap_or(0) < 1 {
|
|
tx.send_async(SignalKind::GossipRelaysNotFound).await.ok();
|
|
}
|
|
})
|
|
.detach();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Set NIP-65 relays for a current user
|
|
pub async fn set_nip65(
|
|
&self,
|
|
relays: &[(RelayUrl, Option<RelayMetadata>)],
|
|
) -> Result<(), Error> {
|
|
let signer = self.client.signer().await?;
|
|
|
|
let tags: Vec<Tag> = relays
|
|
.iter()
|
|
.cloned()
|
|
.map(|(url, metadata)| Tag::relay_metadata(url, metadata))
|
|
.collect();
|
|
|
|
let event = EventBuilder::new(Kind::RelayList, "")
|
|
.tags(tags)
|
|
.sign(&signer)
|
|
.await?;
|
|
|
|
// Send event to the public relays
|
|
self.client.send_event_to(BOOTSTRAP_RELAYS, &event).await?;
|
|
|
|
// Get NIP-17 relays
|
|
self.get_nip17(event.pubkey).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Initialize the relay and announcement caches with events from the local database
|
|
pub async fn init_cache(&self) -> Result<(), Error> {
|
|
let filter = Filter::new().kind(Kind::InboxRelays);
|
|
let events = self.client.database().query(filter).await?;
|
|
let mut relay_cache = self.relay_cache.write().await;
|
|
|
|
for event in events.into_iter() {
|
|
let relays: Vec<RelayUrl> =
|
|
nip17::extract_relay_list(&event).take(3).cloned().collect();
|
|
|
|
// Push all relays to the relay cache
|
|
relay_cache.entry(event.pubkey).or_default().extend(relays);
|
|
}
|
|
|
|
let filter = Filter::new().kind(Kind::Custom(10044));
|
|
let events = self.client.database().query(filter).await?;
|
|
let mut announcement_cache = self.announcement_cache.write().await;
|
|
|
|
for event in events.into_iter() {
|
|
if let Ok(announcement) = self.extract_announcement(&event) {
|
|
announcement_cache.insert(event.pubkey, Some(announcement));
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Initialize the client keys to communicate between clients
|
|
///
|
|
/// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
|
|
pub async fn init_client_key(&self) -> Result<(), Error> {
|
|
// Get the keys from the database or generate new ones
|
|
let keys = self
|
|
.get_keys("client")
|
|
.await
|
|
.unwrap_or_else(|_| Keys::generate());
|
|
|
|
// Initialize the client keys
|
|
let mut device = self.device.write().await;
|
|
device.set_client(keys);
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Get and verify encryption announcement for a given public key
|
|
///
|
|
/// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
|
|
pub async fn get_announcement(&self, public_key: PublicKey) -> Result<(), Error> {
|
|
let timeout = Duration::from_secs(QUERY_TIMEOUT);
|
|
let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
|
|
|
|
let filter = Filter::new()
|
|
.kind(Kind::Custom(10044))
|
|
.author(public_key)
|
|
.limit(1);
|
|
|
|
// Subscribe to events from user's nip65 relays
|
|
self.client.subscribe(filter.clone(), Some(opts)).await?;
|
|
|
|
let tx = self.signal.sender().clone();
|
|
let database = self.client.database().clone();
|
|
|
|
// Verify the received data after a timeout
|
|
smol::spawn(async move {
|
|
smol::Timer::after(timeout).await;
|
|
|
|
if database.count(filter).await.unwrap_or(0) < 1 {
|
|
tx.send_async(SignalKind::EncryptionNotSet).await.ok();
|
|
}
|
|
})
|
|
.detach();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Generate encryption keys and announce them
|
|
///
|
|
/// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
|
|
pub async fn init_encryption_keys(&self) -> Result<(), Error> {
|
|
let signer = self.client.signer().await?;
|
|
let keys = Keys::generate();
|
|
let public_key = keys.public_key();
|
|
let secret = keys.secret_key().to_secret_hex();
|
|
|
|
// Initialize the encryption keys
|
|
let mut device = self.device.write().await;
|
|
device.set_encryption(keys);
|
|
|
|
// Store the encryption keys for future use
|
|
self.set_keys("encryption", secret).await?;
|
|
|
|
// Construct the announcement event
|
|
let event = EventBuilder::new(Kind::Custom(10044), "")
|
|
.tags(vec![
|
|
Tag::client(app_name()),
|
|
Tag::custom(TagKind::custom("n"), vec![public_key]),
|
|
])
|
|
.sign(&signer)
|
|
.await?;
|
|
|
|
// Send the announcement event to the relays
|
|
self.client.send_event(&event).await?;
|
|
|
|
// Resubscribe to gift wrap events that include the encryption public key
|
|
self.get_messages_with_encryption(public_key).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// User has previously set encryption keys, load them from storage
|
|
///
|
|
/// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
|
|
pub async fn load_encryption_keys(&self, announcement: &Announcement) -> Result<(), Error> {
|
|
let keys = self.get_keys("encryption").await?;
|
|
let public_key = announcement.public_key();
|
|
|
|
// Check if the encryption keys match the announcement
|
|
if public_key == keys.public_key() {
|
|
// Update encryption keys
|
|
let mut device = self.device.write().await;
|
|
device.set_encryption(keys);
|
|
|
|
// Resubscribe to gift wrap events that include the encryption public key
|
|
self.get_messages_with_encryption(public_key).await?;
|
|
|
|
Ok(())
|
|
} else {
|
|
Err(anyhow!("Not found"))
|
|
}
|
|
}
|
|
|
|
/// Request encryption keys from other clients
|
|
///
|
|
/// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
|
|
pub async fn request_encryption_keys(&self) -> Result<bool, Error> {
|
|
let mut wait_for_approval = false;
|
|
let device = self.device.read().await;
|
|
|
|
// Client Keys are always known at this point
|
|
let Some(client_key) = device.client.as_ref() else {
|
|
return Err(anyhow!("Client Keys is required"));
|
|
};
|
|
|
|
let signer = self.client.signer().await?;
|
|
let public_key = signer.get_public_key().await?;
|
|
let client_pubkey = client_key.get_public_key().await?;
|
|
|
|
// Get the encryption keys response from the database first
|
|
let filter = Filter::new()
|
|
.kind(Kind::Custom(4455))
|
|
.author(public_key)
|
|
.pubkey(client_pubkey)
|
|
.limit(1);
|
|
|
|
match self.client.database().query(filter).await?.first_owned() {
|
|
// Found encryption keys that shared by other clients
|
|
Some(event) => {
|
|
let root_device = event
|
|
.tags
|
|
.find(TagKind::custom("P"))
|
|
.and_then(|tag| tag.content())
|
|
.and_then(|content| PublicKey::parse(content).ok())
|
|
.context("Invalid event's tags")?;
|
|
|
|
let payload = event.content.as_str();
|
|
let decrypted = client_key.nip44_decrypt(&root_device, payload).await?;
|
|
|
|
let secret = SecretKey::from_hex(&decrypted)?;
|
|
let keys = Keys::new(secret);
|
|
let public_key = keys.public_key();
|
|
|
|
// No longer need to hold the reader for device
|
|
drop(device);
|
|
|
|
// Update encryption keys
|
|
let mut device = self.device.write().await;
|
|
device.set_encryption(keys);
|
|
|
|
// Resubscribe to gift wrap events that include the encryption public key
|
|
self.get_messages_with_encryption(public_key).await?;
|
|
}
|
|
None => {
|
|
// Construct encryption keys request event
|
|
let event = EventBuilder::new(Kind::Custom(4454), "")
|
|
.tags(vec![
|
|
Tag::client(app_name()),
|
|
Tag::custom(TagKind::custom("pubkey"), vec![client_pubkey]),
|
|
])
|
|
.sign(&signer)
|
|
.await?;
|
|
|
|
// Send a request for encryption keys from other devices
|
|
self.client.send_event(&event).await?;
|
|
|
|
// Create a unique ID to control the subscription later
|
|
let subscription_id = SubscriptionId::new("request");
|
|
|
|
let filter = Filter::new()
|
|
.kind(Kind::Custom(4455))
|
|
.author(public_key)
|
|
.pubkey(client_pubkey)
|
|
.since(Timestamp::now());
|
|
|
|
// Subscribe to the approval response event
|
|
self.client
|
|
.subscribe_with_id(subscription_id, filter, None)
|
|
.await?;
|
|
|
|
wait_for_approval = true;
|
|
}
|
|
}
|
|
|
|
Ok(wait_for_approval)
|
|
}
|
|
|
|
/// Receive the encryption keys from other clients
|
|
///
|
|
/// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
|
|
pub async fn receive_encryption_keys(&self, res: Response) -> Result<(), Error> {
|
|
let device = self.device.read().await;
|
|
|
|
// Client Keys are always known at this point
|
|
let Some(client_key) = device.client.as_ref() else {
|
|
return Err(anyhow!("Client Keys is required"));
|
|
};
|
|
|
|
let public_key = res.public_key();
|
|
let payload = res.payload();
|
|
|
|
// Decrypt the payload using the client keys
|
|
let decrypted = client_key.nip44_decrypt(&public_key, payload).await?;
|
|
let secret = SecretKey::parse(&decrypted)?;
|
|
|
|
let keys = Keys::new(secret);
|
|
let public_key = keys.public_key();
|
|
|
|
// No longer need to hold the reader for device
|
|
drop(device);
|
|
|
|
// Update encryption keys
|
|
let mut device = self.device.write().await;
|
|
device.set_encryption(keys);
|
|
|
|
// Resubscribe to gift wrap events that include the encryption public key
|
|
self.get_messages_with_encryption(public_key).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Response the encryption keys request from other clients
|
|
///
|
|
/// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
|
|
pub async fn response_encryption_keys(&self, target: PublicKey) -> Result<(), Error> {
|
|
let device = self.device.read().await;
|
|
|
|
// Client Keys are always known at this point
|
|
let Some(client_key) = device.client.as_ref() else {
|
|
return Err(anyhow!("Client Keys is required"));
|
|
};
|
|
|
|
let encryption = self.get_keys("encryption").await?;
|
|
let client_pubkey = client_key.get_public_key().await?;
|
|
|
|
// Encrypt the encryption keys with the client's signer
|
|
let payload = client_key
|
|
.nip44_encrypt(&target, &encryption.secret_key().to_secret_hex())
|
|
.await?;
|
|
|
|
// Construct the response event
|
|
//
|
|
// P tag: the current client's public key
|
|
// p tag: the requester's public key
|
|
let event = EventBuilder::new(Kind::Custom(4455), payload)
|
|
.tags(vec![
|
|
Tag::custom(TagKind::custom("P"), vec![client_pubkey]),
|
|
Tag::public_key(target),
|
|
])
|
|
.sign(client_key)
|
|
.await?;
|
|
|
|
// Get the current user's signer and public key
|
|
let signer = self.client.signer().await?;
|
|
let public_key = signer.get_public_key().await?;
|
|
|
|
// Get the current user's relay list
|
|
let urls: Vec<RelayUrl> = self
|
|
.client
|
|
.database()
|
|
.relay_list(public_key)
|
|
.await?
|
|
.into_iter()
|
|
.filter_map(|(url, metadata)| {
|
|
if metadata.is_none() || metadata == Some(RelayMetadata::Read) {
|
|
Some(url)
|
|
} else {
|
|
None
|
|
}
|
|
})
|
|
.collect();
|
|
|
|
// Send the response event to the user's relay list
|
|
self.client.send_event_to(urls, &event).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Get and verify NIP-17 relays for a given public key
|
|
pub async fn get_nip17(&self, public_key: PublicKey) -> Result<(), Error> {
|
|
let timeout = Duration::from_secs(QUERY_TIMEOUT);
|
|
let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
|
|
|
|
let filter = Filter::new()
|
|
.kind(Kind::InboxRelays)
|
|
.author(public_key)
|
|
.limit(1);
|
|
|
|
// Subscribe to events from the bootstrapping relays
|
|
self.client.subscribe(filter.clone(), Some(opts)).await?;
|
|
|
|
let tx = self.signal.sender().clone();
|
|
let database = self.client.database().clone();
|
|
|
|
// Verify the received data after a timeout
|
|
smol::spawn(async move {
|
|
smol::Timer::after(timeout).await;
|
|
|
|
if database.count(filter).await.unwrap_or(0) < 1 {
|
|
tx.send_async(SignalKind::MessagingRelaysNotFound)
|
|
.await
|
|
.ok();
|
|
}
|
|
})
|
|
.detach();
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Set NIP-17 relays for a current user
|
|
pub async fn set_nip17(&self, relays: &[RelayUrl]) -> Result<(), Error> {
|
|
let signer = self.client.signer().await?;
|
|
|
|
let event = EventBuilder::new(Kind::InboxRelays, "")
|
|
.tags(relays.iter().cloned().map(Tag::relay))
|
|
.sign(&signer)
|
|
.await?;
|
|
|
|
// Send event to the public relays
|
|
self.client.send_event(&event).await?;
|
|
|
|
// Get all gift wrap events after published event
|
|
self.get_messages(event.pubkey, relays).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Get all gift wrap events in the messaging relays for a given public key
|
|
pub async fn get_messages(
|
|
&self,
|
|
public_key: PublicKey,
|
|
urls: &[RelayUrl],
|
|
) -> Result<(), Error> {
|
|
let id = SubscriptionId::new(INBOX_SUB_ID);
|
|
let filter = Filter::new().kind(Kind::GiftWrap).pubkey(public_key);
|
|
|
|
// Ensure user's have at least one relay
|
|
if urls.is_empty() {
|
|
return Err(anyhow!("Relays are empty"));
|
|
}
|
|
|
|
// Ensure connection to relays
|
|
for url in urls.iter() {
|
|
self.client.add_relay(url).await?;
|
|
self.client.connect_relay(url).await?;
|
|
}
|
|
|
|
// Subscribe to filters to user's messaging relays
|
|
self.client
|
|
.subscribe_with_id_to(urls, id, filter, None)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Resubscribes to gift wrap events that include the encryption public key
|
|
pub async fn get_messages_with_encryption(&self, encryption: PublicKey) -> Result<(), Error> {
|
|
let signer = self.client.signer().await?;
|
|
let public_key = signer.get_public_key().await?;
|
|
let urls = self.messaging_relays(public_key).await;
|
|
|
|
let id = SubscriptionId::new(INBOX_SUB_ID);
|
|
|
|
let filter = Filter::new()
|
|
.kind(Kind::GiftWrap)
|
|
.pubkeys(vec![public_key, encryption]);
|
|
|
|
// Unsubscribe the previous subscription
|
|
self.client.unsubscribe(&id).await;
|
|
|
|
// Subscribe to gift wrap events
|
|
self.client
|
|
.subscribe_with_id_to(&urls, id, filter, None)
|
|
.await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Gets messaging relays for public key
|
|
pub async fn messaging_relays(&self, public_key: PublicKey) -> Vec<RelayUrl> {
|
|
let mut relay_urls = vec![];
|
|
|
|
let filter = Filter::new()
|
|
.kind(Kind::InboxRelays)
|
|
.author(public_key)
|
|
.limit(1);
|
|
|
|
if let Ok(events) = self.client.database().query(filter).await {
|
|
if let Some(event) = events.first_owned() {
|
|
let urls: Vec<RelayUrl> = nip17::extract_owned_relay_list(event).collect();
|
|
|
|
// Connect to relays
|
|
for url in urls.iter() {
|
|
self.client.add_relay(url).await.ok();
|
|
self.client.connect_relay(url).await.ok();
|
|
}
|
|
|
|
relay_urls.extend(urls.into_iter().take(3));
|
|
}
|
|
}
|
|
|
|
relay_urls
|
|
}
|
|
|
|
/// Stores an unwrapped event in local database with reference to original
|
|
async fn set_rumor(&self, id: EventId, rumor: &UnsignedEvent) -> Result<(), Error> {
|
|
let rumor_id = rumor.id.context("Rumor is missing an event id")?;
|
|
let author = rumor.pubkey;
|
|
let conversation = self.conversation_id(rumor).to_string();
|
|
|
|
let mut tags = rumor.tags.clone().to_vec();
|
|
|
|
// Add a unique identifier
|
|
tags.push(Tag::identifier(id));
|
|
|
|
// Add a reference to the rumor's author
|
|
tags.push(Tag::custom(
|
|
TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::A)),
|
|
[author],
|
|
));
|
|
|
|
// Add a conversation id
|
|
tags.push(Tag::custom(
|
|
TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::C)),
|
|
[conversation],
|
|
));
|
|
|
|
// Add a reference to the rumor's id
|
|
tags.push(Tag::event(rumor_id));
|
|
|
|
// Add references to the rumor's participants
|
|
for receiver in rumor.tags.public_keys().copied() {
|
|
tags.push(Tag::custom(
|
|
TagKind::SingleLetter(SingleLetterTag::lowercase(Alphabet::P)),
|
|
[receiver],
|
|
));
|
|
}
|
|
|
|
// Convert rumor to json
|
|
let content = rumor.as_json();
|
|
|
|
let event = EventBuilder::new(Kind::ApplicationSpecificData, content)
|
|
.tags(tags)
|
|
.sign(&Keys::generate())
|
|
.await?;
|
|
|
|
self.client.database().save_event(&event).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Retrieves a previously unwrapped event from local database
|
|
async fn get_rumor(&self, id: EventId) -> Result<UnsignedEvent, Error> {
|
|
let filter = Filter::new()
|
|
.kind(Kind::ApplicationSpecificData)
|
|
.identifier(id)
|
|
.limit(1);
|
|
|
|
if let Some(event) = self.client.database().query(filter).await?.first_owned() {
|
|
UnsignedEvent::from_json(event.content).map_err(|e| anyhow!(e))
|
|
} else {
|
|
Err(anyhow!("Event is not cached yet."))
|
|
}
|
|
}
|
|
|
|
// Unwraps a gift-wrapped event and processes its contents.
|
|
async fn extract_rumor(&self, gift_wrap: &Event) -> Result<(), Error> {
|
|
// Try to get cached rumor first
|
|
if let Ok(event) = self.get_rumor(gift_wrap.id).await {
|
|
self.process_rumor(gift_wrap.id, event).await?;
|
|
return Ok(());
|
|
}
|
|
|
|
// Try to unwrap with the available signer
|
|
let unwrapped = self.try_unwrap_gift_wrap(gift_wrap).await?;
|
|
//let sender = unwrapped.sender;
|
|
let mut rumor_unsigned = unwrapped.rumor;
|
|
|
|
//if !self.verify_rumor_sender(sender, &rumor_unsigned) {
|
|
// return Err(anyhow!("Cannot verify the sender"));
|
|
//};
|
|
|
|
// Generate event id for the rumor if it doesn't have one
|
|
rumor_unsigned.ensure_id();
|
|
|
|
// Cache the rumor
|
|
self.set_rumor(gift_wrap.id, &rumor_unsigned).await?;
|
|
|
|
// Process the rumor
|
|
self.process_rumor(gift_wrap.id, rumor_unsigned).await?;
|
|
|
|
Ok(())
|
|
}
|
|
|
|
// Helper method to try unwrapping with different signers
|
|
async fn try_unwrap_gift_wrap(&self, gift_wrap: &Event) -> Result<UnwrappedGift, Error> {
|
|
// Try to unwrap with the encryption key first
|
|
// NIP-4e: https://github.com/nostr-protocol/nips/blob/per-device-keys/4e.md
|
|
if let Some(signer) = self.device.read().await.encryption.as_ref() {
|
|
match UnwrappedGift::from_gift_wrap(signer, gift_wrap).await {
|
|
Ok(unwrapped) => {
|
|
return Ok(unwrapped);
|
|
}
|
|
Err(e) => {
|
|
log::warn!("Failed to unwrap with the encryption key: {e}")
|
|
}
|
|
}
|
|
}
|
|
|
|
// Try to unwrap with the user's signer
|
|
let signer = self.client.signer().await?;
|
|
let unwrapped = UnwrappedGift::from_gift_wrap(&signer, gift_wrap).await?;
|
|
|
|
Ok(unwrapped)
|
|
}
|
|
|
|
/// Process a rumor event.
|
|
async fn process_rumor(&self, id: EventId, event: UnsignedEvent) -> Result<(), Error> {
|
|
// Send all pubkeys to the metadata batch to sync data
|
|
for public_key in event.tags.public_keys().copied() {
|
|
self.ingester.send(public_key).await;
|
|
}
|
|
|
|
match event.created_at >= self.initialized_at {
|
|
// New message: send a signal to notify the UI
|
|
true => {
|
|
let new_message = NewMessage::new(id, event);
|
|
self.signal.send(SignalKind::NewMessage(new_message)).await;
|
|
}
|
|
// Old message: Coop is probably processing the user's messages during initial load
|
|
false => {
|
|
self.gift_wrap_processing.store(true, Ordering::Release);
|
|
}
|
|
}
|
|
|
|
Ok(())
|
|
}
|
|
|
|
/// Get the conversation ID for a given rumor (message).
|
|
fn conversation_id(&self, rumor: &UnsignedEvent) -> u64 {
|
|
let mut hasher = DefaultHasher::new();
|
|
let mut pubkeys: Vec<PublicKey> = rumor.tags.public_keys().copied().collect();
|
|
pubkeys.push(rumor.pubkey);
|
|
pubkeys.sort();
|
|
pubkeys.dedup();
|
|
pubkeys.hash(&mut hasher);
|
|
|
|
hasher.finish()
|
|
}
|
|
|
|
/// Verify that the sender of a rumor is the same as the sender of the event.
|
|
#[allow(dead_code)]
|
|
fn verify_rumor_sender(&self, sender: PublicKey, rumor: &UnsignedEvent) -> bool {
|
|
rumor.pubkey == sender
|
|
}
|
|
|
|
/// Extract an encryption keys announcement from an event.
|
|
fn extract_announcement(&self, event: &Event) -> Result<Announcement, Error> {
|
|
let public_key = event
|
|
.tags
|
|
.iter()
|
|
.find(|tag| tag.kind().as_str() == "n" || tag.kind().as_str() == "pubkey")
|
|
.and_then(|tag| tag.content())
|
|
.and_then(|c| PublicKey::parse(c).ok())
|
|
.context("Cannot parse public key from the event's tags")?;
|
|
|
|
let client_name = event
|
|
.tags
|
|
.find(TagKind::Client)
|
|
.and_then(|tag| tag.content())
|
|
.map(|c| c.to_string())
|
|
.context("Cannot parse client name from the event's tags")?;
|
|
|
|
Ok(Announcement::new(event.id, client_name, public_key))
|
|
}
|
|
|
|
/// Extract an encryption keys response from an event.
|
|
fn extract_response(&self, event: &Event) -> Result<Response, Error> {
|
|
let payload = event.content.clone();
|
|
let root_device = event
|
|
.tags
|
|
.find(TagKind::custom("P"))
|
|
.and_then(|tag| tag.content())
|
|
.and_then(|c| PublicKey::parse(c).ok())
|
|
.context("Cannot parse public key from the event's tags")?;
|
|
|
|
Ok(Response::new(payload, root_device))
|
|
}
|
|
}
|