@waku/core 0.0.20 → 0.0.22

package/src/lib/connection_manager.ts

@@ -1,12 +1,20 @@
-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,
+  IConnectionManager,
+  IPeersByDiscoveryEvents,
+  IRelay,
+  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");
 
@@ -14,11 +22,14 @@ 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>
+  implements IConnectionManager
+{
   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();
 
@@ -46,13 +57,58 @@ 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,
@@ -69,17 +125,17 @@ export class ConnectionManager {
     // 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();
+    this.dialPeerStorePeers().catch((error) =>
+      log(`Unexpected error while dialing peer store peers`, error)
+    );
   }
 
   private async dialPeerStorePeers(): Promise<void> {
-    const peerInfos = await this.libp2pComponents.peerStore.all();
+    const peerInfos = await this.libp2p.peerStore.all();
     const dialPromises = [];
     for (const peerInfo of peerInfos) {
       if (
-        this.libp2pComponents
-          .getConnections()
-          .find((c) => c.remotePeer === peerInfo.id)
+        this.libp2p.getConnections().find((c) => c.remotePeer === peerInfo.id)
       )
         continue;
 
@@ -101,15 +157,15 @@ 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"]
     );
@@ -118,57 +174,74 @@ export class ConnectionManager {
   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()}`);
-        await this.libp2pComponents.dial(peerId);
+        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.libp2pComponents
-          .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.libp2pComponents.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 {
-      await this.libp2pComponents.hangUp(peerId);
+      this.keepAliveManager.stop(peerId);
+      await this.libp2p.hangUp(peerId);
       log(`Dropped connection with peer ${peerId.toString()}`);
     } catch (error) {
       log(
@@ -177,7 +250,7 @@ export class ConnectionManager {
     }
   }
 
-  private async processDialQueue(): Promise<void> {
+  private processDialQueue(): void {
     if (
       this.pendingPeerDialQueue.length > 0 &&
       this.currentActiveDialCount < this.options.maxParallelDials
@@ -191,14 +264,14 @@ export class ConnectionManager {
   }
 
   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"]
     );
@@ -217,7 +290,7 @@ 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"]
     );
@@ -237,41 +310,77 @@ export class ConnectionManager {
   }
 
   private onEventHandlers = {
-    "peer:discovery": async (evt: CustomEvent<PeerInfo>): Promise<void> => {
-      const { id: peerId } = evt.detail;
-
-      this.attemptDial(peerId).catch((err) =>
-        log(`Error dialing peer ${peerId.toString()} : ${err}`)
-      );
+    "peer:discovery": (evt: CustomEvent<PeerInfo>): void => {
+      void (async () => {
+        const { id: peerId } = evt.detail;
+
+        const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(
+          Tags.BOOTSTRAP
+        );
+
+        this.dispatchEvent(
+          new CustomEvent<PeerId>(
+            isBootstrap
+              ? EPeersByDiscoveryEvents.PEER_DISCOVERY_BOOTSTRAP
+              : EPeersByDiscoveryEvents.PEER_DISCOVERY_PEER_EXCHANGE,
+            {
+              detail: peerId,
+            }
+          )
+        );
+
+        try {
+          await this.attemptDial(peerId);
+        } catch (error) {
+          log(`Error dialing peer ${peerId.toString()} : ${error}`);
+        }
+      })();
     },
-    "peer:connect": async (evt: CustomEvent<Connection>): Promise<void> => {
-      const { remotePeer: peerId } = evt.detail;
-
-      this.keepAliveManager.start(
-        peerId,
-        this.libp2pComponents.ping.bind(this)
-      );
-
-      const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(
-        Tags.BOOTSTRAP
-      );
-
-      if (isBootstrap) {
-        const bootstrapConnections = this.libp2pComponents
-          .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);
+    "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);
       };
     },
   };
@@ -282,19 +391,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;
@@ -309,9 +418,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>(
@@ -390,24 +384,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
-  decoders.forEach(async (dec: IDecoder<T>) => {
-    if (didDecodeMsg) return;
-    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"))
     );
-    // const decoded = await dec.fromProtoObj(pubSubTopic, message);
-    if (!decoded) {
-      log("Not able to decode message");
-      return;
-    }
-    // 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/keep_alive_manager.ts

@@ -1,18 +1,14 @@
 import type { PeerId } from "@libp2p/interface-peer-id";
 import type { IRelay } from "@waku/interfaces";
+import type { KeepAliveOptions } from "@waku/interfaces";
 import debug from "debug";
-import type { Libp2p } from "libp2p";
+import type { PingService } from "libp2p/ping";
 
 import { createEncoder } from "../index.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,7 +22,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 +33,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",
       },
     },
   },