add community crate

crates/community/Cargo.toml

@@ -0,0 +1,22 @@
+[package]
+name = "community"
+version.workspace = true
+edition.workspace = true
+publish.workspace = true
+
+[dependencies]
+concord = { path = "../concord" }
+state = { path = "../state" }
+
+gpui.workspace = true
+nostr-sdk.workspace = true
+
+anyhow.workspace = true
+flume.workspace = true
+log.workspace = true
+serde_json.workspace = true
+smallvec.workspace = true
+
+[dev-dependencies]
+nostr-memory.workspace = true
+smol.workspace = true

crates/community/src/community.rs

@@ -0,0 +1 @@
+

crates/community/src/lib.rs

@@ -0,0 +1,8 @@
+use gpui::{App, Window};
+
+mod community;
+mod sync;
+
+pub use sync::*;
+
+pub fn init(_window: &mut Window, _cx: &mut App) {}

crates/community/src/sync.rs

@@ -0,0 +1,410 @@
+use std::collections::{BTreeMap, BTreeSet};
+
+use anyhow::Result;
+use concord::cord01::KIND_WRAP;
+use concord::cord02::list::{CommunityList, KIND_COMMUNITY_LIST};
+use concord::cord02::{self, ControlFold};
+use concord::cord04::AuthorityCitation;
+use concord::cord04::roles::{Permissions, citation_ok};
+use concord::derive::{channel_group_key, control_group_key, guestbook_group_key};
+use concord::store::{self, CommunityState};
+use concord::{ChannelId, CommunityId, Epoch, GroupKey};
+use nostr_sdk::prelude::*;
+use state::UniversalSigner;
+
+const SUBSCRIPTION_PREFIX: &str = "concord/";
+const STATE_PREFIX: &str = "concord/";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
+pub enum PlaneKind {
+    Control(Epoch),
+    Guestbook,
+    Channel(ChannelId, Epoch),
+}
+
+#[derive(Debug, Clone)]
+pub struct Plane {
+    pub kind: PlaneKind,
+    /// The wrap's author: the control signer for Control, the group's own key otherwise.
+    pub address: PublicKey,
+    pub group: GroupKey,
+}
+
+pub fn planes(state: &CommunityState) -> Result<Vec<Plane>> {
+    let mut planes = Vec::new();
+
+    for (epoch, address) in &state.control_pks {
+        let epoch = Epoch(*epoch);
+        let group = control_group_key(&state.community_root, &state.id, epoch)?;
+        planes.push(Plane {
+            kind: PlaneKind::Control(epoch),
+            address: *address,
+            group,
+        });
+    }
+
+    let group = guestbook_group_key(&state.community_root, &state.id, state.root_epoch)?;
+    planes.push(Plane {
+        kind: PlaneKind::Guestbook,
+        address: group.pk(),
+        group,
+    });
+
+    for channel in &state.channels {
+        if channel.private {
+            continue;
+        }
+
+        let group = channel_group_key(&state.community_root, &channel.id, channel.epoch)?;
+        planes.push(Plane {
+            kind: PlaneKind::Channel(channel.id, channel.epoch),
+            address: group.pk(),
+            group,
+        });
+    }
+
+    Ok(planes)
+}
+
+/// One `Filter` covering every held plane. The address is the event author,
+/// not a `p` tag: a Concord wrap's `p` tag carries a random ephemeral key.
+pub fn subscription_filter(planes: &[Plane]) -> Filter {
+    Filter::new()
+        .kinds([Kind::from(KIND_WRAP)])
+        .authors(planes.iter().map(|plane| plane.address))
+}
+
+pub fn subscription_id(id: &CommunityId) -> SubscriptionId {
+    SubscriptionId::new(format!("{SUBSCRIPTION_PREFIX}{}", id.to_hex()))
+}
+
+pub fn community_of(subscription_id: &SubscriptionId) -> Option<CommunityId> {
+    subscription_id
+        .as_str()
+        .strip_prefix(SUBSCRIPTION_PREFIX)?
+        .parse()
+        .ok()
+}
+
+#[derive(Debug, Clone)]
+pub struct Snapshot {
+    pub state: CommunityState,
+    pub control: ControlFold,
+    pub members: BTreeSet<PublicKey>,
+}
+
+/// Discovers the current account's communities from the local database.
+pub async fn load(
+    database: &dyn NostrDatabase,
+    signer: &UniversalSigner,
+    self_pk: PublicKey,
+) -> Result<Vec<CommunityState>> {
+    let filter = Filter::new().kind(Kind::ApplicationSpecificData);
+    let mut newest: BTreeMap<CommunityId, Event> = BTreeMap::new();
+
+    for event in database.query(filter).await? {
+        let Some(id) = state_document_of(&event) else {
+            continue;
+        };
+
+        match newest.get(&id) {
+            Some(existing) if existing.created_at >= event.created_at => {}
+            _ => {
+                newest.insert(id, event);
+            }
+        }
+    }
+
+    let mut states = Vec::with_capacity(newest.len());
+
+    for event in newest.into_values() {
+        match serde_json::from_str::<CommunityState>(&event.content) {
+            Ok(state) => states.push(state),
+            Err(error) => log::warn!("ignoring malformed community state {}: {error}", event.id),
+        }
+    }
+
+    if let Some(list) = load_list(database, signer, self_pk).await? {
+        states.retain(|state| list.is_live(&state.id));
+    }
+
+    Ok(states)
+}
+
+fn state_document_of(event: &Event) -> Option<CommunityId> {
+    let identifier = event.tags.identifier()?;
+    let hex = identifier.strip_prefix(STATE_PREFIX)?;
+    hex.parse().ok()
+}
+
+async fn load_list(
+    database: &dyn NostrDatabase,
+    signer: &UniversalSigner,
+    self_pk: PublicKey,
+) -> Result<Option<CommunityList>> {
+    let filter = Filter::new()
+        .kind(Kind::Custom(KIND_COMMUNITY_LIST))
+        .author(self_pk)
+        .limit(1);
+
+    let Some(event) = database.query(filter).await?.into_iter().next() else {
+        return Ok(None);
+    };
+
+    let json = signer.nip44_decrypt_async(&self_pk, &event.content).await?;
+
+    Ok(Some(serde_json::from_str(&json)?))
+}
+
+/// Rebuilds a community from the wraps already in the local database.
+pub async fn fold(
+    database: &dyn NostrDatabase,
+    state: &CommunityState,
+) -> Result<Option<Snapshot>> {
+    let planes = planes(state)?;
+
+    if planes.is_empty() {
+        return Ok(None);
+    }
+
+    let wraps = database.query(subscription_filter(&planes)).await?;
+    let mut editions = Vec::new();
+    let mut observed: BTreeMap<PublicKey, u64> = BTreeMap::new();
+    let mut guestbook_rumors = Vec::new();
+
+    for wrap in &wraps {
+        let Some(plane) = planes.iter().find(|plane| plane.address == wrap.pubkey) else {
+            continue;
+        };
+
+        match plane.kind {
+            PlaneKind::Control(_) => {
+                if let Ok(edition) = cord02::open_edition(wrap, &plane.group, &plane.address, true)
+                {
+                    editions.push(edition);
+                }
+            }
+            PlaneKind::Guestbook => {
+                if let Ok((_, rumor)) = cord02::guestbook::open(wrap, &plane.group) {
+                    observe(&mut observed, rumor.author, rumor.at_ms);
+                    guestbook_rumors.push(rumor);
+                }
+            }
+            PlaneKind::Channel(channel, epoch) => {
+                if let Ok((opened, rumor)) =
+                    concord::cord03::open(wrap, &plane.group, &channel, epoch)
+                {
+                    store::cache_rumor(database, &channel, &opened).await?;
+                    observe(&mut observed, rumor.author, rumor.at_ms);
+                }
+            }
+        }
+    }
+
+    if editions.is_empty() {
+        return Ok(None);
+    }
+
+    let control = cord02::fold_control(
+        &state.owner,
+        &state.id,
+        &editions,
+        &state.floors(),
+        &state.banned,
+    );
+
+    let granted: BTreeSet<PublicKey> = control
+        .roles
+        .grants()
+        .filter(|grant| !grant.role_ids.is_empty())
+        .map(|grant| grant.member)
+        .collect();
+
+    let floors = state.floors();
+    let can_kick = |actor: &PublicKey, target: &PublicKey, citation: Option<&AuthorityCitation>| {
+        citation_ok(&state.owner, &state.id, actor, citation, &floors)
+            && control
+                .roles
+                .can_act_on_member(actor, &state.owner, target, Permissions::KICK)
+    };
+
+    let now_ms = Timestamp::now().as_secs().saturating_mul(1000);
+    let coalesced = cord02::guestbook::coalesce(&guestbook_rumors, now_ms, None, can_kick);
+    let mut members = cord02::guestbook::complete_memberlist(
+        &coalesced,
+        &observed,
+        &granted,
+        &control.banned,
+        &BTreeMap::new(),
+    );
+
+    // The roster has no grant for the owner, so membership is stated here.
+    members.insert(state.owner);
+
+    let mut state = state.clone();
+    state.apply_fold(&control);
+    store::save_state(database, &state).await?;
+
+    Ok(Some(Snapshot {
+        state,
+        control,
+        members,
+    }))
+}
+
+fn observe(observed: &mut BTreeMap<PublicKey, u64>, author: PublicKey, at_ms: u64) {
+    observed
+        .entry(author)
+        .and_modify(|seen| *seen = (*seen).max(at_ms))
+        .or_insert(at_ms);
+}
+
+#[cfg(test)]
+mod tests {
+    use concord::cord02::list::{CommunityListEntry, JoinMaterial, Tombstone, build_list_event};
+    use concord::cord02::{CommunityMetadata, ROOT_EPOCH, genesis, open_edition};
+    use concord::cord04::ParsedEdition;
+    use concord::derive::control_signer_group_key;
+    use concord::store::save_state;
+    use nostr_memory::MemoryDatabase;
+
+    use super::*;
+
+    const AT_MS: u64 = 1_719_800_000_000;
+
+    fn community(owner: &Keys) -> CommunityState {
+        let metadata = CommunityMetadata {
+            name: "Room".to_owned(),
+            ..Default::default()
+        };
+        let genesis = genesis(owner, &metadata, AT_MS / 1000).expect("genesis");
+        let read = control_group_key(
+            &genesis.community_root,
+            &genesis.identity.community_id,
+            ROOT_EPOCH,
+        )
+        .expect("read key");
+        let address = control_signer_group_key(
+            &genesis.control_root,
+            &genesis.identity.community_id,
+            ROOT_EPOCH,
+        )
+        .expect("signer key")
+        .pk();
+
+        let editions: Vec<ParsedEdition> = genesis
+            .wraps
+            .iter()
+            .map(|wrap| open_edition(wrap, &read, &address, true).expect("opens"))
+            .collect();
+
+        CommunityState::from_genesis(&genesis, &editions, AT_MS).expect("state")
+    }
+
+    fn material(state: &CommunityState) -> JoinMaterial {
+        JoinMaterial {
+            community_id: state.id,
+            owner: state.owner,
+            owner_salt: "00".repeat(32),
+            community_root: "11".repeat(32),
+            root_epoch: ROOT_EPOCH,
+            control_pk: None,
+            control_root: None,
+            channels: Vec::new(),
+            relays: Vec::new(),
+            name: "Room".to_owned(),
+            extra: Default::default(),
+        }
+    }
+
+    fn entry(state: &CommunityState, added_at: u64) -> CommunityListEntry {
+        let material = material(state);
+
+        CommunityListEntry {
+            community_id: state.id,
+            seed: material.clone(),
+            current: material,
+            added_at,
+            extra: Default::default(),
+        }
+    }
+
+    #[test]
+    fn every_held_plane_routes_by_its_wrap_author() {
+        let owner = Keys::generate();
+        let state = community(&owner);
+        let planes = planes(&state).expect("planes");
+
+        assert_eq!(
+            planes.len(),
+            3,
+            "the control epoch, the guestbook and #general"
+        );
+
+        let filter = subscription_filter(&planes);
+        let expected: BTreeSet<PublicKey> = planes.iter().map(|plane| plane.address).collect();
+        assert_eq!(filter.authors, Some(expected));
+        assert_eq!(filter.kinds, Some(BTreeSet::from([Kind::from(KIND_WRAP)])));
+
+        assert_eq!(community_of(&subscription_id(&state.id)), Some(state.id));
+        assert_eq!(community_of(&SubscriptionId::new("device-giftwrap")), None);
+    }
+
+    #[test]
+    fn loading_scans_state_documents_and_honours_the_list() {
+        smol::block_on(async {
+            let keys = Keys::generate();
+            let signer = UniversalSigner::new(keys.clone());
+            let owner = Keys::generate();
+            let state = community(&owner);
+
+            // With no list event, every state document is a community.
+            let no_list = MemoryDatabase::unbounded();
+            save_state(&no_list, &state).await.expect("saves");
+            let loaded = load(&no_list, &signer, keys.public_key())
+                .await
+                .expect("loads");
+            assert_eq!(loaded.len(), 1);
+            assert_eq!(loaded[0].id, state.id);
+
+            // A live entry keeps it.
+            let event = build_list_event(
+                &keys,
+                &CommunityList {
+                    entries: vec![entry(&state, AT_MS)],
+                    ..Default::default()
+                },
+            )
+            .expect("builds");
+            let live = MemoryDatabase::unbounded();
+            save_state(&live, &state).await.expect("saves");
+            live.save_event(&event).await.expect("saves list");
+            let loaded = load(&live, &signer, keys.public_key())
+                .await
+                .expect("loads");
+            assert_eq!(loaded.len(), 1);
+
+            // A newer tombstone than the entry retires it.
+            let event = build_list_event(
+                &keys,
+                &CommunityList {
+                    entries: vec![entry(&state, AT_MS)],
+                    tombstones: vec![Tombstone {
+                        community_id: state.id,
+                        removed_at: AT_MS + 1,
+                        extra: Default::default(),
+                    }],
+                    ..Default::default()
+                },
+            )
+            .expect("builds");
+            let retired = MemoryDatabase::unbounded();
+            save_state(&retired, &state).await.expect("saves");
+            retired.save_event(&event).await.expect("saves list");
+            let loaded = load(&retired, &signer, keys.public_key())
+                .await
+                .expect("loads");
+            assert!(loaded.is_empty());
+        });
+    }
+}