feat: rewrite the nip-4e implementation (#1)

Make NIP-4e a core feature, not an optional feature.

Note:
- The UI is broken and needs to be updated in a separate PR.

Reviewed-on: #1

crates/person/Cargo.toml

@@ -11,7 +11,7 @@ state = { path = "../state" }
 gpui.workspace = true
 nostr-sdk.workspace = true
 anyhow.workspace = true
-itertools.workspace = true
 smallvec.workspace = true
 smol.workspace = true
+flume.workspace = true
 log.workspace = true

crates/person/src/lib.rs

@@ -1,9 +1,17 @@
+use std::cell::RefCell;
 use std::collections::{HashMap, HashSet};
+use std::rc::Rc;
+use std::time::Duration;
 
+use anyhow::{anyhow, Error};
+use common::{EventUtils, BOOTSTRAP_RELAYS};
 use gpui::{App, AppContext, Context, Entity, Global, Task};
 use nostr_sdk::prelude::*;
+pub use person::*;
 use smallvec::{smallvec, SmallVec};
-use state::NostrRegistry;
+use state::{Announcement, NostrRegistry, TIMEOUT};
+
+mod person;
 
 pub fn init(cx: &mut App) {
     PersonRegistry::set_global(cx.new(PersonRegistry::new), cx);
@@ -13,68 +21,87 @@ struct GlobalPersonRegistry(Entity<PersonRegistry>);
 
 impl Global for GlobalPersonRegistry {}
 
+#[derive(Debug, Clone)]
+enum Dispatch {
+    Person(Box<Person>),
+    Announcement(Box<Event>),
+}
+
 /// Person Registry
 #[derive(Debug)]
 pub struct PersonRegistry {
     /// Collection of all persons (user profiles)
-    pub persons: HashMap<PublicKey, Entity<Profile>>,
+    persons: HashMap<PublicKey, Entity<Person>>,
+
+    /// Set of public keys that have been seen
+    seen: Rc<RefCell<HashSet<PublicKey>>>,
+
+    /// Sender for requesting metadata
+    sender: flume::Sender<PublicKey>,
 
     /// Tasks for asynchronous operations
-    _tasks: SmallVec<[Task<()>; 2]>,
+    _tasks: SmallVec<[Task<()>; 4]>,
 }
 
 impl PersonRegistry {
-    /// Retrieve the global person registry state
+    /// Retrieve the global person registry
     pub fn global(cx: &App) -> Entity<Self> {
         cx.global::<GlobalPersonRegistry>().0.clone()
     }
 
     /// Set the global person registry instance
-    pub(crate) fn set_global(state: Entity<Self>, cx: &mut App) {
+    fn set_global(state: Entity<Self>, cx: &mut App) {
         cx.set_global(GlobalPersonRegistry(state));
     }
 
     /// Create a new person registry instance
-    pub(crate) fn new(cx: &mut Context<Self>) -> Self {
+    fn new(cx: &mut Context<Self>) -> Self {
         let nostr = NostrRegistry::global(cx);
         let client = nostr.read(cx).client();
+
+        // Channel for communication between nostr and gpui
+        let (tx, rx) = flume::bounded::<Dispatch>(100);
+        let (mta_tx, mta_rx) = flume::bounded::<PublicKey>(100);
+
         let mut tasks = smallvec![];
 
         tasks.push(
-            // Handle notifications
-            cx.spawn({
-                let client = nostr.read(cx).client();
+            // Handle nostr notifications
+            cx.background_spawn({
+                let client = client.clone();
 
-                async move |this, cx| {
-                    let mut notifications = client.notifications();
-                    let mut processed_events = HashSet::new();
+                async move {
+                    Self::handle_notifications(&client, &tx).await;
+                }
+            }),
+        );
 
-                    while let Ok(notification) = notifications.recv().await {
-                        let RelayPoolNotification::Message { message, .. } = notification else {
-                            // Skip if the notification is not a message
-                            continue;
-                        };
+        tasks.push(
+            // Handle metadata requests
+            cx.background_spawn({
+                let client = client.clone();
 
-                        if let RelayMessage::Event { event, .. } = message {
-                            if !processed_events.insert(event.id) {
-                                // Skip if the event has already been processed
-                                continue;
+                async move {
+                    Self::handle_requests(&client, &mta_rx).await;
+                }
+            }),
+        );
+
+        tasks.push(
+            // Update GPUI state
+            cx.spawn(async move |this, cx| {
+                while let Ok(event) = rx.recv_async().await {
+                    this.update(cx, |this, cx| {
+                        match event {
+                            Dispatch::Person(person) => {
+                                this.insert(*person, cx);
                             }
-
-                            if event.kind != Kind::Metadata {
-                                // Skip if the event is not a metadata event
-                                continue;
-                            };
-
-                            let metadata = Metadata::from_json(&event.content).unwrap_or_default();
-                            let profile = Profile::new(event.pubkey, metadata);
-
-                            this.update(cx, |this, cx| {
-                                this.insert_or_update_person(profile, cx);
-                            })
-                            .expect("Entity has been released")
-                        }
-                    }
+                            Dispatch::Announcement(event) => {
+                                this.set_announcement(&event, cx);
+                            }
+                        };
+                    })
+                    .ok();
                 }
             }),
         );
@@ -83,18 +110,19 @@ impl PersonRegistry {
             // Load all user profiles from the database
             cx.spawn(async move |this, cx| {
                 let result = cx
-                    .background_spawn(async move { Self::load_persons(&client).await })
+                    .background_executor()
+                    .await_on_background(async move { Self::load_persons(&client).await })
                     .await;
 
                 match result {
-                    Ok(profiles) => {
+                    Ok(persons) => {
                         this.update(cx, |this, cx| {
-                            this.bulk_insert_persons(profiles, cx);
+                            this.bulk_inserts(persons, cx);
                         })
                         .ok();
                     }
                     Err(e) => {
-                        log::error!("Failed to load persons: {e}");
+                        log::error!("Failed to load all persons from the database: {e}");
                     }
                 };
             }),
@@ -102,70 +130,189 @@ impl PersonRegistry {
 
         Self {
             persons: HashMap::new(),
+            seen: Rc::new(RefCell::new(HashSet::new())),
+            sender: mta_tx,
             _tasks: tasks,
         }
     }
 
+    /// Handle nostr notifications
+    async fn handle_notifications(client: &Client, tx: &flume::Sender<Dispatch>) {
+        let mut notifications = client.notifications();
+        let mut processed_events = HashSet::new();
+
+        while let Ok(notification) = notifications.recv().await {
+            let RelayPoolNotification::Message { message, .. } = notification else {
+                // Skip if the notification is not a message
+                continue;
+            };
+
+            if let RelayMessage::Event { event, .. } = message {
+                if !processed_events.insert(event.id) {
+                    // Skip if the event has already been processed
+                    continue;
+                }
+
+                match event.kind {
+                    Kind::Metadata => {
+                        let metadata = Metadata::from_json(&event.content).unwrap_or_default();
+                        let person = Person::new(event.pubkey, metadata);
+                        let val = Box::new(person);
+
+                        // Send
+                        tx.send_async(Dispatch::Person(val)).await.ok();
+                    }
+                    Kind::Custom(10044) => {
+                        let val = Box::new(event.into_owned());
+
+                        // Send
+                        tx.send_async(Dispatch::Announcement(val)).await.ok();
+                    }
+                    Kind::ContactList => {
+                        let public_keys = event.extract_public_keys();
+
+                        // Get metadata for all public keys
+                        Self::get_metadata(client, public_keys).await.ok();
+                    }
+                    _ => {}
+                }
+            }
+        }
+    }
+
+    /// Handle request for metadata
+    async fn handle_requests(client: &Client, rx: &flume::Receiver<PublicKey>) {
+        let mut batch: HashSet<PublicKey> = HashSet::new();
+
+        loop {
+            match flume::Selector::new()
+                .recv(rx, |result| result.ok())
+                .wait_timeout(Duration::from_secs(2))
+            {
+                Ok(Some(public_key)) => {
+                    log::info!("Received public key: {}", public_key);
+                    batch.insert(public_key);
+                    // Process the batch if it's full
+                    if batch.len() >= 20 {
+                        Self::get_metadata(client, std::mem::take(&mut batch))
+                            .await
+                            .ok();
+                    }
+                }
+                _ => {
+                    Self::get_metadata(client, std::mem::take(&mut batch))
+                        .await
+                        .ok();
+                }
+            }
+        }
+    }
+
+    /// Get metadata for all public keys in a event
+    async fn get_metadata<I>(client: &Client, public_keys: I) -> Result<(), Error>
+    where
+        I: IntoIterator<Item = PublicKey>,
+    {
+        let authors: Vec<PublicKey> = public_keys.into_iter().collect();
+        let limit = authors.len();
+
+        if authors.is_empty() {
+            return Err(anyhow!("You need at least one public key"));
+        }
+
+        // Construct the subscription option
+        let opts = SubscribeAutoCloseOptions::default()
+            .exit_policy(ReqExitPolicy::ExitOnEOSE)
+            .timeout(Some(Duration::from_secs(TIMEOUT)));
+
+        // Construct the filter for metadata
+        let filter = Filter::new()
+            .kind(Kind::Metadata)
+            .authors(authors)
+            .limit(limit);
+
+        client
+            .subscribe_to(BOOTSTRAP_RELAYS, filter, Some(opts))
+            .await?;
+
+        Ok(())
+    }
+
     /// Load all user profiles from the database
-    async fn load_persons(client: &Client) -> Result<Vec<Profile>, Error> {
+    async fn load_persons(client: &Client) -> Result<Vec<Person>, Error> {
         let filter = Filter::new().kind(Kind::Metadata).limit(200);
         let events = client.database().query(filter).await?;
 
-        let mut profiles = vec![];
+        let mut persons = vec![];
 
         for event in events.into_iter() {
             let metadata = Metadata::from_json(event.content).unwrap_or_default();
-            let profile = Profile::new(event.pubkey, metadata);
-            profiles.push(profile);
+            let person = Person::new(event.pubkey, metadata);
+            persons.push(person);
         }
 
-        Ok(profiles)
+        Ok(persons)
+    }
+
+    /// Set profile encryption keys announcement
+    fn set_announcement(&mut self, event: &Event, cx: &mut App) {
+        if let Some(person) = self.persons.get(&event.pubkey) {
+            let announcement = Announcement::from(event);
+
+            person.update(cx, |person, cx| {
+                person.set_announcement(announcement);
+                cx.notify();
+            });
+        }
     }
 
     /// Insert batch of persons
-    fn bulk_insert_persons(&mut self, profiles: Vec<Profile>, cx: &mut Context<Self>) {
-        for profile in profiles.into_iter() {
-            self.persons
-                .insert(profile.public_key(), cx.new(|_| profile));
+    fn bulk_inserts(&mut self, persons: Vec<Person>, cx: &mut Context<Self>) {
+        for person in persons.into_iter() {
+            self.persons.insert(person.public_key(), cx.new(|_| person));
         }
         cx.notify();
     }
 
     /// Insert or update a person
-    pub fn insert_or_update_person(&mut self, profile: Profile, cx: &mut App) {
-        let public_key = profile.public_key();
+    pub fn insert(&mut self, person: Person, cx: &mut App) {
+        let public_key = person.public_key();
 
         match self.persons.get(&public_key) {
-            Some(person) => {
-                person.update(cx, |this, cx| {
-                    *this = profile;
+            Some(this) => {
+                this.update(cx, |this, cx| {
+                    *this = person;
                     cx.notify();
                 });
             }
             None => {
-                self.persons.insert(public_key, cx.new(|_| profile));
+                self.persons.insert(public_key, cx.new(|_| person));
             }
         }
     }
 
-    /// Get single person
-    pub fn get_person(&self, public_key: &PublicKey, cx: &App) -> Profile {
-        self.persons
-            .get(public_key)
-            .map(|e| e.read(cx))
-            .cloned()
-            .unwrap_or(Profile::new(public_key.to_owned(), Metadata::default()))
-    }
-
-    /// Get group of persons
-    pub fn get_group_person(&self, public_keys: &[PublicKey], cx: &App) -> Vec<Profile> {
-        let mut profiles = vec![];
-
-        for public_key in public_keys.iter() {
-            let profile = self.get_person(public_key, cx);
-            profiles.push(profile);
+    /// Get single person by public key
+    pub fn get(&self, public_key: &PublicKey, cx: &App) -> Person {
+        if let Some(person) = self.persons.get(public_key) {
+            return person.read(cx).clone();
         }
 
-        profiles
+        let public_key = *public_key;
+        let mut seen = self.seen.borrow_mut();
+
+        if seen.insert(public_key) {
+            let sender = self.sender.clone();
+
+            // Spawn background task to request metadata
+            cx.background_spawn(async move {
+                if let Err(e) = sender.send_async(public_key).await {
+                    log::warn!("Failed to send public key for metadata request: {}", e);
+                }
+            })
+            .detach();
+        }
+
+        // Return a temporary profile with default metadata
+        Person::new(public_key, Metadata::default())
     }
 }

crates/person/src/person.rs

@@ -0,0 +1,122 @@
+use std::cmp::Ordering;
+use std::hash::{Hash, Hasher};
+
+use gpui::SharedString;
+use nostr_sdk::prelude::*;
+use state::Announcement;
+
+/// Person
+#[derive(Debug, Clone)]
+pub struct Person {
+    /// Public Key
+    public_key: PublicKey,
+
+    /// Metadata (profile)
+    metadata: Metadata,
+
+    /// Dekey (NIP-4e) announcement
+    announcement: Option<Announcement>,
+}
+
+impl PartialEq for Person {
+    fn eq(&self, other: &Self) -> bool {
+        self.public_key == other.public_key
+    }
+}
+
+impl Eq for Person {}
+
+impl PartialOrd for Person {
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        Some(self.cmp(other))
+    }
+}
+
+impl Ord for Person {
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.name().cmp(&other.name())
+    }
+}
+
+impl Hash for Person {
+    fn hash<H: Hasher>(&self, state: &mut H) {
+        self.public_key.hash(state)
+    }
+}
+
+impl From<PublicKey> for Person {
+    fn from(public_key: PublicKey) -> Self {
+        Self::new(public_key, Metadata::default())
+    }
+}
+
+impl Person {
+    pub fn new(public_key: PublicKey, metadata: Metadata) -> Self {
+        Self {
+            public_key,
+            metadata,
+            announcement: None,
+        }
+    }
+
+    /// Get profile public key
+    pub fn public_key(&self) -> PublicKey {
+        self.public_key
+    }
+
+    /// Get profile metadata
+    pub fn metadata(&self) -> Metadata {
+        self.metadata.clone()
+    }
+
+    /// Get profile encryption keys announcement
+    pub fn announcement(&self) -> Option<Announcement> {
+        self.announcement.clone()
+    }
+
+    /// Set profile encryption keys announcement
+    pub fn set_announcement(&mut self, announcement: Announcement) {
+        self.announcement = Some(announcement);
+        log::info!("Updated announcement for: {}", self.public_key());
+    }
+
+    /// Get profile avatar
+    pub fn avatar(&self) -> SharedString {
+        self.metadata()
+            .picture
+            .as_ref()
+            .filter(|picture| !picture.is_empty())
+            .map(|picture| picture.into())
+            .unwrap_or_else(|| "brand/avatar.png".into())
+    }
+
+    /// Get profile name
+    pub fn name(&self) -> SharedString {
+        if let Some(display_name) = self.metadata().display_name.as_ref() {
+            if !display_name.is_empty() {
+                return SharedString::from(display_name);
+            }
+        }
+
+        if let Some(name) = self.metadata().name.as_ref() {
+            if !name.is_empty() {
+                return SharedString::from(name);
+            }
+        }
+
+        SharedString::from(shorten_pubkey(self.public_key(), 4))
+    }
+}
+
+/// Shorten a [`PublicKey`] to a string with the first and last `len` characters
+///
+/// Ex. `00000000:00000002`
+pub fn shorten_pubkey(public_key: PublicKey, len: usize) -> String {
+    let Ok(pubkey) = public_key.to_bech32();
+
+    format!(
+        "{}:{}",
+        &pubkey[0..(len + 1)],
+        &pubkey[pubkey.len() - len..]
+    )
+}