wip

crates/state_old/Cargo.toml

@@ -0,0 +1,21 @@
+[package]
+name = "state_old"
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+common = { path = "../common" }
+
+nostr-sdk.workspace = true
+nostr-lmdb.workspace = true
+
+gpui.workspace = true
+smol.workspace = true
+smallvec.workspace = true
+log.workspace = true
+anyhow.workspace = true
+serde.workspace = true
+serde_json.workspace = true
+
+rustls = "0.23.23"

crates/state_old/src/lib.rs

@@ -0,0 +1,388 @@
+use std::collections::HashSet;
+use std::sync::Arc;
+use std::time::Duration;
+
+use anyhow::{anyhow, Context as AnyhowContext, Error};
+use common::{config_dir, BOOTSTRAP_RELAYS, SEARCH_RELAYS};
+use gpui::{App, AppContext, Context, Entity, Global, Task};
+use nostr_lmdb::NostrLmdb;
+use nostr_sdk::prelude::*;
+use smallvec::{smallvec, SmallVec};
+use smol::lock::RwLock;
+pub use storage::*;
+pub use tracker::*;
+
+mod storage;
+mod tracker;
+
+pub const GIFTWRAP_SUBSCRIPTION: &str = "gift-wrap-events";
+
+pub fn init(cx: &mut App) {
+    NostrRegistry::set_global(cx.new(NostrRegistry::new), cx);
+}
+
+struct GlobalNostrRegistry(Entity<NostrRegistry>);
+
+impl Global for GlobalNostrRegistry {}
+
+/// Nostr Registry
+#[derive(Debug)]
+pub struct NostrRegistry {
+    /// Nostr Client
+    client: Client,
+
+    /// Custom gossip implementation
+    gossip: Arc<RwLock<Gossip>>,
+
+    /// Tracks activity related to Nostr events
+    tracker: Arc<RwLock<EventTracker>>,
+
+    /// Tasks for asynchronous operations
+    _tasks: SmallVec<[Task<()>; 1]>,
+}
+
+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(cx: &mut Context<Self>) -> 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();
+
+        // Construct the 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 lmdb
+        let lmdb = cx.background_executor().block(async move {
+            let path = config_dir().join("nostr");
+            NostrLmdb::open(path)
+                .await
+                .expect("Failed to initialize database")
+        });
+
+        // Construct the nostr client
+        let client = ClientBuilder::default().database(lmdb).opts(opts).build();
+
+        let tracker = Arc::new(RwLock::new(EventTracker::default()));
+        let gossip = Arc::new(RwLock::new(Gossip::default()));
+
+        let mut tasks = smallvec![];
+
+        tasks.push(
+            // Establish connection to the bootstrap relays
+            //
+            // And handle notifications from the nostr relay pool channel
+            cx.background_spawn({
+                let client = client.clone();
+                let gossip = Arc::clone(&gossip);
+                let tracker = Arc::clone(&tracker);
+                let _ = initialized_at();
+
+                async move {
+                    // Connect to the bootstrap relays
+                    Self::connect(&client).await;
+
+                    // Handle notifications from the relay pool
+                    Self::handle_notifications(&client, &gossip, &tracker).await;
+                }
+            }),
+        );
+
+        Self {
+            client,
+            tracker,
+            gossip,
+            _tasks: tasks,
+        }
+    }
+
+    /// Establish connection to the bootstrap relays
+    async fn connect(client: &Client) {
+        // 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() {
+            client.add_relay(url).await.ok();
+        }
+
+        // Connect to all added relays
+        client.connect().await;
+    }
+
+    async fn handle_notifications(
+        client: &Client,
+        gossip: &Arc<RwLock<Gossip>>,
+        tracker: &Arc<RwLock<EventTracker>>,
+    ) {
+        let mut notifications = client.notifications();
+        let mut processed_events = HashSet::new();
+
+        while let Ok(notification) = notifications.recv().await {
+            let RelayPoolNotification::Message { message, relay_url } = notification else {
+                // Skip if the notification is not a message
+                continue;
+            };
+
+            match message {
+                RelayMessage::Event { event, .. } => {
+                    if !processed_events.insert(event.id) {
+                        // Skip if the event has already been processed
+                        continue;
+                    }
+
+                    match event.kind {
+                        Kind::RelayList => {
+                            let mut gossip = gossip.write().await;
+                            gossip.insert_relays(&event);
+
+                            let urls: Vec<RelayUrl> = Self::extract_write_relays(&event);
+                            let author = event.pubkey;
+
+                            log::info!("Write relays: {urls:?}");
+
+                            // Fetch user's encryption announcement event
+                            Self::get(client, &urls, author, Kind::Custom(10044)).await;
+                            // Fetch user's messaging relays event
+                            Self::get(client, &urls, author, Kind::InboxRelays).await;
+
+                            // Verify if the event is belonging to the current user
+                            if Self::is_self_authored(client, &event).await {
+                                // Fetch user's metadata event
+                                Self::get(client, &urls, author, Kind::Metadata).await;
+                                // Fetch user's contact list event
+                                Self::get(client, &urls, author, Kind::ContactList).await;
+                            }
+                        }
+                        Kind::InboxRelays => {
+                            let mut gossip = gossip.write().await;
+                            gossip.insert_messaging_relays(&event);
+
+                            if Self::is_self_authored(client, &event).await {
+                                // Extract user's messaging relays
+                                let urls: Vec<RelayUrl> =
+                                    nip17::extract_relay_list(&event).cloned().collect();
+
+                                // Fetch user's inbox messages in the extracted relays
+                                Self::get_messages(client, event.pubkey, &urls).await;
+                            }
+                        }
+                        Kind::Custom(10044) => {
+                            let mut gossip = gossip.write().await;
+                            gossip.insert_announcement(&event);
+                        }
+                        Kind::ContactList => {
+                            if Self::is_self_authored(client, &event).await {
+                                let public_keys: Vec<PublicKey> =
+                                    event.tags.public_keys().copied().collect();
+
+                                if let Err(e) =
+                                    Self::get_metadata_for_list(client, public_keys).await
+                                {
+                                    log::error!("Failed to get metadata for list: {e}");
+                                }
+                            }
+                        }
+                        _ => {}
+                    };
+                }
+                RelayMessage::Ok {
+                    event_id, message, ..
+                } => {
+                    let msg = MachineReadablePrefix::parse(&message);
+                    let mut tracker = tracker.write().await;
+
+                    // Message that need to be authenticated will be handled separately
+                    if let Some(MachineReadablePrefix::AuthRequired) = msg {
+                        // Keep track of events that need to be resent after authentication
+                        tracker.resend_queue.insert(event_id, relay_url);
+                    } else {
+                        // Keep track of events sent by Coop
+                        tracker.sent_ids.insert(event_id);
+                    }
+                }
+                _ => {}
+            }
+        }
+    }
+
+    /// Check if event is published by current user
+    pub async fn is_self_authored(client: &Client, event: &Event) -> bool {
+        if let Ok(signer) = client.signer().await {
+            if let Ok(public_key) = signer.get_public_key().await {
+                return public_key == event.pubkey;
+            }
+        }
+        false
+    }
+
+    /// Get event that match the given kind for a given author
+    async fn get(client: &Client, urls: &[RelayUrl], author: PublicKey, kind: Kind) {
+        // Skip if no relays are provided
+        if urls.is_empty() {
+            return;
+        }
+
+        // Ensure relay connections
+        for url in urls.iter() {
+            client.add_relay(url).await.ok();
+            client.connect_relay(url).await.ok();
+        }
+
+        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
+        if let Err(e) = client.subscribe_to(urls, filter, Some(opts)).await {
+            log::error!("Failed to subscribe: {}", e);
+        }
+    }
+
+    /// Get all gift wrap events in the messaging relays for a given public key
+    pub async fn get_messages(client: &Client, public_key: PublicKey, urls: &[RelayUrl]) {
+        // Verify that there are relays provided
+        if urls.is_empty() {
+            return;
+        }
+
+        // Ensure relay connection
+        for url in urls.iter() {
+            client.add_relay(url).await.ok();
+            client.connect_relay(url).await.ok();
+        }
+
+        let id = SubscriptionId::new(GIFTWRAP_SUBSCRIPTION);
+        let filter = Filter::new().kind(Kind::GiftWrap).pubkey(public_key);
+
+        // Unsubscribe from the previous subscription
+        client.unsubscribe(&id).await;
+
+        // Subscribe to filters to user's messaging relays
+        if let Err(e) = client.subscribe_with_id_to(urls, id, filter, None).await {
+            log::error!("Failed to subscribe: {}", e);
+        } else {
+            log::info!("Subscribed to gift wrap events for public key {public_key}",);
+        }
+    }
+
+    /// Get metadata for a list of public keys
+    async fn get_metadata_for_list(client: &Client, pubkeys: Vec<PublicKey>) -> Result<(), Error> {
+        let opts = SubscribeAutoCloseOptions::default().exit_policy(ReqExitPolicy::ExitOnEOSE);
+        let kinds = vec![Kind::Metadata, Kind::ContactList];
+
+        // Return if the list is empty
+        if pubkeys.is_empty() {
+            return Err(anyhow!("You need at least one public key".to_string(),));
+        }
+
+        let filter = Filter::new()
+            .limit(pubkeys.len() * kinds.len())
+            .authors(pubkeys)
+            .kinds(kinds);
+
+        // Subscribe to filters to the bootstrap relays
+        client
+            .subscribe_to(BOOTSTRAP_RELAYS, filter, Some(opts))
+            .await?;
+
+        Ok(())
+    }
+
+    pub fn extract_read_relays(event: &Event) -> Vec<RelayUrl> {
+        nip65::extract_relay_list(event)
+            .filter_map(|(url, metadata)| {
+                if metadata.is_none() || metadata == &Some(RelayMetadata::Read) {
+                    Some(url.to_owned())
+                } else {
+                    None
+                }
+            })
+            .take(3)
+            .collect()
+    }
+
+    pub fn extract_write_relays(event: &Event) -> Vec<RelayUrl> {
+        nip65::extract_relay_list(event)
+            .filter_map(|(url, metadata)| {
+                if metadata.is_none() || metadata == &Some(RelayMetadata::Write) {
+                    Some(url.to_owned())
+                } else {
+                    None
+                }
+            })
+            .take(3)
+            .collect()
+    }
+
+    /// Extract an encryption keys announcement from an event.
+    pub fn extract_announcement(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());
+
+        Ok(Announcement::new(event.id, client_name, public_key))
+    }
+
+    /// Extract an encryption keys response from an event.
+    pub async fn extract_response(client: &Client, event: &Event) -> Result<Response, Error> {
+        let signer = client.signer().await?;
+        let public_key = signer.get_public_key().await?;
+
+        if event.pubkey != public_key {
+            return Err(anyhow!("Event does not belong to current user"));
+        }
+
+        let client_pubkey = 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(event.content.clone(), client_pubkey))
+    }
+
+    /// Returns a reference to the nostr client.
+    pub fn client(&self) -> Client {
+        self.client.clone()
+    }
+
+    /// Returns a reference to the event tracker.
+    pub fn tracker(&self) -> Arc<RwLock<EventTracker>> {
+        Arc::clone(&self.tracker)
+    }
+
+    /// Returns a reference to the cache manager.
+    pub fn gossip(&self) -> Arc<RwLock<Gossip>> {
+        Arc::clone(&self.gossip)
+    }
+}

crates/state_old/src/storage.rs

@@ -0,0 +1,189 @@
+use std::collections::{HashMap, HashSet};
+
+use gpui::SharedString;
+use nostr_sdk::prelude::*;
+
+use crate::NostrRegistry;
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct Announcement {
+    id: EventId,
+    public_key: PublicKey,
+    client_name: Option<String>,
+}
+
+impl Announcement {
+    pub fn new(id: EventId, client_name: Option<String>, public_key: PublicKey) -> Self {
+        Self {
+            id,
+            client_name,
+            public_key,
+        }
+    }
+
+    pub fn id(&self) -> EventId {
+        self.id
+    }
+
+    pub fn public_key(&self) -> PublicKey {
+        self.public_key
+    }
+
+    pub fn client_name(&self) -> SharedString {
+        self.client_name
+            .as_ref()
+            .map(SharedString::from)
+            .unwrap_or(SharedString::from("Unknown"))
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Response {
+    payload: String,
+    public_key: PublicKey,
+}
+
+impl Response {
+    pub fn new(payload: String, public_key: PublicKey) -> Self {
+        Self {
+            payload,
+            public_key,
+        }
+    }
+
+    pub fn public_key(&self) -> PublicKey {
+        self.public_key
+    }
+
+    pub fn payload(&self) -> &str {
+        self.payload.as_str()
+    }
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct Gossip {
+    /// Gossip relays for each public key
+    relays: HashMap<PublicKey, HashSet<(RelayUrl, Option<RelayMetadata>)>>,
+
+    /// Messaging relays for each public key
+    messaging_relays: HashMap<PublicKey, HashSet<RelayUrl>>,
+
+    /// Encryption announcement for each public key
+    announcements: HashMap<PublicKey, Option<Announcement>>,
+}
+
+impl Gossip {
+    /// Get inbox relays for a public key
+    pub fn inbox_relays(&self, public_key: &PublicKey) -> Vec<RelayUrl> {
+        self.relays
+            .get(public_key)
+            .map(|relays| {
+                relays
+                    .iter()
+                    .filter_map(|(url, metadata)| {
+                        if metadata.is_none() || metadata == &Some(RelayMetadata::Read) {
+                            Some(url.to_owned())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+
+    /// Get outbox relays for a public key
+    pub fn outbox_relays(&self, public_key: &PublicKey) -> Vec<RelayUrl> {
+        self.relays
+            .get(public_key)
+            .map(|relays| {
+                relays
+                    .iter()
+                    .filter_map(|(url, metadata)| {
+                        if metadata.is_none() || metadata == &Some(RelayMetadata::Write) {
+                            Some(url.to_owned())
+                        } else {
+                            None
+                        }
+                    })
+                    .collect()
+            })
+            .unwrap_or_default()
+    }
+
+    /// Insert gossip relays for a public key
+    pub fn insert_relays(&mut self, event: &Event) {
+        self.relays.entry(event.pubkey).or_default().extend(
+            event
+                .tags
+                .iter()
+                .filter_map(|tag| {
+                    if let Some(TagStandard::RelayMetadata {
+                        relay_url,
+                        metadata,
+                    }) = tag.clone().to_standardized()
+                    {
+                        Some((relay_url, metadata))
+                    } else {
+                        None
+                    }
+                })
+                .take(3),
+        );
+    }
+
+    /// Get messaging relays for a public key
+    pub fn messaging_relays(&self, public_key: &PublicKey) -> Vec<RelayUrl> {
+        self.messaging_relays
+            .get(public_key)
+            .cloned()
+            .unwrap_or_default()
+            .into_iter()
+            .collect()
+    }
+
+    /// Insert messaging relays for a public key
+    pub fn insert_messaging_relays(&mut self, event: &Event) {
+        self.messaging_relays
+            .entry(event.pubkey)
+            .or_default()
+            .extend(
+                event
+                    .tags
+                    .iter()
+                    .filter_map(|tag| {
+                        if let Some(TagStandard::Relay(url)) = tag.as_standardized() {
+                            Some(url.to_owned())
+                        } else {
+                            None
+                        }
+                    })
+                    .take(3),
+            );
+    }
+
+    /// Ensure connections for the given relay list
+    pub async fn ensure_connections(&self, client: &Client, urls: &[RelayUrl]) {
+        for url in urls {
+            client.add_relay(url).await.ok();
+            client.connect_relay(url).await.ok();
+        }
+    }
+
+    /// Get announcement for a public key
+    pub fn announcement(&self, public_key: &PublicKey) -> Option<Announcement> {
+        self.announcements
+            .get(public_key)
+            .cloned()
+            .unwrap_or_default()
+    }
+
+    /// Insert announcement for a public key
+    pub fn insert_announcement(&mut self, event: &Event) {
+        let announcement = NostrRegistry::extract_announcement(event).ok();
+
+        self.announcements
+            .entry(event.pubkey)
+            .or_insert(announcement);
+    }
+}

crates/state_old/src/tracker.rs

@@ -0,0 +1,43 @@
+use std::collections::{HashMap, HashSet};
+use std::sync::OnceLock;
+
+use nostr_sdk::prelude::*;
+
+static INITIALIZED_AT: OnceLock<Timestamp> = OnceLock::new();
+
+pub fn initialized_at() -> &'static Timestamp {
+    INITIALIZED_AT.get_or_init(Timestamp::now)
+}
+
+#[derive(Debug, Clone, Default)]
+pub struct EventTracker {
+    /// Tracking events that have been resent by Coop in the current session
+    pub resent_ids: Vec<Output<EventId>>,
+
+    /// Temporarily store events that need to be resent later
+    pub resend_queue: HashMap<EventId, RelayUrl>,
+
+    /// Tracking events sent by Coop in the current session
+    pub sent_ids: HashSet<EventId>,
+
+    /// Tracking events seen on which relays in the current session
+    pub seen_on_relays: HashMap<EventId, HashSet<RelayUrl>>,
+}
+
+impl EventTracker {
+    pub fn resent_ids(&self) -> &Vec<Output<EventId>> {
+        &self.resent_ids
+    }
+
+    pub fn resend_queue(&self) -> &HashMap<EventId, RelayUrl> {
+        &self.resend_queue
+    }
+
+    pub fn sent_ids(&self) -> &HashSet<EventId> {
+        &self.sent_ids
+    }
+
+    pub fn seen_on_relays(&self) -> &HashMap<EventId, HashSet<RelayUrl>> {
+        &self.seen_on_relays
+    }
+}