From 5fd686dcd8ddfbdf276c044e5acf03f744e03193 Mon Sep 17 00:00:00 2001
From: tv <tv@krebsco.de>
Date: Tue, 27 Oct 2026 01:01:51 +0100
Subject: introduce addresses

---
 src/swarm/peer/handshake.rs | 28 +++++++++++++++++++++++++---
 1 file changed, 25 insertions(+), 3 deletions(-)

(limited to 'src/swarm/peer')

diff --git a/src/swarm/peer/handshake.rs b/src/swarm/peer/handshake.rs
index 4c657ad..4a7f451 100644
--- a/src/swarm/peer/handshake.rs
+++ b/src/swarm/peer/handshake.rs
@@ -19,6 +19,9 @@ use crate::transport::{self, ParsedMessage};
 /// costs the recipient as much as it is long. A joining node needs only a few to find
 /// the swarm; the member list gives it the rest once it is ready.
 const MAX_LISTED_PEERS: usize = 64;
+/// Addresses of one peer listed in a HELLO_REPLY, at most (a node has one per transport,
+/// so a few).
+const MAX_LISTED_ADDRESSES: usize = 8;
 
 pub(crate) async fn remember_peer(state: &AppState, peer: &str) {
     if peer.is_empty() {
@@ -202,6 +205,17 @@ pub(super) async fn send_hello_reply(
         peers.sort_by_cached_key(|known| topology::pair_score(peer, known));
         peers.truncate(MAX_LISTED_PEERS);
     }
+    let peers = peers
+        .into_iter()
+        .map(|known| {
+            let mut addresses = state.transport.addresses_of(&known);
+            addresses.truncate(MAX_LISTED_ADDRESSES);
+            transport::ListedPeer {
+                id: known,
+                addresses,
+            }
+        })
+        .collect();
 
     let auth = state
         .swarm_key
@@ -237,11 +251,17 @@ pub(super) async fn send_hello_reply(
 /// Greets the peers a HELLO_REPLY listed: at most `MAX_LISTED_PEERS`, only valid
 /// identities, and, once the member list is known, only those that are our neighbours
 /// (it says whom we greet; a listed peer that isn't one would get nothing from us, so
-/// it isn't remembered either).
-pub(super) async fn discover_peers(state: &AppState, from_peer: &str, advertised_peers: &[String]) {
+/// it isn't remembered either). Where the sender reaches them is a hint to the
+/// transport (at most `MAX_LISTED_ADDRESSES` each).
+pub(super) async fn discover_peers(
+    state: &AppState,
+    from_peer: &str,
+    advertised_peers: &[transport::ListedPeer],
+) {
     let view_known = topology::view_known(state);
     let mut taken = 0;
-    for discovered_peer in advertised_peers {
+    for listed in advertised_peers {
+        let discovered_peer = &listed.id;
         if discovered_peer == from_peer || !state.transport.is_peer_id(discovered_peer) {
             continue;
         }
@@ -258,6 +278,8 @@ pub(super) async fn discover_peers(state: &AppState, from_peer: &str, advertised
         }
         taken += 1;
 
+        let addresses = &listed.addresses[..listed.addresses.len().min(MAX_LISTED_ADDRESSES)];
+        state.transport.learn_addresses(discovered_peer, addresses);
         remember_peer(state, discovered_peer).await;
         if let Err(error) = send_hello_once(state, discovered_peer).await {
             warn!(
-- 
cgit v1.3.1