feat: limit and randomize peer discovery to 25 peers (#640)

Implements peer limiting and randomization to improve network peer distribution:
- Limits peer responses to 25 peers (configurable via MAX_PEERS constant)
- Randomizes peer selection on each load/discovery to avoid always returning the same peers
- Updates PeerSnapshotServiceImpl to shuffle and limit peers from snapshot files
- Updates PeerDiscoveryManager to shuffle and limit discovered peers from cardano-node
- Maintains deterministic in-memory cache between refreshes
- Updates tests to reflect new peer limiting and randomization behavior

This prevents excessive peer lists and naturally distributes connections across the network
without needing to track peer performance metrics.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-authored-by: Mateusz Czeladka <mateusz.czeladka@cardanofoundation.org>
Co-authored-by: Claude <noreply@anthropic.com>

Author: 3 people

api/src/main/java/org/cardanofoundation/rosetta/api/network/service/PeerSnapshotServiceImpl.java

@@ -14,6 +14,7 @@
 import java.nio.file.Path;
 import java.nio.file.Paths;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.Map;
 
@@ -25,6 +26,12 @@
 @Slf4j
 public class PeerSnapshotServiceImpl implements PeerSnapshotService {
 
+  /**
+   * Maximum number of peers to return. This limit prevents returning excessive peer lists
+   * and ensures randomization of peer selection rather than always returning the same peers.
+   */
+  private static final int MAX_PEERS = 25;
+
   @Override
   public List<Peer> loadPeersFromSnapshot(@NotNull String peerSnapshotFile, @NotNull String baseDirectory) {
     try {
@@ -70,10 +77,19 @@ private PeerSnapshotConfig parsePeerSnapshot(String snapshotFilePath) throws IOE
   }
 
   private List<Peer> extractPeersFromSnapshot(PeerSnapshotConfig peerSnapshot) {
-    return peerSnapshot.getBigLedgerPools().stream()
+    List<Peer> allPeers = peerSnapshot.getBigLedgerPools().stream()
         .flatMap(pool -> pool.getRelays().stream())
         .map(this::mapRelayToPeer)
         .toList();
+
+    // Shuffle to randomize peer selection and limit to MAX_PEERS
+    // This ensures we don't always return the same peers
+    List<Peer> shuffledPeers = new ArrayList<>(allPeers);
+    Collections.shuffle(shuffledPeers);
+
+    return shuffledPeers.stream()
+        .limit(MAX_PEERS)
+        .toList();
   }
 
   @NotNull

api/src/test/java/org/cardanofoundation/rosetta/api/network/service/PeerSnapshotServiceImplTest.java

@@ -36,7 +36,8 @@ void shouldLoadPeersFromMainnetSnapshot() {
       // then
       assertNotNull(peers);
       assertThat(peers).isNotEmpty();
-      assertThat(peers.size()).isGreaterThan(100); // Mainnet has many big ledger pools
+      assertThat(peers.size()).isLessThanOrEqualTo(25); // Limited to MAX_PEERS (25)
+      assertThat(peers.size()).isEqualTo(25); // Should have exactly 25 peers if snapshot has enough
     }
 
     @Test
@@ -56,11 +57,18 @@ void shouldExtractDomainRelaysCorrectly() {
           })
           .toList();
 
+      // Due to randomization, we can't guarantee specific domains are present
+      // Just verify that domain peers exist and have correct format
       assertThat(domainPeers).isNotEmpty();
 
-      // Verify at least one known domain relay
-      assertThat(domainPeers)
-          .anyMatch(peer -> peer.getPeerId().contains("cardano.figment.io"));
+      domainPeers.forEach(peer -> {
+        // Domain peers should have format address:port
+        assertThat(peer.getPeerId()).contains(":");
+
+        // Metadata should indicate domain type
+        Map<String, Object> metadata = (Map<String, Object>) peer.getMetadata();
+        assertThat(metadata.get("type")).isEqualTo("domain");
+      });
     }
 
     @Test
@@ -182,13 +190,19 @@ void shouldExtractMultipleRelaysFromSinglePool() {
       List<Peer> peers = peerSnapshotService.loadPeersFromSnapshot(peerSnapshotFile, baseDirectory);
 
       // then
-      // Nordic pool has multiple relays (Relay1-6.NordicPool.org)
-      List<Peer> nordicPoolRelays = peers.stream()
-          .filter(peer -> peer.getPeerId().contains("NordicPool.org"))
-          .toList();
+      // Due to randomization, we can't guarantee specific pools are in the selection
+      // Verify we have peers limited to MAX_PEERS
+      assertThat(peers).hasSizeLessThanOrEqualTo(25);
+      assertThat(peers).isNotEmpty();
 
-      assertThat(nordicPoolRelays).isNotEmpty();
-      assertThat(nordicPoolRelays.size()).isGreaterThan(1);
+      // Verify all peers have valid format (address:port)
+      peers.forEach(peer -> {
+        assertThat(peer.getPeerId()).contains(":");
+
+        // All peers should have metadata with type
+        Map<String, Object> metadata = (Map<String, Object>) peer.getMetadata();
+        assertThat(metadata).containsKey("type");
+      });
     }
 
     @Test
@@ -216,15 +230,20 @@ void shouldVerifyKnownMainnetRelays() {
       List<Peer> peers = peerSnapshotService.loadPeersFromSnapshot(peerSnapshotFile, baseDirectory);
 
       // then
-      List<String> peerIds = peers.stream()
-          .map(Peer::getPeerId)
-          .toList();
+      // Due to randomization, we can't guarantee specific relays are present
+      // Instead verify that all peers have valid format and metadata
+      assertThat(peers).isNotEmpty();
+      assertThat(peers.size()).isEqualTo(25);
 
-      // Verify some known mainnet relays exist
-      assertThat(peerIds)
-          .anyMatch(id -> id.contains("cardano.figment.io"))
-          .anyMatch(id -> id.contains("NordicPool.org"))
-          .anyMatch(id -> id.contains("cardanosuisse.com"));
+      peers.forEach(peer -> {
+        // All peers should have a peer ID with port
+        assertThat(peer.getPeerId()).contains(":");
+
+        // All peers should have metadata with type
+        Map<String, Object> metadata = (Map<String, Object>) peer.getMetadata();
+        assertThat(metadata).containsKey("type");
+        assertThat(metadata.get("type")).isIn("domain", "IPv4", "IPv6");
+      });
     }
 
     @Test
@@ -237,9 +256,9 @@ void shouldExtractAllRelaysFromAllPools() {
       List<Peer> peers = peerSnapshotService.loadPeersFromSnapshot(peerSnapshotFile, baseDirectory);
 
       // then
-      // Mainnet snapshot has many pools with multiple relays each
-      // Total should be significantly higher than the number of pools
-      assertThat(peers.size()).isGreaterThan(200);
+      // Peers are now limited to MAX_PEERS (25) and randomized
+      assertThat(peers.size()).isLessThanOrEqualTo(25);
+      assertThat(peers.size()).isEqualTo(25); // Should have exactly 25 peers
     }
 
     @Test
@@ -290,5 +309,31 @@ void shouldVerifyCommonPorts() {
       assertThat(ports)
           .contains("3001", "6000");
     }
+
+    @Test
+    void shouldRandomizePeerSelection() {
+      // given
+      String peerSnapshotFile = "peer-snapshot.json";
+      String baseDirectory = "../config/node/mainnet";
+
+      // when - load peers multiple times
+      List<Peer> firstLoad = peerSnapshotService.loadPeersFromSnapshot(peerSnapshotFile, baseDirectory);
+      List<Peer> secondLoad = peerSnapshotService.loadPeersFromSnapshot(peerSnapshotFile, baseDirectory);
+
+      // then - both should have 25 peers
+      assertThat(firstLoad.size()).isEqualTo(25);
+      assertThat(secondLoad.size()).isEqualTo(25);
+
+      // And they should be different due to randomization (very high probability)
+      // We check if at least 5 peers are different in order
+      long differentPeers = 0;
+      for (int i = 0; i < Math.min(firstLoad.size(), secondLoad.size()); i++) {
+        if (!firstLoad.get(i).getPeerId().equals(secondLoad.get(i).getPeerId())) {
+          differentPeers++;
+        }
+      }
+
+      assertThat(differentPeers).isGreaterThan(5);
+    }
   }
 }

yaci-indexer/src/main/java/org/cardanofoundation/rosetta/yaciindexer/service/PeerDiscoveryManager.java

@@ -9,14 +9,20 @@
 import reactor.core.publisher.Mono;
 
 import java.time.Duration;
+import java.util.ArrayList;
+import java.util.Collections;
 import java.util.List;
 import java.util.concurrent.CopyOnWriteArrayList;
 
 @Service
 @Slf4j
 public class PeerDiscoveryManager {
 
-    public static final int PEERS_REQUEST_AMOUNT = 50;
+    /**
+     * Maximum number of peers to request from the Cardano node and cache.
+     * Limited to avoid excessive peer lists and allow randomization.
+     */
+    public static final int PEERS_REQUEST_AMOUNT = 25;
     public static final int PEERS_REQUEST_TIMEOUT_SECS = 60;
 
     @Value("${store.cardano.host:preprod-node.world.dev.cardano.org}")
@@ -32,10 +38,20 @@ public class PeerDiscoveryManager {
     private final CopyOnWriteArrayList<PeerAddress> cachedPeers = new CopyOnWriteArrayList<>();
 
     public void updateCachedPeers(List<PeerAddress> peers) {
+        // Shuffle to randomize peer selection and limit to PEERS_REQUEST_AMOUNT
+        // This ensures we don't always return the same peers
+        List<PeerAddress> shuffledPeers = new ArrayList<>(peers);
+        Collections.shuffle(shuffledPeers);
+
+        List<PeerAddress> limitedPeers = shuffledPeers.stream()
+            .limit(PEERS_REQUEST_AMOUNT)
+            .toList();
+
         this.cachedPeers.clear();
-        this.cachedPeers.addAll(peers);
+        this.cachedPeers.addAll(limitedPeers);
 
-        log.debug("Updated cached peers: {} peers available", this.cachedPeers.size());
+        log.debug("Updated cached peers: {} peers available (from {} discovered)",
+            this.cachedPeers.size(), peers.size());
     }
 
     public List<PeerAddress> discoverPeers() {

yaci-indexer/src/test/java/org/cardanofoundation/rosetta/yaciindexer/service/PeerDiscoveryManagerTest.java

@@ -62,7 +62,8 @@ void shouldUpdateCachedPeers() {
             // Then
             List<PeerAddress> cachedPeers = peerDiscoveryManager.getCachedPeers();
             assertThat(cachedPeers).hasSize(3);
-            assertThat(cachedPeers).containsExactlyElementsOf(newPeers);
+            // Peers are shuffled, so we can't check for exact order
+            assertThat(cachedPeers).containsExactlyInAnyOrderElementsOf(newPeers);
         }
 
         @Test
@@ -85,7 +86,8 @@ void shouldClearAndReplaceExistingPeers() {
             // Then
             List<PeerAddress> cachedPeers = peerDiscoveryManager.getCachedPeers();
             assertThat(cachedPeers).hasSize(2);
-            assertThat(cachedPeers).containsExactlyElementsOf(newPeers);
+            // Peers are shuffled, so we can't check for exact order
+            assertThat(cachedPeers).containsExactlyInAnyOrderElementsOf(newPeers);
             assertThat(cachedPeers).doesNotContainAnyElementsOf(initialPeers);
         }