1 files changed, 46 insertions, 10 deletions

diff --git a/src/swarm/relay.rs b/src/swarm/relay.rs
index 1736cec..5ab93f2 100644
--- a/src/swarm/relay.rs
+++ b/src/swarm/relay.rs
@@ -16,7 +16,10 @@
 //! message would announce to every neighbour, and announcements would outnumber the
 //! data they announce (about 15 to 1 at 250 nodes).
 //!
-//! In a full mesh the writer reaches everyone itself, so nothing is announced.
+//! In a full mesh the writer reaches everyone itself, so nothing is announced, but to
+//! the neighbours the writer can't reach: those on none of its transports (a member on
+//! Tor alone, reached through one on Tor and libp2p, from a writer on libp2p alone).
+//! Whom it reaches is what the member list makes its neighbours (`topology::neighbours_of`).
 
 use std::collections::{HashMap, HashSet};
 use std::sync::atomic::Ordering;
@@ -44,7 +47,11 @@ pub(crate) async fn announce(state: &AppState, from: &str) {
     // While the view is unknown everyone counts as a neighbour, but that isn't a full
     // mesh: the others may not hear from the writer.
     if !state.initial_sync_done.load(Ordering::Acquire)
-        || (topology::view_known(state) && topology::is_full_mesh(state))
+        || (topology::view_known(state)
+            && topology::is_full_mesh(state)
+            && unreached(state, &HashSet::from([from.to_owned()]))
+                .await
+                .is_empty())
     {
         return;
     }
@@ -80,26 +87,55 @@ pub(crate) async fn announce(state: &AppState, from: &str) {
 /// round with a single sender skips it; with several, each lacks the others' changes,
 /// so every neighbour is told.
 async fn announce_now(state: &AppState, senders: &HashSet<String>) {
+    let neighbours = unreached(state, senders).await;
+    if neighbours.is_empty() {
+        return;
+    }
     state.stats.announce_round();
+    for peer in neighbours {
+        if let Err(error) = send_status(state, &peer).await {
+            debug!(peer = %peer, error = %format!("{error:#}"), "Announcing our heads failed");
+        }
+    }
+}
+
+/// The neighbours to tell of the changes `senders` sent us. The peer whose changes we
+/// announce has them already, so with a single sender it is skipped; with several, each
+/// lacks the others' changes. In a full mesh, also those every sender is a neighbour of:
+/// the writers reached them themselves.
+async fn unreached(state: &AppState, senders: &HashSet<String>) -> Vec<String> {
     let skip = match senders.len() {
         1 => senders.iter().next().cloned(),
         _ => None,
     };
-    let neighbours: Vec<String> = state
+    let full_mesh = topology::view_known(state) && topology::is_full_mesh(state);
+    // Unknown (a sender not in the member list): nobody counts as reached by it.
+    let reached: Vec<Option<std::collections::BTreeSet<String>>> = if full_mesh {
+        senders
+            .iter()
+            .map(|sender| topology::neighbours_of(state, sender))
+            .collect()
+    } else {
+        Vec::new()
+    };
+    let reached_by_all = |peer: &str| {
+        full_mesh
+            && reached.iter().zip(senders).all(|(neighbours, sender)| {
+                sender == peer || neighbours.as_ref().is_some_and(|n| n.contains(peer))
+            })
+    };
+    state
         .peer_states
         .read()
         .await
         .keys()
         .filter(|peer| {
-            skip.as_deref() != Some(peer.as_str()) && topology::is_neighbour(state, peer)
+            skip.as_deref() != Some(peer.as_str())
+                && topology::is_neighbour(state, peer)
+                && !reached_by_all(peer)
         })
         .cloned()
-        .collect();
-    for peer in neighbours {
-        if let Err(error) = send_status(state, &peer).await {
-            debug!(peer = %peer, error = %format!("{error:#}"), "Announcing our heads failed");
-        }
-    }
+        .collect()
 }
 
 /// Pulls in progress: one neighbour at a time, so each change arrives about once. The