@waku/core 0.0.37-2ed5ddc.0 → 0.0.37-987c6cd.0

package/src/lib/connection_manager/connection_manager.ts

@@ -12,6 +12,7 @@ import { Libp2p } from "@waku/interfaces";
 import { Logger } from "@waku/utils";
 
 import { ConnectionLimiter } from "./connection_limiter.js";
+import { Dialer } from "./dialer.js";
 import { DiscoveryDialer } from "./discovery_dialer.js";
 import { KeepAliveManager } from "./keep_alive_manager.js";
 import { NetworkMonitor } from "./network_monitor.js";
@@ -38,6 +39,7 @@ export class ConnectionManager implements IConnectionManager {
 
   private readonly keepAliveManager: KeepAliveManager;
   private readonly discoveryDialer: DiscoveryDialer;
+  private readonly dialer: Dialer;
   private readonly shardReader: ShardReader;
   private readonly networkMonitor: NetworkMonitor;
   private readonly connectionLimiter: ConnectionLimiter;
@@ -70,11 +72,16 @@ export class ConnectionManager implements IConnectionManager {
       networkConfig: options.networkConfig
     });
 
-    this.discoveryDialer = new DiscoveryDialer({
+    this.dialer = new Dialer({
       libp2p: options.libp2p,
       shardReader: this.shardReader
     });
 
+    this.discoveryDialer = new DiscoveryDialer({
+      libp2p: options.libp2p,
+      dialer: this.dialer
+    });
+
     this.networkMonitor = new NetworkMonitor({
       libp2p: options.libp2p,
       events: options.events
@@ -82,6 +89,9 @@ export class ConnectionManager implements IConnectionManager {
 
     this.connectionLimiter = new ConnectionLimiter({
       libp2p: options.libp2p,
+      events: options.events,
+      networkMonitor: this.networkMonitor,
+      dialer: this.dialer,
       options: this.options
     });
   }
@@ -109,16 +119,23 @@ export class ConnectionManager implements IConnectionManager {
     protocolCodecs: string[]
   ): Promise<Stream> {
     const ma = mapToPeerIdOrMultiaddr(peer);
-    return this.libp2p.dialProtocol(ma, protocolCodecs);
+    log.info(`Dialing peer ${ma.toString()} with protocols ${protocolCodecs}`);
+
+    // must use libp2p directly instead of dialer because we need to dial the peer right away
+    const stream = await this.libp2p.dialProtocol(ma, protocolCodecs);
+    log.info(`Dialed peer ${ma.toString()} with protocols ${protocolCodecs}`);
+
+    return stream;
   }
 
   public async hangUp(peer: PeerId | MultiaddrInput): Promise<boolean> {
     const peerId = mapToPeerId(peer);
 
     try {
+      log.info(`Dropping connection with peer ${peerId.toString()}`);
       await this.libp2p.hangUp(peerId);
-
       log.info(`Dropped connection with peer ${peerId.toString()}`);
+
       return true;
     } catch (error) {
       log.error(
@@ -132,7 +149,10 @@ export class ConnectionManager implements IConnectionManager {
   public async getConnectedPeers(codec?: string): Promise<Peer[]> {
     const peerIDs = this.libp2p.getPeers();
 
+    log.info(`Getting connected peers for codec ${codec}`);
+
     if (peerIDs.length === 0) {
+      log.info(`No connected peers`);
       return [];
     }
 
@@ -146,10 +166,14 @@ export class ConnectionManager implements IConnectionManager {
       })
     );
 
-    return peers
+    const result = peers
       .filter((p) => !!p)
       .filter((p) => (codec ? (p as Peer).protocols.includes(codec) : true))
       .sort((left, right) => getPeerPing(left) - getPeerPing(right)) as Peer[];
+
+    log.info(`Found ${result.length} connected peers for codec ${codec}`);
+
+    return result;
   }
 
   public isTopicConfigured(pubsubTopic: PubsubTopic): boolean {

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

@@ -3,13 +3,13 @@ import { Multiaddr } from "@multiformats/multiaddr";
 import { Logger } from "@waku/utils";
 import { Libp2p } from "libp2p";
 
-import type { ShardReader } from "./shard_reader.js";
+import { Dialer } from "./dialer.js";
 
 type Libp2pEventHandler<T> = (e: CustomEvent<T>) => void;
 
 type DiscoveryDialerConstructorOptions = {
   libp2p: Libp2p;
-  shardReader: ShardReader;
+  dialer: Dialer;
 };
 
 interface IDiscoveryDialer {
@@ -26,54 +26,27 @@ const log = new Logger("discovery-dialer");
  */
 export class DiscoveryDialer implements IDiscoveryDialer {
   private readonly libp2p: Libp2p;
-  private readonly shardReader: ShardReader;
-
-  private dialingInterval: NodeJS.Timeout | null = null;
-  private dialingQueue: PeerId[] = [];
-  private dialHistory: Set<string> = new Set();
+  private readonly dialer: Dialer;
 
   public constructor(options: DiscoveryDialerConstructorOptions) {
     this.libp2p = options.libp2p;
-    this.shardReader = options.shardReader;
+    this.dialer = options.dialer;
 
     this.onPeerDiscovery = this.onPeerDiscovery.bind(this);
   }
 
   public start(): void {
-    log.info("Starting discovery dialer");
-
     this.libp2p.addEventListener(
       "peer:discovery",
       this.onPeerDiscovery as Libp2pEventHandler<PeerInfo>
     );
-
-    if (!this.dialingInterval) {
-      this.dialingInterval = setInterval(() => {
-        void this.processQueue();
-      }, 500);
-
-      log.info("Started dialing interval processor");
-    }
-
-    this.dialHistory.clear();
   }
 
   public stop(): void {
-    log.info("Stopping discovery dialer");
-
     this.libp2p.removeEventListener(
       "peer:discovery",
       this.onPeerDiscovery as Libp2pEventHandler<PeerInfo>
     );
-
-    if (this.dialingInterval) {
-      clearInterval(this.dialingInterval);
-      this.dialingInterval = null;
-
-      log.info("Stopped dialing interval processor");
-    }
-
-    this.dialHistory.clear();
   }
 
   private async onPeerDiscovery(event: CustomEvent<PeerInfo>): Promise<void> {
@@ -81,74 +54,23 @@ export class DiscoveryDialer implements IDiscoveryDialer {
     log.info(`Discovered new peer: ${peerId}`);
 
     try {
-      const shouldSkip = await this.shouldSkipPeer(peerId);
-
-      if (shouldSkip) {
-        log.info(`Skipping peer: ${peerId}`);
-        return;
-      }
-
       await this.updatePeerStore(peerId, event.detail.multiaddrs);
-
-      if (this.dialingQueue.length === 0) {
-        await this.dialPeer(peerId);
-      } else {
-        this.dialingQueue.push(peerId);
-
-        log.info(
-          `Added peer to dialing queue, queue size: ${this.dialingQueue.length}`
-        );
-      }
+      await this.dialer.dial(peerId);
     } catch (error) {
       log.error(`Error dialing peer ${peerId}`, error);
     }
   }
 
-  private async processQueue(): Promise<void> {
-    if (this.dialingQueue.length === 0) return;
-
-    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(this.dialPeer));
-  }
-
-  private async shouldSkipPeer(peerId: PeerId): Promise<boolean> {
-    if (this.dialHistory.has(peerId.toString())) {
-      return true;
-    }
-
-    const hasShardInfo = await this.shardReader.hasShardInfo(peerId);
-    if (!hasShardInfo) {
-      return false;
-    }
-
-    const isOnSameShard = await this.shardReader.isPeerOnNetwork(peerId);
-    if (!isOnSameShard) {
-      log.info(`Skipping peer ${peerId} - not on same shard`);
-      return true;
-    }
-
-    const hasConnection = this.libp2p.getPeers().some((p) => p.equals(peerId));
-    if (hasConnection) {
-      return true;
-    }
-
-    return false;
-  }
-
   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
         });
@@ -160,9 +82,11 @@ export class DiscoveryDialer implements IDiscoveryDialer {
       );
 
       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
       });
@@ -171,19 +95,6 @@ export class DiscoveryDialer implements IDiscoveryDialer {
     }
   }
 
-  private async dialPeer(peerId: PeerId): Promise<void> {
-    try {
-      log.info(`Dialing peer from queue: ${peerId}`);
-
-      await this.libp2p.dial(peerId);
-      this.dialHistory.add(peerId.toString());
-
-      log.info(`Successfully dialed peer from queue: ${peerId}`);
-    } catch (error) {
-      log.error(`Error dialing peer ${peerId}`, error);
-    }
-  }
-
   private async getPeer(peerId: PeerId): Promise<Peer | undefined> {
     try {
       return await this.libp2p.peerStore.get(peerId);

package/src/lib/connection_manager/network_monitor.ts

@@ -8,6 +8,9 @@ type NetworkMonitorConstructorOptions = {
 interface INetworkMonitor {
   start(): void;
   stop(): void;
+  isConnected(): boolean;
+  isP2PConnected(): boolean;
+  isBrowserConnected(): boolean;
 }
 
 export class NetworkMonitor implements INetworkMonitor {
@@ -52,7 +55,28 @@ export class NetworkMonitor implements INetworkMonitor {
     }
   }
 
+  /**
+   * 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;
@@ -61,7 +85,7 @@ export class NetworkMonitor implements INetworkMonitor {
       // ignore
     }
 
-    return this.isNetworkConnected;
+    return true;
   }
 
   private onConnectedEvent(): void {