@waku/core 0.0.37-7a9850d.0 → 0.0.37-c7682ea.0

package/src/lib/connection_manager/dialer.ts

@@ -0,0 +1,139 @@
+import type { PeerId } from "@libp2p/interface";
+import { Libp2p } from "@waku/interfaces";
+import { Logger } from "@waku/utils";
+
+import { ShardReader } from "./shard_reader.js";
+
+const log = new Logger("dialer");
+
+type DialerConstructorOptions = {
+  libp2p: Libp2p;
+  shardReader: ShardReader;
+};
+
+interface IDialer {
+  start(): void;
+  stop(): void;
+  dial(peerId: PeerId): Promise<void>;
+}
+
+export class Dialer implements IDialer {
+  private readonly libp2p: Libp2p;
+  private readonly shardReader: ShardReader;
+
+  private dialingQueue: PeerId[] = [];
+  private dialHistory: Map<string, number> = new Map();
+  private dialingInterval: NodeJS.Timeout | null = null;
+  private isProcessing = false;
+
+  public constructor(options: DialerConstructorOptions) {
+    this.libp2p = options.libp2p;
+    this.shardReader = options.shardReader;
+  }
+
+  public start(): void {
+    if (!this.dialingInterval) {
+      this.dialingInterval = setInterval(() => {
+        void this.processQueue();
+      }, 500);
+    }
+
+    this.dialHistory.clear();
+  }
+
+  public stop(): void {
+    if (this.dialingInterval) {
+      clearInterval(this.dialingInterval);
+      this.dialingInterval = null;
+    }
+
+    this.dialHistory.clear();
+  }
+
+  public async dial(peerId: PeerId): Promise<void> {
+    const shouldSkip = await this.shouldSkipPeer(peerId);
+
+    if (shouldSkip) {
+      log.info(`Skipping peer: ${peerId}`);
+      return;
+    }
+
+    // If queue is empty and we're not currently processing, dial immediately
+    if (this.dialingQueue.length === 0 && !this.isProcessing) {
+      await this.dialPeer(peerId);
+    } else {
+      // Add to queue
+      this.dialingQueue.push(peerId);
+      log.info(
+        `Added peer to dialing queue, queue size: ${this.dialingQueue.length}`
+      );
+    }
+  }
+
+  private async processQueue(): Promise<void> {
+    if (this.dialingQueue.length === 0 || this.isProcessing) return;
+
+    this.isProcessing = true;
+
+    try {
+      const peersToDial = this.dialingQueue.slice(0, 3);
+      this.dialingQueue = this.dialingQueue.slice(peersToDial.length);
+
+      log.info(
+        `Processing dial queue: dialing ${peersToDial.length} peers, ${this.dialingQueue.length} remaining in queue`
+      );
+
+      await Promise.all(peersToDial.map((peerId) => this.dialPeer(peerId)));
+    } finally {
+      this.isProcessing = false;
+    }
+  }
+
+  private async dialPeer(peerId: PeerId): Promise<void> {
+    try {
+      log.info(`Dialing peer from queue: ${peerId}`);
+
+      await this.libp2p.dial(peerId);
+      this.dialHistory.set(peerId.toString(), Date.now());
+
+      log.info(`Successfully dialed peer from queue: ${peerId}`);
+    } catch (error) {
+      log.error(`Error dialing peer ${peerId}`, error);
+    }
+  }
+
+  private async shouldSkipPeer(peerId: PeerId): Promise<boolean> {
+    const hasConnection = this.libp2p.getPeers().some((p) => p.equals(peerId));
+    if (hasConnection) {
+      log.info(`Skipping peer ${peerId} - already connected`);
+      return true;
+    }
+
+    const lastDialed = this.dialHistory.get(peerId.toString());
+    if (lastDialed && Date.now() - lastDialed < 10_000) {
+      log.info(
+        `Skipping peer ${peerId} - already dialed in the last 10 seconds`
+      );
+      return true;
+    }
+
+    try {
+      const hasShardInfo = await this.shardReader.hasShardInfo(peerId);
+      if (!hasShardInfo) {
+        log.info(`Skipping peer ${peerId} - no shard info`);
+        return false;
+      }
+
+      const isOnSameShard = await this.shardReader.isPeerOnNetwork(peerId);
+      if (!isOnSameShard) {
+        log.info(`Skipping peer ${peerId} - not on same shard`);
+        return true;
+      }
+
+      return false;
+    } catch (error) {
+      log.error(`Error checking shard info for peer ${peerId}`, error);
+      return true; // Skip peer when there's an error
+    }
+  }
+}

package/src/lib/connection_manager/discovery_dialer.ts

@@ -0,0 +1,106 @@
+import { Peer, PeerId, PeerInfo } from "@libp2p/interface";
+import { Multiaddr } from "@multiformats/multiaddr";
+import { Logger } from "@waku/utils";
+import { Libp2p } from "libp2p";
+
+import { Dialer } from "./dialer.js";
+
+type Libp2pEventHandler<T> = (e: CustomEvent<T>) => void;
+
+type DiscoveryDialerConstructorOptions = {
+  libp2p: Libp2p;
+  dialer: Dialer;
+};
+
+interface IDiscoveryDialer {
+  start(): void;
+  stop(): void;
+}
+
+const log = new Logger("discovery-dialer");
+
+/**
+ * This class is responsible for dialing peers that are discovered by the libp2p node.
+ * Managing limits for the peers is out of scope for this class.
+ * Dialing after discovery is needed to identify the peer and get all other information: metadata, protocols, etc.
+ */
+export class DiscoveryDialer implements IDiscoveryDialer {
+  private readonly libp2p: Libp2p;
+  private readonly dialer: Dialer;
+
+  public constructor(options: DiscoveryDialerConstructorOptions) {
+    this.libp2p = options.libp2p;
+    this.dialer = options.dialer;
+
+    this.onPeerDiscovery = this.onPeerDiscovery.bind(this);
+  }
+
+  public start(): void {
+    this.libp2p.addEventListener(
+      "peer:discovery",
+      this.onPeerDiscovery as Libp2pEventHandler<PeerInfo>
+    );
+  }
+
+  public stop(): void {
+    this.libp2p.removeEventListener(
+      "peer:discovery",
+      this.onPeerDiscovery as Libp2pEventHandler<PeerInfo>
+    );
+  }
+
+  private async onPeerDiscovery(event: CustomEvent<PeerInfo>): Promise<void> {
+    const peerId = event.detail.id;
+    log.info(`Discovered new peer: ${peerId}`);
+
+    try {
+      await this.updatePeerStore(peerId, event.detail.multiaddrs);
+      await this.dialer.dial(peerId);
+    } catch (error) {
+      log.error(`Error dialing peer ${peerId}`, error);
+    }
+  }
+
+  private async updatePeerStore(
+    peerId: PeerId,
+    multiaddrs: Multiaddr[]
+  ): Promise<void> {
+    try {
+      log.info(`Updating peer store for ${peerId}`);
+      const peer = await this.getPeer(peerId);
+
+      if (!peer) {
+        log.info(`Peer ${peerId} not found in store, saving`);
+        await this.libp2p.peerStore.save(peerId, {
+          multiaddrs: multiaddrs
+        });
+        return;
+      }
+
+      const hasSameAddr = multiaddrs.every((addr) =>
+        peer.addresses.some((a) => a.multiaddr.equals(addr))
+      );
+
+      if (hasSameAddr) {
+        log.info(`Peer ${peerId} has same addresses in peer store, skipping`);
+        return;
+      }
+
+      log.info(`Merging peer ${peerId} addresses in peer store`);
+      await this.libp2p.peerStore.merge(peerId, {
+        multiaddrs: multiaddrs
+      });
+    } catch (error) {
+      log.error(`Error updating peer store for ${peerId}`, error);
+    }
+  }
+
+  private async getPeer(peerId: PeerId): Promise<Peer | undefined> {
+    try {
+      return await this.libp2p.peerStore.get(peerId);
+    } catch (error) {
+      log.error(`Error getting peer info for ${peerId}`, error);
+      return undefined;
+    }
+  }
+}

package/src/lib/connection_manager/keep_alive_manager.ts

@@ -1,5 +1,5 @@
 import type { PeerId } from "@libp2p/interface";
-import type { IRelay, Libp2p, PeerIdStr } from "@waku/interfaces";
+import type { IEncoder, IRelay, Libp2p } from "@waku/interfaces";
 import { Logger, pubsubTopicToSingleShardInfo } from "@waku/utils";
 import { utf8ToBytes } from "@waku/utils/bytes";
 
@@ -19,7 +19,12 @@ type CreateKeepAliveManagerOptions = {
   relay?: IRelay;
 };
 
-export class KeepAliveManager {
+interface IKeepAliveManager {
+  start(): void;
+  stop(): void;
+}
+
+export class KeepAliveManager implements IKeepAliveManager {
   private readonly relay?: IRelay;
   private readonly libp2p: Libp2p;
 
@@ -27,7 +32,7 @@ export class KeepAliveManager {
 
   private pingKeepAliveTimers: Map<string, ReturnType<typeof setInterval>> =
     new Map();
-  private relayKeepAliveTimers: Map<PeerId, ReturnType<typeof setInterval>[]> =
+  private relayKeepAliveTimers: Map<string, ReturnType<typeof setInterval>[]> =
     new Map();
 
   public constructor({
@@ -38,122 +43,184 @@ export class KeepAliveManager {
     this.options = options;
     this.relay = relay;
     this.libp2p = libp2p;
+
+    this.onPeerConnect = this.onPeerConnect.bind(this);
+    this.onPeerDisconnect = this.onPeerDisconnect.bind(this);
   }
 
-  public start(peerId: PeerId): void {
-    // Just in case a timer already exists for this peer
-    this.stop(peerId);
+  public start(): void {
+    this.libp2p.addEventListener("peer:connect", this.onPeerConnect);
+    this.libp2p.addEventListener("peer:disconnect", this.onPeerDisconnect);
+  }
 
-    const { pingKeepAlive: pingPeriodSecs, relayKeepAlive: relayPeriodSecs } =
-      this.options;
+  public stop(): void {
+    this.libp2p.removeEventListener("peer:connect", this.onPeerConnect);
+    this.libp2p.removeEventListener("peer:disconnect", this.onPeerDisconnect);
 
-    const peerIdStr = peerId.toString();
+    for (const timer of this.pingKeepAliveTimers.values()) {
+      clearInterval(timer);
+    }
 
-    // Ping the peer every pingPeriodSecs seconds
-    // if pingPeriodSecs is 0, don't ping the peer
-    if (pingPeriodSecs !== 0) {
-      const interval = setInterval(() => {
-        void (async () => {
-          let ping: number;
-          try {
-            // ping the peer for keep alive
-            // also update the peer store with the latency
-            try {
-              ping = await this.libp2p.services.ping.ping(peerId);
-              log.info(`Ping succeeded (${peerIdStr})`, ping);
-            } catch (error) {
-              log.error(`Ping failed for peer (${peerIdStr}).
-                Next ping will be attempted in ${pingPeriodSecs} seconds.
-              `);
-              return;
-            }
-
-            try {
-              await this.libp2p.peerStore.merge(peerId, {
-                metadata: {
-                  ping: utf8ToBytes(ping.toString())
-                }
-              });
-            } catch (e) {
-              log.error("Failed to update ping", e);
-            }
-          } catch (e) {
-            log.error(`Ping failed (${peerIdStr})`, e);
-          }
-        })();
-      }, pingPeriodSecs * 1000);
-
-      this.pingKeepAliveTimers.set(peerIdStr, interval);
+    for (const timerArray of this.relayKeepAliveTimers.values()) {
+      for (const timer of timerArray) {
+        clearInterval(timer);
+      }
     }
 
-    const relay = this.relay;
-    if (relay && relayPeriodSecs !== 0) {
-      const intervals = this.scheduleRelayPings(
-        relay,
-        relayPeriodSecs,
-        peerId.toString()
+    this.pingKeepAliveTimers.clear();
+    this.relayKeepAliveTimers.clear();
+  }
+
+  private onPeerConnect(evt: CustomEvent<PeerId>): void {
+    const peerId = evt.detail;
+    this.startPingForPeer(peerId);
+  }
+
+  private onPeerDisconnect(evt: CustomEvent<PeerId>): void {
+    const peerId = evt.detail;
+    this.stopPingForPeer(peerId);
+  }
+
+  private startPingForPeer(peerId: PeerId): void {
+    // Just in case a timer already exists for this peer
+    this.stopPingForPeer(peerId);
+
+    this.startLibp2pPing(peerId);
+    this.startRelayPing(peerId);
+  }
+
+  private stopPingForPeer(peerId: PeerId): void {
+    this.stopLibp2pPing(peerId);
+    this.stopRelayPing(peerId);
+  }
+
+  private startLibp2pPing(peerId: PeerId): void {
+    if (this.options.pingKeepAlive === 0) {
+      log.warn(
+        `Ping keep alive is disabled pingKeepAlive:${this.options.pingKeepAlive}, skipping start for libp2p ping`
       );
-      this.relayKeepAliveTimers.set(peerId, intervals);
+      return;
     }
-  }
 
-  public stop(peerId: PeerId): void {
     const peerIdStr = peerId.toString();
 
     if (this.pingKeepAliveTimers.has(peerIdStr)) {
-      clearInterval(this.pingKeepAliveTimers.get(peerIdStr));
-      this.pingKeepAliveTimers.delete(peerIdStr);
+      log.warn(
+        `Ping already started for peer: ${peerIdStr}, skipping start for libp2p ping`
+      );
+      return;
     }
 
-    if (this.relayKeepAliveTimers.has(peerId)) {
-      this.relayKeepAliveTimers.get(peerId)?.map(clearInterval);
-      this.relayKeepAliveTimers.delete(peerId);
-    }
+    const interval = setInterval(() => {
+      void this.pingLibp2p(peerId);
+    }, this.options.pingKeepAlive * 1000);
+
+    this.pingKeepAliveTimers.set(peerIdStr, interval);
   }
 
-  public stopAll(): void {
-    for (const timer of [
-      ...Object.values(this.pingKeepAliveTimers),
-      ...Object.values(this.relayKeepAliveTimers)
-    ]) {
-      clearInterval(timer);
+  private stopLibp2pPing(peerId: PeerId): void {
+    const peerIdStr = peerId.toString();
+
+    if (!this.pingKeepAliveTimers.has(peerIdStr)) {
+      log.warn(
+        `Ping not started for peer: ${peerIdStr}, skipping stop for ping`
+      );
+      return;
     }
 
-    this.pingKeepAliveTimers.clear();
-    this.relayKeepAliveTimers.clear();
+    clearInterval(this.pingKeepAliveTimers.get(peerIdStr));
+    this.pingKeepAliveTimers.delete(peerIdStr);
   }
 
-  public connectionsExist(): boolean {
-    return (
-      this.pingKeepAliveTimers.size > 0 || this.relayKeepAliveTimers.size > 0
-    );
-  }
+  private startRelayPing(peerId: PeerId): void {
+    if (!this.relay) {
+      return;
+    }
+
+    if (this.options.relayKeepAlive === 0) {
+      log.warn(
+        `Relay keep alive is disabled relayKeepAlive:${this.options.relayKeepAlive}, skipping start for relay ping`
+      );
+      return;
+    }
+
+    if (this.relayKeepAliveTimers.has(peerId.toString())) {
+      log.warn(
+        `Relay ping already started for peer: ${peerId.toString()}, skipping start for relay ping`
+      );
+      return;
+    }
 
-  private scheduleRelayPings(
-    relay: IRelay,
-    relayPeriodSecs: number,
-    peerIdStr: PeerIdStr
-  ): NodeJS.Timeout[] {
-    // send a ping message to each PubsubTopic the peer is part of
     const intervals: NodeJS.Timeout[] = [];
-    for (const topic of relay.pubsubTopics) {
-      const meshPeers = relay.getMeshPeers(topic);
-      if (!meshPeers.includes(peerIdStr)) continue;
+
+    for (const topic of this.relay.pubsubTopics) {
+      const meshPeers = this.relay.getMeshPeers(topic);
+
+      if (!meshPeers.includes(peerId.toString())) {
+        log.warn(
+          `Peer: ${peerId.toString()} is not in the mesh for topic: ${topic}, skipping start for relay ping`
+        );
+        continue;
+      }
 
       const encoder = createEncoder({
         pubsubTopicShardInfo: pubsubTopicToSingleShardInfo(topic),
         contentTopic: RelayPingContentTopic,
         ephemeral: true
       });
+
       const interval = setInterval(() => {
-        log.info("Sending Waku Relay ping message");
-        relay
-          .send(encoder, { payload: new Uint8Array([1]) })
-          .catch((e) => log.error("Failed to send relay ping", e));
-      }, relayPeriodSecs * 1000);
+        void this.pingRelay(encoder);
+      }, this.options.relayKeepAlive * 1000);
+
       intervals.push(interval);
     }
 
-    return intervals;
+    this.relayKeepAliveTimers.set(peerId.toString(), intervals);
+  }
+
+  private stopRelayPing(peerId: PeerId): void {
+    if (!this.relay) {
+      return;
+    }
+
+    const peerIdStr = peerId.toString();
+
+    if (!this.relayKeepAliveTimers.has(peerIdStr)) {
+      log.warn(
+        `Relay ping not started for peer: ${peerIdStr}, skipping stop for relay ping`
+      );
+      return;
+    }
+
+    this.relayKeepAliveTimers.get(peerIdStr)?.map(clearInterval);
+    this.relayKeepAliveTimers.delete(peerIdStr);
+  }
+
+  private async pingRelay(encoder: IEncoder): Promise<void> {
+    try {
+      log.info("Sending Waku Relay ping message");
+      await this.relay!.send(encoder, { payload: new Uint8Array([1]) });
+    } catch (e) {
+      log.error("Failed to send relay ping", e);
+    }
+  }
+
+  private async pingLibp2p(peerId: PeerId): Promise<void> {
+    try {
+      log.info(`Pinging libp2p peer (${peerId.toString()})`);
+      const ping = await this.libp2p.services.ping.ping(peerId);
+
+      log.info(`Ping succeeded (${peerId.toString()})`, ping);
+
+      await this.libp2p.peerStore.merge(peerId, {
+        metadata: {
+          ping: utf8ToBytes(ping.toString())
+        }
+      });
+      log.info(`Ping updated for peer (${peerId.toString()})`);
+    } catch (e) {
+      log.error(`Ping failed for peer (${peerId.toString()})`, e);
+    }
   }
 }

package/src/lib/connection_manager/network_monitor.ts

@@ -0,0 +1,112 @@
+import { IWakuEventEmitter, Libp2p } from "@waku/interfaces";
+
+type NetworkMonitorConstructorOptions = {
+  libp2p: Libp2p;
+  events: IWakuEventEmitter;
+};
+
+interface INetworkMonitor {
+  start(): void;
+  stop(): void;
+  isConnected(): boolean;
+  isP2PConnected(): boolean;
+  isBrowserConnected(): boolean;
+}
+
+export class NetworkMonitor implements INetworkMonitor {
+  private readonly libp2p: Libp2p;
+  private readonly events: IWakuEventEmitter;
+
+  private isNetworkConnected: boolean = false;
+
+  public constructor(options: NetworkMonitorConstructorOptions) {
+    this.libp2p = options.libp2p;
+    this.events = options.events;
+
+    this.onConnectedEvent = this.onConnectedEvent.bind(this);
+    this.onDisconnectedEvent = this.onDisconnectedEvent.bind(this);
+    this.dispatchNetworkEvent = this.dispatchNetworkEvent.bind(this);
+  }
+
+  public start(): void {
+    this.libp2p.addEventListener("peer:connect", this.onConnectedEvent);
+    this.libp2p.addEventListener("peer:disconnect", this.onDisconnectedEvent);
+
+    try {
+      globalThis.addEventListener("online", this.dispatchNetworkEvent);
+      globalThis.addEventListener("offline", this.dispatchNetworkEvent);
+    } catch (err) {
+      // ignore
+    }
+  }
+
+  public stop(): void {
+    this.libp2p.removeEventListener("peer:connect", this.onConnectedEvent);
+    this.libp2p.removeEventListener(
+      "peer:disconnect",
+      this.onDisconnectedEvent
+    );
+
+    try {
+      globalThis.removeEventListener("online", this.dispatchNetworkEvent);
+      globalThis.removeEventListener("offline", this.dispatchNetworkEvent);
+    } catch (err) {
+      // ignore
+    }
+  }
+
+  /**
+   * Returns true if the node is connected to the network via libp2p and browser.
+   */
+  public isConnected(): boolean {
+    if (!this.isBrowserConnected()) {
+      return false;
+    }
+
+    return this.isP2PConnected();
+  }
+
+  /**
+   * Returns true if the node is connected to the network via libp2p.
+   */
+  public isP2PConnected(): boolean {
+    return this.isNetworkConnected;
+  }
+
+  /**
+   * Returns true if the node is connected to the network via browser.
+   */
+  public isBrowserConnected(): boolean {
+    try {
+      if (globalThis?.navigator && !globalThis?.navigator?.onLine) {
+        return false;
+      }
+    } catch (err) {
+      // ignore
+    }
+
+    return true;
+  }
+
+  private onConnectedEvent(): void {
+    if (!this.isNetworkConnected) {
+      this.isNetworkConnected = true;
+      this.dispatchNetworkEvent();
+    }
+  }
+
+  private onDisconnectedEvent(): void {
+    if (this.isNetworkConnected && this.libp2p.getConnections().length === 0) {
+      this.isNetworkConnected = false;
+      this.dispatchNetworkEvent();
+    }
+  }
+
+  private dispatchNetworkEvent(): void {
+    this.events.dispatchEvent(
+      new CustomEvent<boolean>("waku:connection", {
+        detail: this.isConnected()
+      })
+    );
+  }
+}