feat: Move to fully connected network

platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/gossip/SyncGossip.java

@@ -193,9 +193,9 @@ protected SyncGossip(
         final ThreadConfig threadConfig = platformContext.getConfiguration().getConfigData(ThreadConfig.class);
 
         final BasicConfig basicConfig = platformContext.getConfiguration().getConfigData(BasicConfig.class);
-
-        topology = new StaticTopology(random, addressBook, selfId, basicConfig.numConnections());
         final List<PeerInfo> peers = Utilities.createPeerInfoList(addressBook, selfId);
+
+        topology = new StaticTopology(random, peers, selfId, basicConfig.numConnections());
         final NetworkPeerIdentifier peerIdentifier = new NetworkPeerIdentifier(platformContext, peers);
         final SocketFactory socketFactory =
                 NetworkUtils.createSocketFactory(selfId, peers, keysAndCerts, platformContext.getConfiguration());

platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/OutboundConnectionManager.java

@@ -22,6 +22,7 @@
 import com.swirlds.common.threading.locks.locked.LockedResource;
 import com.swirlds.platform.network.connection.NotConnectedConnection;
 import com.swirlds.platform.network.connectivity.OutboundConnectionCreator;
+import java.util.Objects;
 
 /**
  * Manages a connection that is initiated by this node. If the connection in use is broken, it will try to establish a
@@ -46,7 +47,7 @@ public OutboundConnectionManager(final NodeId peerId, final OutboundConnectionCr
     @Override
     public Connection waitForConnection() {
         try (final LockedResource<Connection> resource = lock.lock()) {
-            while (!resource.getResource().connected()) {
+            while (!Objects.requireNonNull(resource.getResource()).connected()) {
                 resource.getResource().disconnect();
                 resource.setResource(connectionCreator.createConnection(peerId));
             }

platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/topology/NetworkTopology.java

@@ -18,8 +18,7 @@
 
 import com.swirlds.common.platform.NodeId;
 import com.swirlds.platform.network.RandomGraph;
-import java.util.List;
-import java.util.function.Predicate;
+import java.util.Set;
 
 /**
  * Holds information about the topology of the network
@@ -44,14 +43,9 @@ public interface NetworkTopology {
     boolean shouldConnectToMe(NodeId nodeId);
 
     /**
-     * @return a list of all peers this node should be connected to
+     * @return a Set of all peers this node should be connected to
      */
-    List<NodeId> getNeighbors();
-
-    /**
-     * @return a list of peers this node should be connected to with the applied filter
-     */
-    List<NodeId> getNeighbors(final Predicate<NodeId> filter);
+    Set<NodeId> getNeighbors();
 
     /**
      * @return the underlying graph on which this topology is based on

platform-sdk/swirlds-platform-core/src/main/java/com/swirlds/platform/network/topology/StaticTopology.java

@@ -17,78 +17,64 @@
 package com.swirlds.platform.network.topology;
 
 import com.swirlds.common.platform.NodeId;
+import com.swirlds.platform.network.PeerInfo;
 import com.swirlds.platform.network.RandomGraph;
-import com.swirlds.platform.system.address.AddressBook;
 import edu.umd.cs.findbugs.annotations.NonNull;
-import java.util.Arrays;
+import java.util.HashMap;
 import java.util.List;
-import java.util.Objects;
+import java.util.Map;
 import java.util.Random;
-import java.util.function.Predicate;
+import java.util.Set;
 
 /**
  * A bidirectional topology that never changes.
  */
 public class StaticTopology implements NetworkTopology {
     private static final long SEED = 0;
 
-    private final NodeId selfId;
+    /** nodes are mapped so lookups are efficient. **/
+    private Map<NodeId, Long> peerNodeToIdMap = new HashMap<>();
+
     /**
-     * Two nodes are neighbors if their indexes in the address book are neighbors in the connection graph.
+     * Two nodes are neighbors if their node indexes are neighbors in the connection graph.
      */
-    private final AddressBook addressBook;
-
     private final RandomGraph connectionGraph;
 
+    private final NodeId selfId;
+
     /**
      * Constructor.
      *
      * @param random            a source of randomness, used to chose random neighbors, does not need to be
      *                          cryptographically secure
-     * @param addressBook       the current address book
+     * @param peers             the set of peers in the network
      * @param selfId            the ID of this node
      * @param numberOfNeighbors the number of neighbors each node should have
      */
     public StaticTopology(
             @NonNull final Random random,
-            @NonNull final AddressBook addressBook,
+            @NonNull final List<PeerInfo> peers,
             @NonNull final NodeId selfId,
             final int numberOfNeighbors) {
-        this.addressBook = Objects.requireNonNull(addressBook, "addressBook must not be null");
-        this.selfId = Objects.requireNonNull(selfId, "selfId must not be null");
-        this.connectionGraph = new RandomGraph(random, addressBook.getSize(), numberOfNeighbors, SEED);
-
-        if (!addressBook.contains(selfId)) {
-            throw new IllegalArgumentException("Address book does not contain selfId");
-        }
-    }
-
-    /**
-     * {@inheritDoc}
-     */
-    @Override
-    public List<NodeId> getNeighbors() {
-        return getNeighbors((nodeId -> true));
+        this.peerNodeToIdMap = map(peers);
+        this.selfId = selfId;
+        this.connectionGraph = new RandomGraph(random, peers.size() + 1, numberOfNeighbors, SEED);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
-    public List<NodeId> getNeighbors(final Predicate<NodeId> filter) {
-        final int selfIndex = addressBook.getIndexOfNodeId(selfId);
-        return Arrays.stream(connectionGraph.getNeighbors(selfIndex))
-                .mapToObj(addressBook::getNodeId)
-                .filter(filter)
-                .toList();
+    public Set<NodeId> getNeighbors() {
+        return peerNodeToIdMap.keySet();
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean shouldConnectToMe(final NodeId nodeId) {
-        return isNeighbor(nodeId) && addressBook.getIndexOfNodeId(nodeId) < addressBook.getIndexOfNodeId(selfId);
+        return isNeighbor(nodeId) && nodeId.id() < selfId.id();
     }
 
     /**
@@ -98,20 +84,15 @@ public boolean shouldConnectToMe(final NodeId nodeId) {
      * @return true if this node is my neighbor, false if not
      */
     private boolean isNeighbor(final NodeId nodeId) {
-        if (!addressBook.contains(nodeId)) {
-            return false;
-        }
-        final int selfIndex = addressBook.getIndexOfNodeId(selfId);
-        final int nodeIndex = addressBook.getIndexOfNodeId(nodeId);
-        return connectionGraph.isAdjacent(selfIndex, nodeIndex);
+        return peerNodeToIdMap.containsKey(nodeId);
     }
 
     /**
      * {@inheritDoc}
      */
     @Override
     public boolean shouldConnectTo(final NodeId nodeId) {
-        return isNeighbor(nodeId) && addressBook.getIndexOfNodeId(nodeId) > addressBook.getIndexOfNodeId(selfId);
+        return isNeighbor(nodeId) && nodeId.id() > selfId.id();
     }
 
     /**
@@ -121,4 +102,19 @@ public boolean shouldConnectTo(final NodeId nodeId) {
     public RandomGraph getConnectionGraph() {
         return connectionGraph;
     }
+
+    /**
+     * Maps the list of peers to a map of node IDs to their index in the peer list
+     * and populates the peerNodesList with the node IDs
+     *
+     * @param peers the list of peers
+     * @return the map of node IDs to their peer Id
+     */
+    @NonNull
+    private Map<NodeId, Long> map(@NonNull final List<PeerInfo> peers) {
+        for (final PeerInfo peer : peers) {
+            peerNodeToIdMap.put(peer.nodeId(), peer.nodeId().id());
+        }
+        return peerNodeToIdMap;
+    }
 }

platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/network/StaticConnectionManagersTest.java

@@ -24,9 +24,12 @@
 
 import com.swirlds.common.platform.NodeId;
 import com.swirlds.common.test.fixtures.RandomUtils;
+import com.swirlds.platform.Utilities;
 import com.swirlds.platform.network.Connection;
 import com.swirlds.platform.network.ConnectionManager;
+import com.swirlds.platform.network.PeerInfo;
 import com.swirlds.platform.network.connectivity.OutboundConnectionCreator;
+import com.swirlds.platform.network.topology.NetworkTopology;
 import com.swirlds.platform.network.topology.StaticConnectionManagers;
 import com.swirlds.platform.network.topology.StaticTopology;
 import com.swirlds.platform.system.address.AddressBook;
@@ -57,9 +60,12 @@ void testShouldConnectToMe(final int numNodes, final int numNeighbors) throws Ex
         final AddressBook addressBook =
                 new RandomAddressBookGenerator(r).setSize(numNodes).build();
         final NodeId selfId = addressBook.getNodeId(r.nextInt(numNodes));
-        final StaticTopology topology = new StaticTopology(r, addressBook, selfId, numNeighbors);
+
+        final List<PeerInfo> peers = Utilities.createPeerInfoList(addressBook, selfId);
+        final NetworkTopology topology = new StaticTopology(r, peers, selfId, numNeighbors);
+
         final StaticConnectionManagers managers = new StaticConnectionManagers(topology, connectionCreator);
-        final List<NodeId> neighbors = topology.getNeighbors();
+        final List<NodeId> neighbors = topology.getNeighbors().stream().toList();
         final NodeId neighbor = neighbors.get(r.nextInt(neighbors.size()));
 
         if (topology.shouldConnectToMe(neighbor)) {
@@ -90,9 +96,11 @@ void testShouldConnectTo(final int numNodes, final int numNeighbors) throws Exce
         final AddressBook addressBook =
                 new RandomAddressBookGenerator(r).setSize(numNodes).build();
         final NodeId selfId = addressBook.getNodeId(r.nextInt(numNodes));
-        final StaticTopology topology = new StaticTopology(r, addressBook, selfId, numNeighbors);
+        final List<PeerInfo> peers = Utilities.createPeerInfoList(addressBook, selfId);
+        final NetworkTopology topology = new StaticTopology(r, peers, selfId, numNeighbors);
+
         final StaticConnectionManagers managers = new StaticConnectionManagers(topology, connectionCreator);
-        final List<NodeId> neighbors = topology.getNeighbors();
+        final List<NodeId> neighbors = topology.getNeighbors().stream().toList();
         final NodeId neighbor = neighbors.get(r.nextInt(neighbors.size()));
 
         if (topology.shouldConnectTo(neighbor)) {

platform-sdk/swirlds-unit-tests/core/swirlds-platform-test/src/test/java/com/swirlds/platform/test/network/TopologyTest.java

@@ -22,6 +22,8 @@
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 import com.swirlds.common.platform.NodeId;
+import com.swirlds.platform.Utilities;
+import com.swirlds.platform.network.PeerInfo;
 import com.swirlds.platform.network.RandomGraph;
 import com.swirlds.platform.network.topology.NetworkTopology;
 import com.swirlds.platform.network.topology.StaticTopology;
@@ -34,6 +36,7 @@
 import java.util.Objects;
 import java.util.Random;
 import java.util.Set;
+import java.util.stream.Collectors;
 import java.util.stream.IntStream;
 import java.util.stream.Stream;
 import org.junit.jupiter.params.ParameterizedTest;
@@ -124,12 +127,15 @@ void testFullyConnectedTopology(final int numNodes, final int numNeighbors, fina
             final NodeId outOfBoundsId = addressBook.getNextNodeId();
             final NodeId thisNodeId = addressBook.getNodeId(thisNode);
             final Random random = getRandomPrintSeed();
-            final NetworkTopology topology = new StaticTopology(random, addressBook, thisNodeId, numNeighbors);
-            final List<NodeId> neighbors = topology.getNeighbors();
-            final List<NodeId> expected = IntStream.range(0, numNodes)
+
+            final List<PeerInfo> peers = Utilities.createPeerInfoList(addressBook, thisNodeId);
+
+            final NetworkTopology topology = new StaticTopology(random, peers, thisNodeId, numNeighbors);
+            final Set<NodeId> neighbors = topology.getNeighbors();
+            final Set<NodeId> expected = IntStream.range(0, numNodes)
                     .mapToObj(addressBook::getNodeId)
                     .filter(nodeId -> !Objects.equals(thisNodeId, nodeId))
-                    .toList();
+                    .collect(Collectors.toSet());
             assertEquals(expected, neighbors, "all should be neighbors except me");
             for (final NodeId neighbor : neighbors) {
                 assertTrue(