@waku/core 0.0.26-7eb3375.0 → 0.0.27

package/src/lib/base_protocol.ts

@@ -1,13 +1,23 @@
 import type { Libp2p } from "@libp2p/interface";
-import type { Stream } from "@libp2p/interface/connection";
-import type { PeerId } from "@libp2p/interface/peer-id";
-import { Peer, PeerStore } from "@libp2p/interface/peer-store";
-import type { IBaseProtocol, Libp2pComponents } from "@waku/interfaces";
-import { getPeersForProtocol, selectPeerForProtocol } from "@waku/utils/libp2p";
+import type { Peer, PeerStore, Stream } from "@libp2p/interface";
+import type {
+  IBaseProtocol,
+  Libp2pComponents,
+  ProtocolCreateOptions,
+  PubsubTopic
+} from "@waku/interfaces";
+import { ensureShardingConfigured, Logger } from "@waku/utils";
+import {
+  getConnectedPeersForProtocolAndShard,
+  getPeersForProtocol,
+  sortPeersByLatency
+} from "@waku/utils/libp2p";
 
-import { filterPeers } from "./filterPeers.js";
+import { filterPeersByDiscovery } from "./filterPeers.js";
 import { StreamManager } from "./stream_manager.js";
 
+const DEFAULT_NUM_PEERS_TO_USE = 3;
+
 /**
  * A class with predefined helpers, to be used as a base to implement Waku
  * Protocols.
@@ -15,12 +25,18 @@ import { StreamManager } from "./stream_manager.js";
 export class BaseProtocol implements IBaseProtocol {
   public readonly addLibp2pEventListener: Libp2p["addEventListener"];
   public readonly removeLibp2pEventListener: Libp2p["removeEventListener"];
+  readonly numPeersToUse: number;
   protected streamManager: StreamManager;
 
   constructor(
     public multicodec: string,
-    private components: Libp2pComponents
+    private components: Libp2pComponents,
+    private log: Logger,
+    protected pubsubTopics: PubsubTopic[],
+    private options?: ProtocolCreateOptions
   ) {
+    this.numPeersToUse = options?.numPeersToUse ?? DEFAULT_NUM_PEERS_TO_USE;
+
     this.addLibp2pEventListener = components.events.addEventListener.bind(
       components.events
     );
@@ -49,26 +65,27 @@ export class BaseProtocol implements IBaseProtocol {
    * the class protocol. Waku may or may not be currently connected to these
    * peers.
    */
-  public async peers(): Promise<Peer[]> {
+  public async allPeers(): Promise<Peer[]> {
     return getPeersForProtocol(this.peerStore, [this.multicodec]);
   }
 
-  protected async getPeer(peerId?: PeerId): Promise<Peer> {
-    const { peer } = await selectPeerForProtocol(
-      this.peerStore,
-      [this.multicodec],
-      peerId
-    );
-    return peer;
+  public async connectedPeers(): Promise<Peer[]> {
+    const peers = await this.allPeers();
+    return peers.filter((peer) => {
+      return (
+        this.components.connectionManager.getConnections(peer.id).length > 0
+      );
+    });
   }
 
   /**
-   * Retrieves a list of peers based on the specified criteria.
+   * Retrieves a list of connected peers that support the protocol. The list is sorted by latency.
    *
    * @param numPeers - The total number of peers to retrieve. If 0, all peers are returned.
    * @param maxBootstrapPeers - The maximum number of bootstrap peers to retrieve.
-   * @returns A Promise that resolves to an array of peers based on the specified criteria.
-   */
+
+  * @returns A list of peers that support the protocol sorted by latency.
+  */
   protected async getPeers(
     {
       numPeers,
@@ -81,12 +98,42 @@ export class BaseProtocol implements IBaseProtocol {
       numPeers: 0
     }
   ): Promise<Peer[]> {
-    // Retrieve all peers that support the protocol
-    const allPeersForProtocol = await getPeersForProtocol(this.peerStore, [
-      this.multicodec
-    ]);
+    // Retrieve all connected peers that support the protocol & shard (if configured)
+    const connectedPeersForProtocolAndShard =
+      await getConnectedPeersForProtocolAndShard(
+        this.components.connectionManager.getConnections(),
+        this.peerStore,
+        [this.multicodec],
+        this.options?.shardInfo
+          ? ensureShardingConfigured(this.options.shardInfo).shardInfo
+          : undefined
+      );
+
+    // Filter the peers based on discovery & number of peers requested
+    const filteredPeers = filterPeersByDiscovery(
+      connectedPeersForProtocolAndShard,
+      numPeers,
+      maxBootstrapPeers
+    );
+
+    // Sort the peers by latency
+    const sortedFilteredPeers = await sortPeersByLatency(
+      this.peerStore,
+      filteredPeers
+    );
+
+    if (sortedFilteredPeers.length === 0) {
+      this.log.warn(
+        "No peers found. Ensure you have a connection to the network."
+      );
+    }
+
+    if (sortedFilteredPeers.length < numPeers) {
+      this.log.warn(
+        `Only ${sortedFilteredPeers.length} peers found. Requested ${numPeers}.`
+      );
+    }
 
-    // Filter the peers based on the specified criteria
-    return filterPeers(allPeersForProtocol, numPeers, maxBootstrapPeers);
+    return sortedFilteredPeers;
   }
 }

package/src/lib/connection_manager.ts

@@ -1,9 +1,5 @@
-import type { PeerId } from "@libp2p/interface/peer-id";
-import type { PeerInfo } from "@libp2p/interface/peer-info";
-import type { Peer } from "@libp2p/interface/peer-store";
-import type { PeerStore } from "@libp2p/interface/peer-store";
-import { CustomEvent, EventEmitter } from "@libp2p/interfaces/events";
-import { decodeRelayShard } from "@waku/enr";
+import type { Peer, PeerId, PeerInfo, PeerStore } from "@libp2p/interface";
+import { CustomEvent, TypedEventEmitter } from "@libp2p/interface";
 import {
   ConnectionManagerOptions,
   EConnectionStateEvents,
@@ -18,7 +14,7 @@ import {
   ShardInfo
 } from "@waku/interfaces";
 import { Libp2p, Tags } from "@waku/interfaces";
-import { shardInfoToPubsubTopics } from "@waku/utils";
+import { decodeRelayShard, shardInfoToPubsubTopics } from "@waku/utils";
 import { Logger } from "@waku/utils";
 
 import { KeepAliveManager } from "./keep_alive_manager.js";
@@ -30,7 +26,7 @@ export const DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER = 3;
 export const DEFAULT_MAX_PARALLEL_DIALS = 3;
 
 export class ConnectionManager
-  extends EventEmitter<IPeersByDiscoveryEvents & IConnectionStateEvents>
+  extends TypedEventEmitter<IPeersByDiscoveryEvents & IConnectionStateEvents>
   implements IConnectionManager
 {
   private static instances = new Map<string, ConnectionManager>();
@@ -101,8 +97,11 @@ export class ConnectionManager
 
     const peersDiscoveredByBootstrap: Peer[] = [];
     const peersDiscoveredByPeerExchange: Peer[] = [];
+    const peersDiscoveredByLocal: Peer[] = [];
+
     const peersConnectedByBootstrap: Peer[] = [];
     const peersConnectedByPeerExchange: Peer[] = [];
+    const peersConnectedByLocal: Peer[] = [];
 
     for (const peer of peersDiscovered) {
       const tags = await this.getTagNamesForPeer(peer.id);
@@ -111,6 +110,8 @@ export class ConnectionManager
         peersDiscoveredByBootstrap.push(peer);
       } else if (tags.includes(Tags.PEER_EXCHANGE)) {
         peersDiscoveredByPeerExchange.push(peer);
+      } else if (tags.includes(Tags.LOCAL)) {
+        peersDiscoveredByLocal.push(peer);
       }
     }
 
@@ -122,17 +123,21 @@ export class ConnectionManager
         peersConnectedByBootstrap.push(peer);
       } else if (tags.includes(Tags.PEER_EXCHANGE)) {
         peersConnectedByPeerExchange.push(peer);
+      } else if (tags.includes(Tags.LOCAL)) {
+        peersConnectedByLocal.push(peer);
       }
     }
 
     return {
       DISCOVERED: {
         [Tags.BOOTSTRAP]: peersDiscoveredByBootstrap,
-        [Tags.PEER_EXCHANGE]: peersDiscoveredByPeerExchange
+        [Tags.PEER_EXCHANGE]: peersDiscoveredByPeerExchange,
+        [Tags.LOCAL]: peersDiscoveredByLocal
       },
       CONNECTED: {
         [Tags.BOOTSTRAP]: peersConnectedByBootstrap,
-        [Tags.PEER_EXCHANGE]: peersConnectedByPeerExchange
+        [Tags.PEER_EXCHANGE]: peersConnectedByPeerExchange,
+        [Tags.LOCAL]: peersConnectedByLocal
       }
     };
   }
@@ -380,6 +385,8 @@ export class ConnectionManager
     },
     "peer:connect": (evt: CustomEvent<PeerId>): void => {
       void (async () => {
+        log.info(`Connected to peer ${evt.detail.toString()}`);
+
         const peerId = evt.detail;
 
         this.keepAliveManager.start(