feat(relay): implement NIP-ER event reminder support (kind:30300) (#934)

Signed-off-by: npub1mn7jgtj4w2pd0g0zeuhxsa6jy6p0rewxz4kujt98my82ahfmp72sxjexk7 <dcfd242e557282d7a1e2cf2e6877522682f1e5c6156dc92ca7d90eaedd3b0f95@sprout-oss.stage.blox.sqprod.co>
Signed-off-by: Will Pfleger <wpfleger@squareup.com>
Signed-off-by: Will Pfleger <pfleger.will@gmail.com>
Co-authored-by: npub1mn7jgtj4w2pd0g0zeuhxsa6jy6p0rewxz4kujt98my82ahfmp72sxjexk7 <dcfd242e557282d7a1e2cf2e6877522682f1e5c6156dc92ca7d90eaedd3b0f95@sprout-oss.stage.blox.sqprod.co>

Author: wpfleger96

crates/buzz-core/src/kind.rs

@@ -91,6 +91,25 @@ pub const KIND_AGENT_PROFILE: u32 = 10100;
 /// `docs/nips/NIP-AE.md` and [`crate::engram`].
 pub const KIND_AGENT_ENGRAM: u32 = 30174;
 
+/// NIP-ER: Event Reminder (parameterized replaceable, author-only).
+///
+/// Encrypted, author-only reminder addressed by `(pubkey, kind, d_tag)`. The
+/// public `not_before` tag tells supporting relays when the reminder is due;
+/// the target, note, and state are NIP-44 encrypted to the author. Reads are
+/// author-only (see [`AUTHOR_ONLY_KINDS`]). See `docs/nips/NIP-ER.md`.
+pub const KIND_EVENT_REMINDER: u32 = 30300;
+
+/// Kinds whose stored events are readable only by their author.
+///
+/// The relay must never reveal the existence, count, tags, content, schedule,
+/// or search matches of these events to anyone but the authenticated author.
+/// Shared across the ingest write path (NIP-ER `not_before` validation) and the
+/// read path (REQ/COUNT/subscription author-only filtering).
+///
+/// Currently O(1) with a single entry. If this grows past ~4 kinds, convert to
+/// a compile-time bitset or sorted array with binary search for hot-path use.
+pub const AUTHOR_ONLY_KINDS: &[u32] = &[KIND_EVENT_REMINDER];
+
 // NIP-29 group admin events
 /// NIP-29: Add a user to a group.
 pub const KIND_NIP29_PUT_USER: u32 = 9000;
@@ -371,6 +390,7 @@ pub const ALL_KINDS: &[u32] = &[
     KIND_FILE_METADATA,
     KIND_AGENT_PROFILE,
     KIND_AGENT_ENGRAM,
+    KIND_EVENT_REMINDER,
     KIND_NIP29_PUT_USER,
     KIND_NIP29_REMOVE_USER,
     KIND_NIP29_EDIT_METADATA,
@@ -554,6 +574,7 @@ pub fn event_kind_i32(event: &nostr::Event) -> i32 {
 // Compile-time: new kinds are in the expected ranges.
 const _: () = assert!(is_replaceable(KIND_AGENT_PROFILE)); // 10100 ∈ 10000–19999
 const _: () = assert!(is_parameterized_replaceable(KIND_WORKFLOW_DEF)); // 30620 ∈ 30000–39999
+const _: () = assert!(is_parameterized_replaceable(KIND_EVENT_REMINDER)); // 30300 ∈ 30000–39999
 const _: () = assert!(is_parameterized_replaceable(KIND_MESH_LLM_RELAY_STATUS)); // 30621 ∈ 30000–39999
 const _: () = assert!(is_parameterized_replaceable(KIND_DM_VISIBILITY)); // 30622 ∈ 30000–39999
 

crates/buzz-pubsub/src/lib.rs

@@ -100,6 +100,20 @@ impl PubSubManager {
     }
 
     /// Publish an event to the Redis channel. Returns subscriber count.
+    ///
+    /// Routing note (NIP-ER author-private reminders): events are keyed by
+    /// `channel_id` (`buzz:channel:{id}`), and every relay node's subscriber
+    /// `PSUBSCRIBE buzz:channel:*` — so the channel key is a routing label, not
+    /// an isolation boundary; every node already receives every published event.
+    /// Author-private reminders (kind:30300, stored under the nil channel
+    /// sentinel) are therefore NOT protected by per-author Redis routing, and
+    /// adding it would be pointless: the reminder's author may be connected to
+    /// any node, so every node must still receive it. The actual author-only
+    /// delivery boundary is `filter_fanout_by_access` in the relay, which runs
+    /// on BOTH the in-process and the Redis cross-node (`subscribe_local`)
+    /// fan-out paths and drops every recipient that is not the event author.
+    /// Redis only ever carries events between nodes inside the relay trust
+    /// domain; the ciphertext is NIP-44-encrypted to the author regardless.
     pub async fn publish_event(
         &self,
         channel_id: Uuid,

crates/buzz-relay/src/api/bridge.rs

@@ -282,6 +282,12 @@ pub async fn query_events(
             "restricted: agent-engram reads require authors=[self] or #p=[self]",
         ));
     }
+    if !crate::handlers::req::author_only_filters_authorized(&filters, &authed_pubkey_hex) {
+        return Err(api_error(
+            StatusCode::FORBIDDEN,
+            "restricted: author-only kinds require authors=[self]",
+        ));
+    }
 
     // Get channels this user can access — same enforcement as WS REQ handler.
     let accessible_channels = state
@@ -291,8 +297,14 @@ pub async fn query_events(
 
     // ── NIP-50 search: route to Typesense if any filter has a `search` field ──
     if filters.iter().any(|f| f.search.is_some()) {
-        return handle_bridge_search(&state, &filters, &accessible_channels, &authed_pubkey_hex)
-            .await;
+        return handle_bridge_search(
+            &state,
+            &filters,
+            &accessible_channels,
+            &authed_pubkey_hex,
+            &pubkey_bytes,
+        )
+        .await;
     }
 
     // ── Presence: synthesize kind:20001 from Redis (ephemeral, never in DB) ──
@@ -472,6 +484,9 @@ pub async fn query_events(
                     ) {
                         continue;
                     }
+                    if crate::handlers::req::is_author_only_event(&se.event, &pubkey_bytes) {
+                        continue;
+                    }
                     if let Ok(v) = serde_json::to_value(&se.event) {
                         events.push(v);
                     }
@@ -528,6 +543,12 @@ pub async fn count_events(
             "restricted: agent-engram reads require authors=[self] or #p=[self]",
         ));
     }
+    if !crate::handlers::req::author_only_filters_authorized(&filters, &authed_pubkey_hex) {
+        return Err(api_error(
+            StatusCode::FORBIDDEN,
+            "restricted: author-only kinds require authors=[self]",
+        ));
+    }
 
     // Get channels this user can access.
     let accessible_channels = state
@@ -537,6 +558,9 @@ pub async fn count_events(
 
     let mut total: u64 = 0;
     for filter in &filters {
+        let needs_author_only_filtering =
+            crate::handlers::req::filter_can_match_author_only_kinds(filter);
+
         // If filter targets a specific channel, verify access.
         if let Some(ch_id) = extract_channel_from_filter(filter) {
             if !accessible_channels.contains(&ch_id) {
@@ -546,7 +570,15 @@ pub async fn count_events(
             let query =
                 crate::handlers::req::build_event_query_from_filter(filter, &pubkey_bytes, &state)
                     .await;
-            if crate::handlers::req::filter_fully_pushable(filter) {
+            let author_is_self = filter.authors.as_ref().is_some_and(|authors| {
+                !authors.is_empty()
+                    && authors
+                        .iter()
+                        .all(|a| a.to_hex().eq_ignore_ascii_case(&authed_pubkey_hex))
+            });
+            if crate::handlers::req::filter_fully_pushable(filter)
+                && (!needs_author_only_filtering || author_is_self)
+            {
                 match state.db.count_events(&query).await {
                     Ok(n) => total += n as u64,
                     Err(e) => {
@@ -561,9 +593,15 @@ pub async fn count_events(
                 match state.db.query_events(&q).await {
                     Ok(stored_events) => {
                         for se in stored_events {
-                            if buzz_core::filter::filters_match(std::slice::from_ref(filter), &se) {
-                                total += 1;
+                            if !buzz_core::filter::filters_match(std::slice::from_ref(filter), &se)
+                            {
+                                continue;
                             }
+                            if crate::handlers::req::is_author_only_event(&se.event, &pubkey_bytes)
+                            {
+                                continue;
+                            }
+                            total += 1;
                         }
                     }
                     Err(e) => {
@@ -579,7 +617,15 @@ pub async fn count_events(
                     .await;
             query.channel_ids = Some(accessible_channels.to_vec());
 
-            if crate::handlers::req::filter_fully_pushable(filter) {
+            let author_is_self = filter.authors.as_ref().is_some_and(|authors| {
+                !authors.is_empty()
+                    && authors
+                        .iter()
+                        .all(|a| a.to_hex().eq_ignore_ascii_case(&authed_pubkey_hex))
+            });
+            if crate::handlers::req::filter_fully_pushable(filter)
+                && (!needs_author_only_filtering || author_is_self)
+            {
                 query.limit = None;
                 match state.db.count_events(&query).await {
                     Ok(n) => total += n as u64,
@@ -594,9 +640,15 @@ pub async fn count_events(
                 match state.db.query_events(&query).await {
                     Ok(stored_events) => {
                         for se in stored_events {
-                            if buzz_core::filter::filters_match(std::slice::from_ref(filter), &se) {
-                                total += 1;
+                            if !buzz_core::filter::filters_match(std::slice::from_ref(filter), &se)
+                            {
+                                continue;
+                            }
+                            if crate::handlers::req::is_author_only_event(&se.event, &pubkey_bytes)
+                            {
+                                continue;
                             }
+                            total += 1;
                         }
                     }
                     Err(e) => {
@@ -651,6 +703,7 @@ async fn handle_bridge_search(
     filters: &[nostr::Filter],
     accessible_channels: &[uuid::Uuid],
     reader_pubkey_hex: &str,
+    pubkey_bytes: &[u8],
 ) -> Result<Json<Value>, (StatusCode, Json<Value>)> {
     // Bridge always includes global (non-channel) events — same as WS with full scopes.
     let channel_scope = match crate::handlers::req::build_search_channel_scope_filter(
@@ -766,6 +819,9 @@ async fn handle_bridge_search(
             if !search_hit_accepted(filter, stored, accessible_channels, reader_pubkey_hex) {
                 continue;
             }
+            if crate::handlers::req::is_author_only_event(&stored.event, pubkey_bytes) {
+                continue;
+            }
             // Dedup across filters.
             if !seen_ids.insert(id_array) {
                 continue;

crates/buzz-relay/src/handlers/count.rs

@@ -6,6 +6,7 @@ use nostr::Filter;
 use tracing::warn;
 
 use crate::connection::{AuthState, ConnectionState};
+use crate::handlers::req::is_author_only_event;
 use crate::protocol::RelayMessage;
 use crate::state::AppState;
 
@@ -61,6 +62,13 @@ pub async fn handle_count(
         ));
         return;
     }
+    if !super::req::author_only_filters_authorized(&filters, &authed_pubkey_hex) {
+        conn.send(RelayMessage::closed(
+            &sub_id,
+            "restricted: author-only kinds require authors=[self]",
+        ));
+        return;
+    }
 
     // Get channels this user can access — same enforcement as WS REQ handler.
     let accessible_channels = match state.get_accessible_channel_ids_cached(&pubkey_bytes).await {
@@ -75,6 +83,11 @@ pub async fn handle_count(
     // For each filter, count matching events with channel access enforcement.
     let mut total: u64 = 0;
     for filter in &filters {
+        // Determine if this filter can match author-only kinds — if so, the
+        // fast-path count_events() cannot be used because it doesn't do
+        // per-event author filtering.
+        let needs_author_only_filtering = super::req::filter_can_match_author_only_kinds(filter);
+
         if let Some(ch_id) = extract_channel_from_filter(filter) {
             // Filter targets a specific channel — verify access.
             if !accessible_channels.contains(&ch_id) {
@@ -83,7 +96,15 @@ pub async fn handle_count(
             // Channel is accessible — count with pushability check.
             let query =
                 super::req::build_event_query_from_filter(filter, &pubkey_bytes, &state).await;
-            if super::req::filter_fully_pushable(filter) {
+            let author_is_self = filter.authors.as_ref().is_some_and(|authors| {
+                !authors.is_empty()
+                    && authors
+                        .iter()
+                        .all(|a| a.to_hex().eq_ignore_ascii_case(&authed_pubkey_hex))
+            });
+            if super::req::filter_fully_pushable(filter)
+                && (!needs_author_only_filtering || author_is_self)
+            {
                 match state.db.count_events(&query).await {
                     Ok(n) => total += n as u64,
                     Err(e) => {
@@ -99,9 +120,14 @@ pub async fn handle_count(
                 match state.db.query_events(&q).await {
                     Ok(stored_events) => {
                         for se in stored_events {
-                            if buzz_core::filter::filters_match(std::slice::from_ref(filter), &se) {
-                                total += 1;
+                            if !buzz_core::filter::filters_match(std::slice::from_ref(filter), &se)
+                            {
+                                continue;
                             }
+                            if is_author_only_event(&se.event, &pubkey_bytes) {
+                                continue;
+                            }
+                            total += 1;
                         }
                     }
                     Err(e) => {
@@ -121,7 +147,15 @@ pub async fn handle_count(
                 super::req::build_event_query_from_filter(filter, &pubkey_bytes, &state).await;
             query.channel_ids = Some(accessible_channels.to_vec());
 
-            if super::req::filter_fully_pushable(filter) {
+            let author_is_self = filter.authors.as_ref().is_some_and(|authors| {
+                !authors.is_empty()
+                    && authors
+                        .iter()
+                        .all(|a| a.to_hex().eq_ignore_ascii_case(&authed_pubkey_hex))
+            });
+            if super::req::filter_fully_pushable(filter)
+                && (!needs_author_only_filtering || author_is_self)
+            {
                 query.limit = None; // COUNT doesn't need a row limit
                 match state.db.count_events(&query).await {
                     Ok(n) => total += n as u64,
@@ -137,9 +171,14 @@ pub async fn handle_count(
                 match state.db.query_events(&query).await {
                     Ok(stored_events) => {
                         for se in stored_events {
-                            if buzz_core::filter::filters_match(std::slice::from_ref(filter), &se) {
-                                total += 1;
+                            if !buzz_core::filter::filters_match(std::slice::from_ref(filter), &se)
+                            {
+                                continue;
+                            }
+                            if is_author_only_event(&se.event, &pubkey_bytes) {
+                                continue;
                             }
+                            total += 1;
                         }
                     }
                     Err(e) => {