@waku/core 0.0.21 → 0.0.23

package/src/lib/connection_manager.ts

@@ -1,18 +1,20 @@
-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 { PeerId } from "@libp2p/interface/peer-id";
+import type { PeerInfo } from "@libp2p/interface/peer-info";
+import type { Peer } from "@libp2p/interface/peer-store";
 import { CustomEvent, EventEmitter } from "@libp2p/interfaces/events";
 import {
   ConnectionManagerOptions,
   EPeersByDiscoveryEvents,
+  IConnectionManager,
   IPeersByDiscoveryEvents,
   IRelay,
-  PeersByDiscoveryResult,
+  KeepAliveOptions,
+  PeersByDiscoveryResult
 } from "@waku/interfaces";
 import { Libp2p, Tags } from "@waku/interfaces";
 import debug from "debug";
 
-import { KeepAliveManager, KeepAliveOptions } from "./keep_alive_manager.js";
+import { KeepAliveManager } from "./keep_alive_manager.js";
 
 const log = debug("waku:connection-manager");
 
@@ -20,7 +22,10 @@ export const DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED = 1;
 export const DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER = 3;
 export const DEFAULT_MAX_PARALLEL_DIALS = 3;
 
-export class ConnectionManager extends EventEmitter<IPeersByDiscoveryEvents> {
+export class ConnectionManager
+  extends EventEmitter<IPeersByDiscoveryEvents>
+  implements IConnectionManager
+{
   private static instances = new Map<string, ConnectionManager>();
   private keepAliveManager: KeepAliveManager;
   private options: ConnectionManagerOptions;
@@ -87,12 +92,12 @@ export class ConnectionManager extends EventEmitter<IPeersByDiscoveryEvents> {
     return {
       DISCOVERED: {
         [Tags.BOOTSTRAP]: peersDiscoveredByBootstrap,
-        [Tags.PEER_EXCHANGE]: peersDiscoveredByPeerExchange,
+        [Tags.PEER_EXCHANGE]: peersDiscoveredByPeerExchange
       },
       CONNECTED: {
         [Tags.BOOTSTRAP]: peersConnectedByBootstrap,
-        [Tags.PEER_EXCHANGE]: peersConnectedByPeerExchange,
-      },
+        [Tags.PEER_EXCHANGE]: peersConnectedByPeerExchange
+      }
     };
   }
 
@@ -108,7 +113,7 @@ export class ConnectionManager extends EventEmitter<IPeersByDiscoveryEvents> {
       maxDialAttemptsForPeer: DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER,
       maxBootstrapPeersAllowed: DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED,
       maxParallelDials: DEFAULT_MAX_PARALLEL_DIALS,
-      ...options,
+      ...options
     };
 
     this.keepAliveManager = new KeepAliveManager(keepAliveOptions, relay);
@@ -169,55 +174,71 @@ export class ConnectionManager extends EventEmitter<IPeersByDiscoveryEvents> {
   private async dialPeer(peerId: PeerId): Promise<void> {
     this.currentActiveDialCount += 1;
     let dialAttempt = 0;
-    while (dialAttempt <= this.options.maxDialAttemptsForPeer) {
+    while (dialAttempt < this.options.maxDialAttemptsForPeer) {
       try {
-        log(`Dialing peer ${peerId.toString()}`);
+        log(`Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`);
         await this.libp2p.dial(peerId);
 
         const tags = await this.getTagNamesForPeer(peerId);
         // add tag to connection describing discovery mechanism
         // don't add duplicate tags
-        this.libp2p
-          .getConnections(peerId)
-          .forEach(
-            (conn) => (conn.tags = Array.from(new Set([...conn.tags, ...tags])))
-          );
+        this.libp2p.getConnections(peerId).forEach((conn) => {
+          conn.tags = Array.from(new Set([...conn.tags, ...tags]));
+        });
 
         this.dialAttemptsForPeer.delete(peerId.toString());
-        return;
-      } catch (e) {
-        const error = e as AggregateError;
-
+        // Dialing succeeded, break the loop
+        break;
+      } catch (error) {
+        if (error instanceof AggregateError) {
+          // Handle AggregateError
+          log(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
+        } else {
+          // Handle generic error
+          log(
+            `Error dialing peer ${peerId.toString()} - ${
+              (error as any).message
+            }`
+          );
+        }
         this.dialErrorsForPeer.set(peerId.toString(), error);
-        log(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
-
-        dialAttempt = this.dialAttemptsForPeer.get(peerId.toString()) ?? 1;
-        this.dialAttemptsForPeer.set(peerId.toString(), dialAttempt + 1);
 
-        if (dialAttempt <= this.options.maxDialAttemptsForPeer) {
-          log(`Reattempting dial (${dialAttempt})`);
-        }
+        dialAttempt++;
+        this.dialAttemptsForPeer.set(peerId.toString(), dialAttempt);
       }
     }
 
-    try {
-      log(
-        `Deleting undialable peer ${peerId.toString()} from peer store. Error: ${JSON.stringify(
-          this.dialErrorsForPeer.get(peerId.toString()).errors[0]
-        )}
-        }`
-      );
-      this.dialErrorsForPeer.delete(peerId.toString());
-      return await this.libp2p.peerStore.delete(peerId);
-    } catch (error) {
-      throw `Error deleting undialable peer ${peerId.toString()} from peer store - ${error}`;
-    } finally {
-      this.currentActiveDialCount -= 1;
-      this.processDialQueue();
+    // Always decrease the active dial count and process the dial queue
+    this.currentActiveDialCount--;
+    this.processDialQueue();
+
+    // If max dial attempts reached and dialing failed, delete the peer
+    if (dialAttempt === this.options.maxDialAttemptsForPeer) {
+      try {
+        const error = this.dialErrorsForPeer.get(peerId.toString());
+
+        let errorMessage;
+        if (error instanceof AggregateError) {
+          errorMessage = JSON.stringify(error.errors[0]);
+        } else {
+          errorMessage = error.message;
+        }
+
+        log(
+          `Deleting undialable peer ${peerId.toString()} from peer store. Error: ${errorMessage}`
+        );
+
+        this.dialErrorsForPeer.delete(peerId.toString());
+        await this.libp2p.peerStore.delete(peerId);
+      } catch (error) {
+        throw new Error(
+          `Error deleting undialable peer ${peerId.toString()} from peer store - ${error}`
+        );
+      }
     }
   }
 
-  async dropConnection(peerId: PeerId): Promise<void> {
+  private async dropConnection(peerId: PeerId): Promise<void> {
     try {
       this.keepAliveManager.stop(peerId);
       await this.libp2p.hangUp(peerId);
@@ -297,25 +318,16 @@ export class ConnectionManager extends EventEmitter<IPeersByDiscoveryEvents> {
           Tags.BOOTSTRAP
         );
 
-        if (isBootstrap) {
-          this.dispatchEvent(
-            new CustomEvent<PeerId>(
-              EPeersByDiscoveryEvents.PEER_DISCOVERY_BOOTSTRAP,
-              {
-                detail: peerId,
-              }
-            )
-          );
-        } else {
-          this.dispatchEvent(
-            new CustomEvent<PeerId>(
-              EPeersByDiscoveryEvents.PEER_DISCOVERY_PEER_EXCHANGE,
-              {
-                detail: peerId,
-              }
-            )
-          );
-        }
+        this.dispatchEvent(
+          new CustomEvent<PeerId>(
+            isBootstrap
+              ? EPeersByDiscoveryEvents.PEER_DISCOVERY_BOOTSTRAP
+              : EPeersByDiscoveryEvents.PEER_DISCOVERY_PEER_EXCHANGE,
+            {
+              detail: peerId
+            }
+          )
+        );
 
         try {
           await this.attemptDial(peerId);
@@ -328,7 +340,11 @@ export class ConnectionManager extends EventEmitter<IPeersByDiscoveryEvents> {
       void (async () => {
         const peerId = evt.detail;
 
-        this.keepAliveManager.start(peerId, this.libp2p.services.ping);
+        this.keepAliveManager.start(
+          peerId,
+          this.libp2p.services.ping,
+          this.libp2p.peerStore
+        );
 
         const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(
           Tags.BOOTSTRAP
@@ -349,7 +365,7 @@ export class ConnectionManager extends EventEmitter<IPeersByDiscoveryEvents> {
               new CustomEvent<PeerId>(
                 EPeersByDiscoveryEvents.PEER_CONNECT_BOOTSTRAP,
                 {
-                  detail: peerId,
+                  detail: peerId
                 }
               )
             );
@@ -359,7 +375,7 @@ export class ConnectionManager extends EventEmitter<IPeersByDiscoveryEvents> {
             new CustomEvent<PeerId>(
               EPeersByDiscoveryEvents.PEER_CONNECT_PEER_EXCHANGE,
               {
-                detail: peerId,
+                detail: peerId
               }
             )
           );
@@ -370,7 +386,7 @@ export class ConnectionManager extends EventEmitter<IPeersByDiscoveryEvents> {
       return (evt: CustomEvent<PeerId>): void => {
         this.keepAliveManager.stop(evt.detail);
       };
-    },
+    }
   };
 
   /**

package/src/lib/filter/filter_rpc.ts

@@ -42,7 +42,7 @@ export class FilterSubscribeRpc {
       filterSubscribeType:
         proto.FilterSubscribeRequest.FilterSubscribeType.SUBSCRIBE,
       pubsubTopic,
-      contentTopics,
+      contentTopics
     });
   }
 
@@ -55,7 +55,7 @@ export class FilterSubscribeRpc {
       filterSubscribeType:
         proto.FilterSubscribeRequest.FilterSubscribeType.UNSUBSCRIBE,
       pubsubTopic,
-      contentTopics,
+      contentTopics
     });
   }
 
@@ -65,7 +65,7 @@ export class FilterSubscribeRpc {
       filterSubscribeType:
         proto.FilterSubscribeRequest.FilterSubscribeType.UNSUBSCRIBE_ALL,
       pubsubTopic,
-      contentTopics: [],
+      contentTopics: []
     });
   }
 
@@ -75,7 +75,7 @@ export class FilterSubscribeRpc {
       filterSubscribeType:
         proto.FilterSubscribeRequest.FilterSubscribeType.SUBSCRIBER_PING,
       pubsubTopic: "",
-      contentTopics: [],
+      contentTopics: []
     });
   }
 

package/src/lib/filter/index.ts

@@ -1,7 +1,6 @@
-import { Stream } from "@libp2p/interface-connection";
-import type { PeerId } from "@libp2p/interface-peer-id";
-import type { Peer } from "@libp2p/interface-peer-store";
-import type { IncomingStreamData } from "@libp2p/interface-registrar";
+import { Stream } from "@libp2p/interface/connection";
+import type { Peer } from "@libp2p/interface/peer-store";
+import type { IncomingStreamData } from "@libp2p/interface-internal/registrar";
 import type {
   Callback,
   ContentTopic,
@@ -14,9 +13,8 @@ import type {
   Libp2p,
   PeerIdStr,
   ProtocolCreateOptions,
-  ProtocolOptions,
   PubSubTopic,
-  Unsubscribe,
+  Unsubscribe
 } from "@waku/interfaces";
 import { WakuMessage } from "@waku/proto";
 import { groupByContentTopic, toAsyncIterator } from "@waku/utils";
@@ -31,7 +29,7 @@ import { DefaultPubSubTopic } from "../constants.js";
 import {
   FilterPushRpc,
   FilterSubscribeResponse,
-  FilterSubscribeRpc,
+  FilterSubscribeRpc
 } from "./filter_rpc.js";
 
 const log = debug("waku:filter:v2");
@@ -41,9 +39,9 @@ type SubscriptionCallback<T extends IDecodedMessage> = {
   callback: Callback<T>;
 };
 
-const FilterCodecs = {
+export const FilterCodecs = {
   SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
-  PUSH: "/vac/waku/filter-push/2.0.0-beta1",
+  PUSH: "/vac/waku/filter-push/2.0.0-beta1"
 };
 
 class Subscription {
@@ -125,7 +123,7 @@ class Subscription {
       // Decoder that decode to different implementations of `IDecodedMessage`
       const subscriptionCallback = {
         decoders,
-        callback,
+        callback
       } as unknown as SubscriptionCallback<IDecodedMessage>;
 
       // The callback and decoder may override previous values, this is on
@@ -228,6 +226,7 @@ class Subscription {
 class Filter extends BaseProtocol implements IReceiver {
   private readonly options: ProtocolCreateOptions;
   private activeSubscriptions = new Map<string, Subscription>();
+  private readonly NUM_PEERS_PROTOCOL = 1;
 
   private getActiveSubscription(
     pubSubTopic: PubSubTopic,
@@ -257,31 +256,32 @@ class Filter extends BaseProtocol implements IReceiver {
     this.options = options ?? {};
   }
 
-  async createSubscription(
-    pubSubTopic?: string,
-    peerId?: PeerId
-  ): Promise<Subscription> {
+  async createSubscription(pubSubTopic?: string): Promise<Subscription> {
     const _pubSubTopic =
       pubSubTopic ?? this.options.pubSubTopic ?? DefaultPubSubTopic;
 
-    const peer = await this.getPeer(peerId);
+    const peer = (
+      await this.getPeers({
+        maxBootstrapPeers: 1,
+        numPeers: this.NUM_PEERS_PROTOCOL
+      })
+    )[0];
 
     const subscription =
       this.getActiveSubscription(_pubSubTopic, peer.id.toString()) ??
       this.setActiveSubscription(
         _pubSubTopic,
         peer.id.toString(),
-        new Subscription(_pubSubTopic, peer, this.newStream.bind(this, peer))
+        new Subscription(_pubSubTopic, peer, this.getStream.bind(this, peer))
       );
 
     return subscription;
   }
 
   public toSubscriptionIterator<T extends IDecodedMessage>(
-    decoders: IDecoder<T> | IDecoder<T>[],
-    opts?: ProtocolOptions | undefined
+    decoders: IDecoder<T> | IDecoder<T>[]
   ): Promise<IAsyncIterator<T>> {
-    return toAsyncIterator(this, decoders, opts);
+    return toAsyncIterator(this, decoders);
   }
 
   /**
@@ -301,10 +301,9 @@ class Filter extends BaseProtocol implements IReceiver {
    */
   async subscribe<T extends IDecodedMessage>(
     decoders: IDecoder<T> | IDecoder<T>[],
-    callback: Callback<T>,
-    opts?: ProtocolOptions
+    callback: Callback<T>
   ): Promise<Unsubscribe> {
-    const subscription = await this.createSubscription(undefined, opts?.peerId);
+    const subscription = await this.createSubscription();
 
     await subscription.subscribe(decoders, callback);
 
@@ -384,23 +383,17 @@ async function pushMessage<T extends IDecodedMessage>(
     return;
   }
 
-  let didDecodeMsg = false;
-  // We don't want to wait for decoding failure, just attempt to decode
-  // all messages and do the call back on the one that works
-  // noinspection ES6MissingAwait
-  for (const dec of decoders) {
-    if (didDecodeMsg) break;
-    const decoded = await dec.fromProtoObj(
-      pubSubTopic,
-      message as IProtoMessage
+  try {
+    const decodePromises = decoders.map((dec) =>
+      dec
+        .fromProtoObj(pubSubTopic, message as IProtoMessage)
+        .then((decoded) => decoded || Promise.reject("Decoding failed"))
     );
-    if (!decoded) {
-      log("Not able to decode message");
-      continue;
-    }
-    // This is just to prevent more decoding attempt
-    // TODO: Could be better if we were to abort promises
-    didDecodeMsg = Boolean(decoded);
-    await callback(decoded);
+
+    const decodedMessage = await Promise.any(decodePromises);
+
+    await callback(decodedMessage);
+  } catch (e) {
+    log("Error decoding message", e);
   }
 }

package/src/lib/filterPeers.ts

@@ -0,0 +1,43 @@
+import { Peer } from "@libp2p/interface/peer-store";
+import { Tags } from "@waku/interfaces";
+
+/**
+ * Retrieves a list of peers based on the specified criteria.
+ *
+ * @param peers - The list of peers to filter from.
+ * @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.
+ */
+export async function filterPeers(
+  peers: Peer[],
+  numPeers: number,
+  maxBootstrapPeers: number
+): Promise<Peer[]> {
+  // Collect the bootstrap peers up to the specified maximum
+  const bootstrapPeers = peers
+    .filter((peer) => peer.tags.has(Tags.BOOTSTRAP))
+    .slice(0, maxBootstrapPeers);
+
+  // Collect non-bootstrap peers
+  const nonBootstrapPeers = peers.filter(
+    (peer) => !peer.tags.has(Tags.BOOTSTRAP)
+  );
+
+  // If numPeers is 0, return all peers
+  if (numPeers === 0) {
+    return [...bootstrapPeers, ...nonBootstrapPeers];
+  }
+
+  // Initialize the list of selected peers with the bootstrap peers
+  const selectedPeers: Peer[] = [...bootstrapPeers];
+
+  // Fill up to numPeers with remaining random peers if needed
+  while (selectedPeers.length < numPeers && nonBootstrapPeers.length > 0) {
+    const randomIndex = Math.floor(Math.random() * nonBootstrapPeers.length);
+    const randomPeer = nonBootstrapPeers.splice(randomIndex, 1)[0];
+    selectedPeers.push(randomPeer);
+  }
+
+  return selectedPeers;
+}

package/src/lib/keep_alive_manager.ts

@@ -1,18 +1,16 @@
-import type { PeerId } from "@libp2p/interface-peer-id";
+import type { PeerId } from "@libp2p/interface/peer-id";
+import type { PeerStore } from "@libp2p/interface/peer-store";
 import type { IRelay } from "@waku/interfaces";
+import type { KeepAliveOptions } from "@waku/interfaces";
+import { utf8ToBytes } from "@waku/utils/bytes";
 import debug from "debug";
 import type { PingService } from "libp2p/ping";
 
-import { createEncoder } from "../index.js";
+import { createEncoder } from "./message/version_0.js";
 
 export const RelayPingContentTopic = "/relay-ping/1/ping/null";
 const log = debug("waku:keep-alive");
 
-export interface KeepAliveOptions {
-  pingKeepAlive: number;
-  relayKeepAlive: number;
-}
-
 export class KeepAliveManager {
   private pingKeepAliveTimers: Map<string, ReturnType<typeof setInterval>>;
   private relayKeepAliveTimers: Map<PeerId, ReturnType<typeof setInterval>>;
@@ -26,8 +24,12 @@ export class KeepAliveManager {
     this.relay = relay;
   }
 
-  public start(peerId: PeerId, libp2pPing: PingService): void {
-    // Just in case a timer already exist for this peer
+  public start(
+    peerId: PeerId,
+    libp2pPing: PingService,
+    peerStore: PeerStore
+  ): void {
+    // Just in case a timer already exists for this peer
     this.stop(peerId);
 
     const { pingKeepAlive: pingPeriodSecs, relayKeepAlive: relayPeriodSecs } =
@@ -37,10 +39,28 @@ export class KeepAliveManager {
 
     if (pingPeriodSecs !== 0) {
       const interval = setInterval(() => {
-        libp2pPing.ping(peerId).catch((e) => {
-          log(`Ping failed (${peerIdStr})`, e);
-        });
+        void (async () => {
+          try {
+            // ping the peer for keep alive
+            // also update the peer store with the latency
+            const ping = await libp2pPing.ping(peerId);
+            log(`Ping succeeded (${peerIdStr})`, ping);
+
+            try {
+              await peerStore.patch(peerId, {
+                metadata: {
+                  ping: utf8ToBytes(ping.toString())
+                }
+              });
+            } catch (e) {
+              log("Failed to update ping", e);
+            }
+          } catch (e) {
+            log(`Ping failed (${peerIdStr})`, e);
+          }
+        })();
       }, pingPeriodSecs * 1000);
+
       this.pingKeepAliveTimers.set(peerIdStr, interval);
     }
 
@@ -48,7 +68,7 @@ export class KeepAliveManager {
     if (relay && relayPeriodSecs !== 0) {
       const encoder = createEncoder({
         contentTopic: RelayPingContentTopic,
-        ephemeral: true,
+        ephemeral: true
       });
       const interval = setInterval(() => {
         log("Sending Waku Relay ping message");
@@ -77,7 +97,7 @@ export class KeepAliveManager {
   public stopAll(): void {
     for (const timer of [
       ...Object.values(this.pingKeepAliveTimers),
-      ...Object.values(this.relayKeepAliveTimers),
+      ...Object.values(this.relayKeepAliveTimers)
     ]) {
       clearInterval(timer);
     }