update

crates/community/src/history.rs

@@ -6,9 +6,10 @@ use std::time::{Duration, Instant};
 
 use anyhow::Result;
 use concord::cord01::KIND_WRAP_EPHEMERAL;
-use concord::cord03::{self, ChatRumor, plane_keys};
-use concord::state::ChannelCursor;
-use concord::{ChannelId, Epoch};
+use concord::cord03::{self, ChatRumor};
+use concord::derive::channel_group_key;
+use concord::state::{ChannelCursor, HeldKey};
+use concord::{ChannelId, GroupKey};
 use futures::future::{Either, select};
 use nostr_sdk::prelude::*;
 
@@ -149,13 +150,16 @@ pub async fn page(
     client: &Client,
     pages: &PageRegistry,
     channel: &ChannelId,
-    held: &[(Epoch, [u8; 32])],
+    held: &[HeldKey],
     relays: &[RelayUrl],
     window: Window,
     max_pages: usize,
     limit: usize,
 ) -> Result<WrapPage> {
-    let planes = plane_keys(held, channel)?;
+    let planes: Vec<(HeldKey, GroupKey)> = held
+        .iter()
+        .map(|key| Ok((*key, channel_group_key(&key.key, channel, key.epoch)?)))
+        .collect::<Result<Vec<_>>>()?;
     let authors: Vec<PublicKey> = planes.iter().map(|(_, group)| group.pk()).collect();
 
     if authors.is_empty() || relays.is_empty() || limit == 0 {
@@ -201,12 +205,20 @@ pub async fn page(
         let answered = client.database().query(filter).await?;
 
         for wrap in walk.accept(answered, limit) {
-            let Some((epoch, group)) = planes.iter().find(|(_, group)| group.pk() == wrap.pubkey)
+            let Some((held, group)) = planes.iter().find(|(_, group)| group.pk() == wrap.pubkey)
             else {
                 continue;
             };
 
-            let Ok((stream, rumor)) = cord03::open(&wrap, group, channel, *epoch) else {
+            // A retired key reads only what was sealed before its rotation published.
+            if held
+                .retired_at
+                .is_some_and(|retired| wrap.created_at.as_secs() > retired)
+            {
+                continue;
+            }
+
+            let Ok((stream, rumor)) = cord03::open(&wrap, group, channel, held.epoch) else {
                 continue;
             };
 
@@ -332,7 +344,6 @@ fn history_subscription() -> SubscriptionId {
     SubscriptionId::new(format!("history-{}", NEXT.fetch_add(1, Ordering::Relaxed)))
 }
 
-/// Await `future`, giving up after `limit`.
 async fn within<F>(limit: Duration, future: F) -> Option<F::Output>
 where
     F: Future,
@@ -460,6 +471,7 @@ impl Walk {
 mod tests {
     use std::cmp::Reverse;
 
+    use concord::Epoch;
     use concord::cord03::{build_message, seal_rumor};
     use concord::derive::channel_group_key;
 
@@ -492,8 +504,27 @@ mod tests {
     fn a_walk_pages_back_across_a_rekey() {
         let channel = ChannelId::from_bytes([0x9cu8; 32]);
         let author = Keys::generate();
-        let held = [(Epoch(0), SECRET), (Epoch(1), NEXT_SECRET)];
-        let planes = plane_keys(&held, &channel).expect("derives");
+        let held = [
+            HeldKey {
+                epoch: Epoch(0),
+                key: SECRET,
+                retired_at: None,
+            },
+            HeldKey {
+                epoch: Epoch(1),
+                key: NEXT_SECRET,
+                retired_at: None,
+            },
+        ];
+        let planes: Vec<(HeldKey, GroupKey)> = held
+            .iter()
+            .map(|key| {
+                (
+                    *key,
+                    channel_group_key(&key.key, &channel, key.epoch).expect("derives"),
+                )
+            })
+            .collect();
 
         // Three messages a second apart: a page boundary falls between each.
         let base = 1_700_000_000_000;
@@ -530,13 +561,13 @@ mod tests {
             let page = serve_page(&relay, walk.region(), 2);
 
             for wrap in walk.accept(page, 2) {
-                let Some((epoch, group)) =
+                let Some((held, group)) =
                     planes.iter().find(|(_, group)| group.pk() == wrap.pubkey)
                 else {
                     continue;
                 };
 
-                let (_, rumor) = cord03::open(&wrap, group, &channel, *epoch).expect("opens");
+                let (_, rumor) = cord03::open(&wrap, group, &channel, held.epoch).expect("opens");
                 found.push(rumor);
             }
         }