tangle

commit dadd67536a5b7fc6e0b24666db1a8b6eb3d39a1f
parent bc9481e065a652aa0d3486e296454b35d5073ae3
Author: triesap <tyson@radroots.org>
Date:   Sun, 14 Jun 2026 16:27:34 -0700

runtime: use shared group read gates

Diffstat:
M
crates/tangle_runtime/src/relay/core.rs
 | 
16
++--------------
M
crates/tangle_runtime/src/runtime.rs
 | 
24
+++++++++++++++---------
M
crates/tangle_runtime/tests/phase2_acceptance_targets.rs
 | 
9
++++++++-

3 files changed, 25 insertions(+), 24 deletions(-)
diff --git a/crates/tangle_runtime/src/relay/core.rs b/crates/tangle_runtime/src/relay/core.rs
@@ -614,8 +614,8 @@ impl BaseRelay {
         self.groups.as_ref().map(GroupServiceHandle::projection)
     }
 
-    pub(crate) fn group_service(&self) -> Option<&GroupServiceHandle> {
-        self.groups.as_ref()
+    pub(crate) fn group_service_handle(&self) -> Option<GroupServiceHandle> {
+        self.groups.clone()
     }
 
     pub(crate) fn group_outbox_pending_events(&self) -> usize {
@@ -1037,18 +1037,6 @@ impl BaseRelay {
             .unwrap_or(Ok(true))
             .map_err(BaseRelayError::from)
     }
-
-    pub(crate) fn fanout_offset(
-        &self,
-        offset: StoreOffset,
-        subscriptions: &mut LiveSubscriptionSet,
-    ) -> Result<Vec<RelayMessage>, BaseRelayError> {
-        let event = self.event_by_offset(offset)?;
-        let groups = self.groups.as_ref();
-        Ok(subscriptions.fanout(&event, |event, auth| {
-            Self::group_read_gate_visible_to_auth(groups, event, auth).unwrap_or(false)
-        }))
-    }
 }
 
 #[cfg(test)]
diff --git a/crates/tangle_runtime/src/runtime.rs b/crates/tangle_runtime/src/runtime.rs
@@ -4,6 +4,7 @@ use crate::{
     config::BaseRelayRuntimeConfig,
     errors::BaseRelayError,
     event_bus::{TangleEventBus, TangleEventReceiver},
+    groups::GroupServiceHandle,
     logging,
     ops::{BaseRelayReadinessHandle, BaseRelayReadinessState},
     pocket_conversion::pocket_event_to_tangle,
@@ -155,6 +156,7 @@ impl TangleRuntime {
 struct TangleRuntimeShared {
     config: Arc<BaseRelayRuntimeConfig>,
     store: PocketStoreHandle,
+    groups: Option<GroupServiceHandle>,
     relay: Mutex<BaseRelay>,
     readiness: BaseRelayReadinessHandle,
     limits: TangleRuntimeLimits,
@@ -177,9 +179,11 @@ impl TangleRuntimeShared {
             shutdown,
         } = runtime;
         let store = relay.store_handle();
+        let groups = relay.group_service_handle();
         Self {
             config: Arc::new(config),
             store,
+            groups,
             relay: Mutex::new(relay),
             readiness,
             limits,
@@ -823,10 +827,11 @@ impl TangleRuntimeHandle {
         let pocket_event = self.inner.store.event_by_offset(offset.as_u64())?;
         let event = pocket_event_to_tangle(&pocket_event)?;
         let group_auth = GroupAuthContext::new(auth.authenticated_pubkeys().iter().cloned());
-        let visible = {
-            let relay = self.inner.relay.lock().await;
-            BaseRelay::group_read_gate_visible_to_auth(relay.group_service(), &event, &group_auth)?
-        };
+        let visible = BaseRelay::group_read_gate_visible_to_auth(
+            self.inner.groups.as_ref(),
+            &event,
+            &group_auth,
+        )?;
         if !visible {
             self.inner.metrics.record_group_read_denial();
             return Ok(None);
@@ -839,11 +844,12 @@ impl TangleRuntimeHandle {
         offset: StoreOffset,
         subscriptions: &mut LiveSubscriptionSet,
     ) -> Result<Vec<RelayMessage>, BaseRelayError> {
-        self.inner
-            .relay
-            .lock()
-            .await
-            .fanout_offset(offset, subscriptions)
+        let pocket_event = self.inner.store.event_by_offset(offset.as_u64())?;
+        let event = pocket_event_to_tangle(&pocket_event)?;
+        Ok(subscriptions.fanout(&event, |event, auth| {
+            BaseRelay::group_read_gate_visible_to_auth(self.inner.groups.as_ref(), event, auth)
+                .unwrap_or(false)
+        }))
     }
 
     pub async fn shutdown(&self) -> Result<BaseRelayShutdownReport, BaseRelayError> {
diff --git a/crates/tangle_runtime/tests/phase2_acceptance_targets.rs b/crates/tangle_runtime/tests/phase2_acceptance_targets.rs
@@ -1298,6 +1298,7 @@ fn closed_groups_use_strict_nip29_semantics_without_compatibility_flag() {
 #[test]
 fn req_count_and_live_fanout_share_one_group_read_gate() {
     let relay_core = include_str!("../src/relay/core.rs");
+    let runtime = include_str!("../src/runtime.rs");
 
     assert_eq!(
         relay_core
@@ -1309,7 +1310,13 @@ fn req_count_and_live_fanout_share_one_group_read_gate() {
         relay_core
             .matches("Self::group_read_gate_visible_to_auth")
             .count(),
-        4
+        3
+    );
+    assert_eq!(
+        runtime
+            .matches("BaseRelay::group_read_gate_visible_to_auth")
+            .count(),
+        2
     );
     assert!(!relay_core.contains("fn event_visible_to_auth("));
     assert!(!relay_core.contains("fn pocket_event_visible_to_auth("));