@waku/core 0.0.19 → 0.0.21

package/src/lib/connection_manager.ts

@@ -1,9 +1,15 @@
-import type { Connection } from "@libp2p/interface-connection";
-import type { Libp2p } from "@libp2p/interface-libp2p";
 import type { PeerId } from "@libp2p/interface-peer-id";
 import type { PeerInfo } from "@libp2p/interface-peer-info";
-import type { ConnectionManagerOptions, IRelay } from "@waku/interfaces";
-import { Tags } from "@waku/interfaces";
+import type { Peer } from "@libp2p/interface-peer-store";
+import { CustomEvent, EventEmitter } from "@libp2p/interfaces/events";
+import {
+  ConnectionManagerOptions,
+  EPeersByDiscoveryEvents,
+  IPeersByDiscoveryEvents,
+  IRelay,
+  PeersByDiscoveryResult,
+} from "@waku/interfaces";
+import { Libp2p, Tags } from "@waku/interfaces";
 import debug from "debug";
 
 import { KeepAliveManager, KeepAliveOptions } from "./keep_alive_manager.js";
@@ -12,15 +18,19 @@ const log = debug("waku:connection-manager");
 
 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 {
+export class ConnectionManager extends EventEmitter<IPeersByDiscoveryEvents> {
   private static instances = new Map<string, ConnectionManager>();
   private keepAliveManager: KeepAliveManager;
   private options: ConnectionManagerOptions;
-  private libp2pComponents: Libp2p;
+  private libp2p: Libp2p;
   private dialAttemptsForPeer: Map<string, number> = new Map();
   private dialErrorsForPeer: Map<string, any> = new Map();
 
+  private currentActiveDialCount = 0;
+  private pendingPeerDialQueue: Array<PeerId> = [];
+
   public static create(
     peerId: string,
     libp2p: Libp2p,
@@ -42,16 +52,62 @@ export class ConnectionManager {
     return instance;
   }
 
+  public async getPeersByDiscovery(): Promise<PeersByDiscoveryResult> {
+    const peersDiscovered = await this.libp2p.peerStore.all();
+    const peersConnected = this.libp2p
+      .getConnections()
+      .map((conn) => conn.remotePeer);
+
+    const peersDiscoveredByBootstrap: Peer[] = [];
+    const peersDiscoveredByPeerExchange: Peer[] = [];
+    const peersConnectedByBootstrap: Peer[] = [];
+    const peersConnectedByPeerExchange: Peer[] = [];
+
+    for (const peer of peersDiscovered) {
+      const tags = await this.getTagNamesForPeer(peer.id);
+
+      if (tags.includes(Tags.BOOTSTRAP)) {
+        peersDiscoveredByBootstrap.push(peer);
+      } else if (tags.includes(Tags.PEER_EXCHANGE)) {
+        peersDiscoveredByPeerExchange.push(peer);
+      }
+    }
+
+    for (const peerId of peersConnected) {
+      const peer = await this.libp2p.peerStore.get(peerId);
+      const tags = await this.getTagNamesForPeer(peerId);
+
+      if (tags.includes(Tags.BOOTSTRAP)) {
+        peersConnectedByBootstrap.push(peer);
+      } else if (tags.includes(Tags.PEER_EXCHANGE)) {
+        peersConnectedByPeerExchange.push(peer);
+      }
+    }
+
+    return {
+      DISCOVERED: {
+        [Tags.BOOTSTRAP]: peersDiscoveredByBootstrap,
+        [Tags.PEER_EXCHANGE]: peersDiscoveredByPeerExchange,
+      },
+      CONNECTED: {
+        [Tags.BOOTSTRAP]: peersConnectedByBootstrap,
+        [Tags.PEER_EXCHANGE]: peersConnectedByPeerExchange,
+      },
+    };
+  }
+
   private constructor(
-    libp2pComponents: Libp2p,
+    libp2p: Libp2p,
     keepAliveOptions: KeepAliveOptions,
     relay?: IRelay,
     options?: Partial<ConnectionManagerOptions>
   ) {
-    this.libp2pComponents = libp2pComponents;
+    super();
+    this.libp2p = libp2p;
     this.options = {
       maxDialAttemptsForPeer: DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER,
       maxBootstrapPeersAllowed: DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED,
+      maxParallelDials: DEFAULT_MAX_PARALLEL_DIALS,
       ...options,
     };
 
@@ -60,6 +116,31 @@ export class ConnectionManager {
     this.run()
       .then(() => log(`Connection Manager is now running`))
       .catch((error) => log(`Unexpected error while running service`, error));
+
+    // libp2p emits `peer:discovery` events during its initialization
+    // which means that before the ConnectionManager is initialized, some peers may have been discovered
+    // we will dial the peers in peerStore ONCE before we start to listen to the `peer:discovery` events within the ConnectionManager
+    this.dialPeerStorePeers().catch((error) =>
+      log(`Unexpected error while dialing peer store peers`, error)
+    );
+  }
+
+  private async dialPeerStorePeers(): Promise<void> {
+    const peerInfos = await this.libp2p.peerStore.all();
+    const dialPromises = [];
+    for (const peerInfo of peerInfos) {
+      if (
+        this.libp2p.getConnections().find((c) => c.remotePeer === peerInfo.id)
+      )
+        continue;
+
+      dialPromises.push(this.attemptDial(peerInfo.id));
+    }
+    try {
+      await Promise.all(dialPromises);
+    } catch (error) {
+      log(`Unexpected error while dialing peer store peers`, error);
+    }
   }
 
   private async run(): Promise<void> {
@@ -71,31 +152,32 @@ export class ConnectionManager {
 
   stop(): void {
     this.keepAliveManager.stopAll();
-    this.libp2pComponents.removeEventListener(
+    this.libp2p.removeEventListener(
       "peer:connect",
       this.onEventHandlers["peer:connect"]
     );
-    this.libp2pComponents.removeEventListener(
+    this.libp2p.removeEventListener(
       "peer:disconnect",
       this.onEventHandlers["peer:disconnect"]
     );
-    this.libp2pComponents.removeEventListener(
+    this.libp2p.removeEventListener(
       "peer:discovery",
       this.onEventHandlers["peer:discovery"]
     );
   }
 
   private async dialPeer(peerId: PeerId): Promise<void> {
+    this.currentActiveDialCount += 1;
     let dialAttempt = 0;
     while (dialAttempt <= this.options.maxDialAttemptsForPeer) {
       try {
         log(`Dialing peer ${peerId.toString()}`);
-        await this.libp2pComponents.dial(peerId);
+        await this.libp2p.dial(peerId);
 
         const tags = await this.getTagNamesForPeer(peerId);
         // add tag to connection describing discovery mechanism
         // don't add duplicate tags
-        this.libp2pComponents
+        this.libp2p
           .getConnections(peerId)
           .forEach(
             (conn) => (conn.tags = Array.from(new Set([...conn.tags, ...tags])))
@@ -105,6 +187,7 @@ export class ConnectionManager {
         return;
       } catch (e) {
         const error = e as AggregateError;
+
         this.dialErrorsForPeer.set(peerId.toString(), error);
         log(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
 
@@ -125,21 +208,49 @@ export class ConnectionManager {
         }`
       );
       this.dialErrorsForPeer.delete(peerId.toString());
-      return await this.libp2pComponents.peerStore.delete(peerId);
+      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();
+    }
+  }
+
+  async dropConnection(peerId: PeerId): Promise<void> {
+    try {
+      this.keepAliveManager.stop(peerId);
+      await this.libp2p.hangUp(peerId);
+      log(`Dropped connection with peer ${peerId.toString()}`);
+    } catch (error) {
+      log(
+        `Error dropping connection with peer ${peerId.toString()} - ${error}`
+      );
+    }
+  }
+
+  private processDialQueue(): void {
+    if (
+      this.pendingPeerDialQueue.length > 0 &&
+      this.currentActiveDialCount < this.options.maxParallelDials
+    ) {
+      const peerId = this.pendingPeerDialQueue.shift();
+      if (!peerId) return;
+      this.attemptDial(peerId).catch((error) => {
+        log(error);
+      });
     }
   }
 
   private startPeerDiscoveryListener(): void {
-    this.libp2pComponents.peerStore.addEventListener(
-      "peer",
+    this.libp2p.addEventListener(
+      "peer:discovery",
       this.onEventHandlers["peer:discovery"]
     );
   }
 
   private startPeerConnectionListener(): void {
-    this.libp2pComponents.addEventListener(
+    this.libp2p.addEventListener(
       "peer:connect",
       this.onEventHandlers["peer:connect"]
     );
@@ -158,32 +269,106 @@ export class ConnectionManager {
      * >this event will **only** be triggered when the last connection is closed.
      * @see https://github.com/libp2p/js-libp2p/blob/bad9e8c0ff58d60a78314077720c82ae331cc55b/doc/API.md?plain=1#L2100
      */
-    this.libp2pComponents.addEventListener(
+    this.libp2p.addEventListener(
       "peer:disconnect",
       this.onEventHandlers["peer:disconnect"]
     );
   }
 
+  private async attemptDial(peerId: PeerId): Promise<void> {
+    if (this.currentActiveDialCount >= this.options.maxParallelDials) {
+      this.pendingPeerDialQueue.push(peerId);
+      return;
+    }
+
+    if (!(await this.shouldDialPeer(peerId))) return;
+
+    this.dialPeer(peerId).catch((err) => {
+      throw `Error dialing peer ${peerId.toString()} : ${err}`;
+    });
+  }
+
   private onEventHandlers = {
-    "peer:discovery": async (evt: CustomEvent<PeerInfo>): Promise<void> => {
-      const { id: peerId } = evt.detail;
-      if (!(await this.shouldDialPeer(peerId))) return;
+    "peer:discovery": (evt: CustomEvent<PeerInfo>): void => {
+      void (async () => {
+        const { id: peerId } = evt.detail;
 
-      this.dialPeer(peerId).catch((err) =>
-        log(`Error dialing peer ${peerId.toString()} : ${err}`)
-      );
+        const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(
+          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,
+              }
+            )
+          );
+        }
+
+        try {
+          await this.attemptDial(peerId);
+        } catch (error) {
+          log(`Error dialing peer ${peerId.toString()} : ${error}`);
+        }
+      })();
     },
-    "peer:connect": (evt: CustomEvent<Connection>): void => {
-      {
-        this.keepAliveManager.start(
-          evt.detail.remotePeer,
-          this.libp2pComponents.ping.bind(this)
+    "peer:connect": (evt: CustomEvent<PeerId>): void => {
+      void (async () => {
+        const peerId = evt.detail;
+
+        this.keepAliveManager.start(peerId, this.libp2p.services.ping);
+
+        const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(
+          Tags.BOOTSTRAP
         );
-      }
+
+        if (isBootstrap) {
+          const bootstrapConnections = this.libp2p
+            .getConnections()
+            .filter((conn) => conn.tags.includes(Tags.BOOTSTRAP));
+
+          // If we have too many bootstrap connections, drop one
+          if (
+            bootstrapConnections.length > this.options.maxBootstrapPeersAllowed
+          ) {
+            await this.dropConnection(peerId);
+          } else {
+            this.dispatchEvent(
+              new CustomEvent<PeerId>(
+                EPeersByDiscoveryEvents.PEER_CONNECT_BOOTSTRAP,
+                {
+                  detail: peerId,
+                }
+              )
+            );
+          }
+        } else {
+          this.dispatchEvent(
+            new CustomEvent<PeerId>(
+              EPeersByDiscoveryEvents.PEER_CONNECT_PEER_EXCHANGE,
+              {
+                detail: peerId,
+              }
+            )
+          );
+        }
+      })();
     },
     "peer:disconnect": () => {
-      return (evt: CustomEvent<Connection>): void => {
-        this.keepAliveManager.stop(evt.detail.remotePeer);
+      return (evt: CustomEvent<PeerId>): void => {
+        this.keepAliveManager.stop(evt.detail);
       };
     },
   };
@@ -194,19 +379,19 @@ export class ConnectionManager {
    * 2. If the peer is not a bootstrap peer
    */
   private async shouldDialPeer(peerId: PeerId): Promise<boolean> {
-    const isConnected = this.libp2pComponents.getConnections(peerId).length > 0;
+    const isConnected = this.libp2p.getConnections(peerId).length > 0;
 
     if (isConnected) return false;
 
-    const isBootstrap = (await this.getTagNamesForPeer(peerId)).some(
-      (tagName) => tagName === Tags.BOOTSTRAP
-    );
+    const tagNames = await this.getTagNamesForPeer(peerId);
+
+    const isBootstrap = tagNames.some((tagName) => tagName === Tags.BOOTSTRAP);
 
     if (isBootstrap) {
-      const currentBootstrapConnections = this.libp2pComponents
+      const currentBootstrapConnections = this.libp2p
         .getConnections()
         .filter((conn) => {
-          conn.tags.find((name) => name === Tags.BOOTSTRAP);
+          return conn.tags.find((name) => name === Tags.BOOTSTRAP);
         }).length;
       if (currentBootstrapConnections < this.options.maxBootstrapPeersAllowed)
         return true;
@@ -221,9 +406,12 @@ export class ConnectionManager {
    * Fetches the tag names for a given peer
    */
   private async getTagNamesForPeer(peerId: PeerId): Promise<string[]> {
-    const tags = (await this.libp2pComponents.peerStore.getTags(peerId)).map(
-      (tag) => tag.name
-    );
-    return tags;
+    try {
+      const peer = await this.libp2p.peerStore.get(peerId);
+      return Array.from(peer.tags.keys());
+    } catch (error) {
+      log(`Failed to get peer ${peerId}, error: ${error}`);
+      return [];
+    }
   }
 }

package/src/lib/filter/{v2/index.ts → index.ts}

@@ -1,5 +1,4 @@
 import { Stream } from "@libp2p/interface-connection";
-import type { Libp2p } from "@libp2p/interface-libp2p";
 import type { PeerId } from "@libp2p/interface-peer-id";
 import type { Peer } from "@libp2p/interface-peer-store";
 import type { IncomingStreamData } from "@libp2p/interface-registrar";
@@ -9,9 +8,10 @@ import type {
   IAsyncIterator,
   IDecodedMessage,
   IDecoder,
-  IFilterV2,
+  IFilter,
   IProtoMessage,
   IReceiver,
+  Libp2p,
   PeerIdStr,
   ProtocolCreateOptions,
   ProtocolOptions,
@@ -25,8 +25,8 @@ import all from "it-all";
 import * as lp from "it-length-prefixed";
 import { pipe } from "it-pipe";
 
-import { BaseProtocol } from "../../base_protocol.js";
-import { DefaultPubSubTopic } from "../../constants.js";
+import { BaseProtocol } from "../base_protocol.js";
+import { DefaultPubSubTopic } from "../constants.js";
 
 import {
   FilterPushRpc,
@@ -41,7 +41,7 @@ type SubscriptionCallback<T extends IDecodedMessage> = {
   callback: Callback<T>;
 };
 
-const FilterV2Codecs = {
+const FilterCodecs = {
   SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
   PUSH: "/vac/waku/filter-push/2.0.0-beta1",
 };
@@ -225,7 +225,7 @@ class Subscription {
   }
 }
 
-class FilterV2 extends BaseProtocol implements IReceiver {
+class Filter extends BaseProtocol implements IReceiver {
   private readonly options: ProtocolCreateOptions;
   private activeSubscriptions = new Map<string, Subscription>();
 
@@ -245,18 +245,12 @@ class FilterV2 extends BaseProtocol implements IReceiver {
     return subscription;
   }
 
-  constructor(public libp2p: Libp2p, options?: ProtocolCreateOptions) {
-    super(
-      FilterV2Codecs.SUBSCRIBE,
-      libp2p.peerStore,
-      libp2p.getConnections.bind(libp2p)
-    );
+  constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
+    super(FilterCodecs.SUBSCRIBE, libp2p.components);
 
-    this.libp2p
-      .handle(FilterV2Codecs.PUSH, this.onRequest.bind(this))
-      .catch((e) => {
-        log("Failed to register ", FilterV2Codecs.PUSH, e);
-      });
+    libp2p.handle(FilterCodecs.PUSH, this.onRequest.bind(this)).catch((e) => {
+      log("Failed to register ", FilterCodecs.PUSH, e);
+    });
 
     this.activeSubscriptions = new Map();
 
@@ -312,7 +306,7 @@ class FilterV2 extends BaseProtocol implements IReceiver {
   ): Promise<Unsubscribe> {
     const subscription = await this.createSubscription(undefined, opts?.peerId);
 
-    subscription.subscribe(decoders, callback);
+    await subscription.subscribe(decoders, callback);
 
     const contentTopics = Array.from(
       groupByContentTopic(
@@ -371,10 +365,10 @@ class FilterV2 extends BaseProtocol implements IReceiver {
   }
 }
 
-export function wakuFilterV2(
+export function wakuFilter(
   init: Partial<ProtocolCreateOptions> = {}
-): (libp2p: Libp2p) => IFilterV2 {
-  return (libp2p: Libp2p) => new FilterV2(libp2p, init);
+): (libp2p: Libp2p) => IFilter {
+  return (libp2p: Libp2p) => new Filter(libp2p, init);
 }
 
 async function pushMessage<T extends IDecodedMessage>(
@@ -394,20 +388,19 @@ async function pushMessage<T extends IDecodedMessage>(
   // 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
-  decoders.forEach(async (dec: IDecoder<T>) => {
-    if (didDecodeMsg) return;
+  for (const dec of decoders) {
+    if (didDecodeMsg) break;
     const decoded = await dec.fromProtoObj(
       pubSubTopic,
       message as IProtoMessage
     );
-    // const decoded = await dec.fromProtoObj(pubSubTopic, message);
     if (!decoded) {
       log("Not able to decode message");
-      return;
+      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);
-  });
+  }
 }

package/src/lib/keep_alive_manager.ts

@@ -1,7 +1,7 @@
 import type { PeerId } from "@libp2p/interface-peer-id";
 import type { IRelay } from "@waku/interfaces";
 import debug from "debug";
-import type { Libp2p } from "libp2p";
+import type { PingService } from "libp2p/ping";
 
 import { createEncoder } from "../index.js";
 
@@ -26,7 +26,7 @@ export class KeepAliveManager {
     this.relay = relay;
   }
 
-  public start(peerId: PeerId, libp2pPing: Libp2p["ping"]): void {
+  public start(peerId: PeerId, libp2pPing: PingService): void {
     // Just in case a timer already exist for this peer
     this.stop(peerId);
 
@@ -37,7 +37,7 @@ export class KeepAliveManager {
 
     if (pingPeriodSecs !== 0) {
       const interval = setInterval(() => {
-        libp2pPing(peerId).catch((e) => {
+        libp2pPing.ping(peerId).catch((e) => {
           log(`Ping failed (${peerIdStr})`, e);
         });
       }, pingPeriodSecs * 1000);

package/src/lib/light_push/index.ts

@@ -1,9 +1,9 @@
-import type { Libp2p } from "@libp2p/interface-libp2p";
 import type { PeerId } from "@libp2p/interface-peer-id";
 import {
   IEncoder,
   ILightPush,
   IMessage,
+  Libp2p,
   ProtocolCreateOptions,
   ProtocolOptions,
   SendError,
@@ -33,8 +33,8 @@ export { PushResponse };
 class LightPush extends BaseProtocol implements ILightPush {
   options: ProtocolCreateOptions;
 
-  constructor(public libp2p: Libp2p, options?: ProtocolCreateOptions) {
-    super(LightPushCodec, libp2p.peerStore, libp2p.getConnections.bind(libp2p));
+  constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
+    super(LightPushCodec, libp2p.components);
     this.options = options || {};
   }
 

package/src/lib/predefined_bootstrap_nodes.ts

@@ -47,21 +47,21 @@ export const fleets = {
     "wakuv2.prod": {
       "waku-websocket": {
         "node-01.ac-cn-hongkong-c.wakuv2.prod":
-          "/dns4/node-01.ac-cn-hongkong-c.wakuv2.prod.statusim.net/tcp/443/wss/p2p/16Uiu2HAm4v86W3bmT1BiH6oSPzcsSr24iDQpSN5Qa992BCjjwgrD",
+          "/dns4/node-01.ac-cn-hongkong-c.wakuv2.prod.statusim.net/tcp/8000/wss/p2p/16Uiu2HAm4v86W3bmT1BiH6oSPzcsSr24iDQpSN5Qa992BCjjwgrD",
         "node-01.do-ams3.wakuv2.prod":
-          "/dns4/node-01.do-ams3.wakuv2.prod.statusim.net/tcp/443/wss/p2p/16Uiu2HAmL5okWopX7NqZWBUKVqW8iUxCEmd5GMHLVPwCgzYzQv3e",
+          "/dns4/node-01.do-ams3.wakuv2.prod.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmL5okWopX7NqZWBUKVqW8iUxCEmd5GMHLVPwCgzYzQv3e",
         "node-01.gc-us-central1-a.wakuv2.prod":
-          "/dns4/node-01.gc-us-central1-a.wakuv2.prod.statusim.net/tcp/443/wss/p2p/16Uiu2HAmVkKntsECaYfefR1V2yCR79CegLATuTPE6B9TxgxBiiiA",
+          "/dns4/node-01.gc-us-central1-a.wakuv2.prod.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmVkKntsECaYfefR1V2yCR79CegLATuTPE6B9TxgxBiiiA",
       },
     },
     "wakuv2.test": {
       "waku-websocket": {
         "node-01.ac-cn-hongkong-c.wakuv2.test":
-          "/dns4/node-01.ac-cn-hongkong-c.wakuv2.test.statusim.net/tcp/443/wss/p2p/16Uiu2HAkvWiyFsgRhuJEb9JfjYxEkoHLgnUQmr1N5mKWnYjxYRVm",
+          "/dns4/node-01.ac-cn-hongkong-c.wakuv2.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAkvWiyFsgRhuJEb9JfjYxEkoHLgnUQmr1N5mKWnYjxYRVm",
         "node-01.do-ams3.wakuv2.test":
-          "/dns4/node-01.do-ams3.wakuv2.test.statusim.net/tcp/443/wss/p2p/16Uiu2HAmPLe7Mzm8TsYUubgCAW1aJoeFScxrLj8ppHFivPo97bUZ",
+          "/dns4/node-01.do-ams3.wakuv2.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmPLe7Mzm8TsYUubgCAW1aJoeFScxrLj8ppHFivPo97bUZ",
         "node-01.gc-us-central1-a.wakuv2.test":
-          "/dns4/node-01.gc-us-central1-a.wakuv2.test.statusim.net/tcp/443/wss/p2p/16Uiu2HAmJb2e28qLXxT5kZxVUUoJt72EMzNGXB47Rxx5hw3q4YjS",
+          "/dns4/node-01.gc-us-central1-a.wakuv2.test.statusim.net/tcp/8000/wss/p2p/16Uiu2HAmJb2e28qLXxT5kZxVUUoJt72EMzNGXB47Rxx5hw3q4YjS",
       },
     },
   },

package/src/lib/store/index.ts

@@ -1,5 +1,4 @@
 import type { Stream } from "@libp2p/interface-connection";
-import type { Libp2p } from "@libp2p/interface-libp2p";
 import type { PeerId } from "@libp2p/interface-peer-id";
 import { sha256 } from "@noble/hashes/sha256";
 import {
@@ -7,6 +6,7 @@ import {
   IDecodedMessage,
   IDecoder,
   IStore,
+  Libp2p,
   ProtocolCreateOptions,
 } from "@waku/interfaces";
 import { proto_store as proto } from "@waku/proto";
@@ -81,8 +81,8 @@ export interface QueryOptions {
 class Store extends BaseProtocol implements IStore {
   options: ProtocolCreateOptions;
 
-  constructor(public libp2p: Libp2p, options?: ProtocolCreateOptions) {
-    super(StoreCodec, libp2p.peerStore, libp2p.getConnections.bind(libp2p));
+  constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
+    super(StoreCodec, libp2p.components);
     this.options = options ?? {};
   }
 

package/src/lib/wait_for_remote_peer.ts

@@ -1,5 +1,5 @@
-import type { PeerProtocolsChangeData } from "@libp2p/interface-peer-store";
-import type { IRelay, PointToPointProtocol, Waku } from "@waku/interfaces";
+import type { IdentifyResult } from "@libp2p/interface-libp2p";
+import type { IBaseProtocol, IRelay, Waku } from "@waku/interfaces";
 import { Protocols } from "@waku/interfaces";
 import debug from "debug";
 import { pEvent } from "p-event";
@@ -10,7 +10,7 @@ const log = debug("waku:wait-for-remote-peer");
  * Wait for a remote peer to be ready given the passed protocols.
  * Must be used after attempting to connect to nodes, using
  * {@link @waku/core.WakuNode.dial} or a bootstrap method with
- * {@link @waku/create.createLightNode}.
+ * {@link @waku/sdk.createLightNode}.
  *
  * If the passed protocols is a GossipSub protocol, then it resolves only once
  * a peer is in a mesh, to help ensure that other peers will send and receive
@@ -74,9 +74,7 @@ export async function waitForRemotePeer(
 /**
  * Wait for a peer with the given protocol to be connected.
  */
-async function waitForConnectedPeer(
-  protocol: PointToPointProtocol
-): Promise<void> {
+async function waitForConnectedPeer(protocol: IBaseProtocol): Promise<void> {
   const codec = protocol.multicodec;
   const peers = await protocol.peers();
 
@@ -86,14 +84,14 @@ async function waitForConnectedPeer(
   }
 
   await new Promise<void>((resolve) => {
-    const cb = (evt: CustomEvent<PeerProtocolsChangeData>): void => {
-      if (evt.detail.protocols.includes(codec)) {
+    const cb = (evt: CustomEvent<IdentifyResult>): void => {
+      if (evt.detail?.protocols?.includes(codec)) {
         log("Resolving for", codec, evt.detail.protocols);
-        protocol.peerStore.removeEventListener("change:protocols", cb);
+        protocol.removeLibp2pEventListener("peer:identify", cb);
         resolve();
       }
     };
-    protocol.peerStore.addEventListener("change:protocols", cb);
+    protocol.addLibp2pEventListener("peer:identify", cb);
   });
 }