@waku/core 0.0.30-e49e728.0 → 0.0.31-04bd518.0

package/src/lib/connection_manager.ts

@@ -89,6 +89,34 @@ export class ConnectionManager
     return instance;
   }
 
+  public stop(): void {
+    this.keepAliveManager.stopAll();
+    this.libp2p.removeEventListener(
+      "peer:connect",
+      this.onEventHandlers["peer:connect"]
+    );
+    this.libp2p.removeEventListener(
+      "peer:disconnect",
+      this.onEventHandlers["peer:disconnect"]
+    );
+    this.libp2p.removeEventListener(
+      "peer:discovery",
+      this.onEventHandlers["peer:discovery"]
+    );
+  }
+
+  public async dropConnection(peerId: PeerId): Promise<void> {
+    try {
+      this.keepAliveManager.stop(peerId);
+      await this.libp2p.hangUp(peerId);
+      log.info(`Dropped connection with peer ${peerId.toString()}`);
+    } catch (error) {
+      log.error(
+        `Error dropping connection with peer ${peerId.toString()} - ${error}`
+      );
+    }
+  }
+
   public async getPeersByDiscovery(): Promise<PeersByDiscoveryResult> {
     const peersDiscovered = await this.libp2p.peerStore.all();
     const peersConnected = this.libp2p
@@ -159,7 +187,11 @@ export class ConnectionManager
       ...options
     };
 
-    this.keepAliveManager = new KeepAliveManager(keepAliveOptions, relay);
+    this.keepAliveManager = new KeepAliveManager({
+      relay,
+      libp2p,
+      options: keepAliveOptions
+    });
 
     this.run()
       .then(() => log.info(`Connection Manager is now running`))
@@ -200,22 +232,6 @@ export class ConnectionManager
     this.startPeerDisconnectionListener();
   }
 
-  stop(): void {
-    this.keepAliveManager.stopAll();
-    this.libp2p.removeEventListener(
-      "peer:connect",
-      this.onEventHandlers["peer:connect"]
-    );
-    this.libp2p.removeEventListener(
-      "peer:disconnect",
-      this.onEventHandlers["peer:disconnect"]
-    );
-    this.libp2p.removeEventListener(
-      "peer:discovery",
-      this.onEventHandlers["peer:discovery"]
-    );
-  }
-
   private async dialPeer(peerId: PeerId): Promise<void> {
     this.currentActiveParallelDialCount += 1;
     let dialAttempt = 0;
@@ -238,6 +254,7 @@ export class ConnectionManager
         this.dialAttemptsForPeer.set(peerId.toString(), -1);
 
         // Dialing succeeded, break the loop
+        this.keepAliveManager.start(peerId);
         break;
       } catch (error) {
         if (error instanceof AggregateError) {
@@ -298,18 +315,6 @@ export class ConnectionManager
     }
   }
 
-  private async dropConnection(peerId: PeerId): Promise<void> {
-    try {
-      this.keepAliveManager.stop(peerId);
-      await this.libp2p.hangUp(peerId);
-      log.info(`Dropped connection with peer ${peerId.toString()}`);
-    } catch (error) {
-      log.error(
-        `Error dropping connection with peer ${peerId.toString()} - ${error}`
-      );
-    }
-  }
-
   private processDialQueue(): void {
     if (
       this.pendingPeerDialQueue.length > 0 &&
@@ -356,7 +361,7 @@ export class ConnectionManager
     );
   }
 
-  private async attemptDial(peerId: PeerId): Promise<void> {
+  public async attemptDial(peerId: PeerId): Promise<void> {
     if (!(await this.shouldDialPeer(peerId))) return;
 
     if (this.currentActiveParallelDialCount >= this.options.maxParallelDials) {
@@ -364,9 +369,7 @@ export class ConnectionManager
       return;
     }
 
-    this.dialPeer(peerId).catch((err) => {
-      log.error(`Error dialing peer ${peerId.toString()} : ${err}`);
-    });
+    await this.dialPeer(peerId);
   }
 
   private onEventHandlers = {
@@ -389,11 +392,7 @@ export class ConnectionManager
 
         const peerId = evt.detail;
 
-        this.keepAliveManager.start(
-          peerId,
-          this.libp2p.services.ping,
-          this.libp2p.peerStore
-        );
+        this.keepAliveManager.start(peerId);
 
         const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(
           Tags.BOOTSTRAP
@@ -449,38 +448,40 @@ export class ConnectionManager
    * @returns true if the peer should be dialed, false otherwise
    */
   private async shouldDialPeer(peerId: PeerId): Promise<boolean> {
-    // if we're already connected to the peer, don't dial
     const isConnected = this.libp2p.getConnections(peerId).length > 0;
     if (isConnected) {
       log.warn(`Already connected to peer ${peerId.toString()}. Not dialing.`);
       return false;
     }
 
-    // if the peer is not part of any of the configured pubsub topics, don't dial
-    if (!(await this.isPeerTopicConfigured(peerId))) {
+    const isSameShard = await this.isPeerTopicConfigured(peerId);
+    if (!isSameShard) {
       const shardInfo = await this.getPeerShardInfo(
         peerId,
         this.libp2p.peerStore
       );
+
       log.warn(
         `Discovered peer ${peerId.toString()} with ShardInfo ${shardInfo} is not part of any of the configured pubsub topics (${
           this.configuredPubsubTopics
         }).
             Not dialing.`
       );
+
       return false;
     }
 
-    // if the peer is not dialable based on bootstrap status, don't dial
-    if (!(await this.isPeerDialableBasedOnBootstrapStatus(peerId))) {
+    const isPreferredBasedOnBootstrap =
+      await this.isPeerDialableBasedOnBootstrapStatus(peerId);
+    if (!isPreferredBasedOnBootstrap) {
       log.warn(
         `Peer ${peerId.toString()} is not dialable based on bootstrap status. Not dialing.`
       );
       return false;
     }
 
-    // If the peer is already already has an active dial attempt, or has been dialed before, don't dial it
-    if (this.dialAttemptsForPeer.has(peerId.toString())) {
+    const hasBeenDialed = this.dialAttemptsForPeer.has(peerId.toString());
+    if (hasBeenDialed) {
       log.warn(
         `Peer ${peerId.toString()} has already been attempted dial before, or already has a dial attempt in progress, skipping dial`
       );
@@ -502,19 +503,17 @@ export class ConnectionManager
 
     const isBootstrap = tagNames.some((tagName) => tagName === Tags.BOOTSTRAP);
 
-    if (isBootstrap) {
-      const currentBootstrapConnections = this.libp2p
-        .getConnections()
-        .filter((conn) => {
-          return conn.tags.find((name) => name === Tags.BOOTSTRAP);
-        }).length;
-      if (currentBootstrapConnections < this.options.maxBootstrapPeersAllowed)
-        return true;
-    } else {
+    if (!isBootstrap) {
       return true;
     }
 
-    return false;
+    const currentBootstrapConnections = this.libp2p
+      .getConnections()
+      .filter((conn) => {
+        return conn.tags.find((name) => name === Tags.BOOTSTRAP);
+      }).length;
+
+    return currentBootstrapConnections < this.options.maxBootstrapPeersAllowed;
   }
 
   private async dispatchDiscoveryEvent(peerId: PeerId): Promise<void> {

package/src/lib/filter/filter_rpc.ts

@@ -8,16 +8,16 @@ import { v4 as uuid } from "uuid";
 export class FilterPushRpc {
   public constructor(public proto: proto.MessagePush) {}
 
-  static decode(bytes: Uint8Array): FilterPushRpc {
+  public static decode(bytes: Uint8Array): FilterPushRpc {
     const res = proto.MessagePush.decode(bytes);
     return new FilterPushRpc(res);
   }
 
-  encode(): Uint8Array {
+  public encode(): Uint8Array {
     return proto.MessagePush.encode(this.proto);
   }
 
-  get wakuMessage(): WakuMessage | undefined {
+  public get wakuMessage(): WakuMessage | undefined {
     return this.proto.wakuMessage;
   }
 
@@ -25,7 +25,7 @@ export class FilterPushRpc {
    * Get the pubsub topic from the FilterPushRpc object.
    * @returns string
    */
-  get pubsubTopic(): string | undefined {
+  public get pubsubTopic(): string | undefined {
     return this.proto.pubsubTopic;
   }
 }
@@ -33,7 +33,7 @@ export class FilterPushRpc {
 export class FilterSubscribeRpc {
   public constructor(public proto: proto.FilterSubscribeRequest) {}
 
-  static createSubscribeRequest(
+  public static createSubscribeRequest(
     pubsubTopic: string,
     contentTopics: string[]
   ): FilterSubscribeRpc {
@@ -46,7 +46,7 @@ export class FilterSubscribeRpc {
     });
   }
 
-  static createUnsubscribeRequest(
+  public static createUnsubscribeRequest(
     pubsubTopic: string,
     contentTopics: string[]
   ): FilterSubscribeRpc {
@@ -59,7 +59,9 @@ export class FilterSubscribeRpc {
     });
   }
 
-  static createUnsubscribeAllRequest(pubsubTopic: string): FilterSubscribeRpc {
+  public static createUnsubscribeAllRequest(
+    pubsubTopic: string
+  ): FilterSubscribeRpc {
     return new FilterSubscribeRpc({
       requestId: uuid(),
       filterSubscribeType:
@@ -69,7 +71,7 @@ export class FilterSubscribeRpc {
     });
   }
 
-  static createSubscriberPingRequest(): FilterSubscribeRpc {
+  public static createSubscriberPingRequest(): FilterSubscribeRpc {
     return new FilterSubscribeRpc({
       requestId: uuid(),
       filterSubscribeType:
@@ -79,28 +81,28 @@ export class FilterSubscribeRpc {
     });
   }
 
-  static decode(bytes: Uint8Array): FilterSubscribeRpc {
+  public static decode(bytes: Uint8Array): FilterSubscribeRpc {
     const res = proto.FilterSubscribeRequest.decode(bytes);
     return new FilterSubscribeRpc(res);
   }
 
-  encode(): Uint8Array {
+  public encode(): Uint8Array {
     return proto.FilterSubscribeRequest.encode(this.proto);
   }
 
-  get filterSubscribeType(): proto.FilterSubscribeRequest.FilterSubscribeType {
+  public get filterSubscribeType(): proto.FilterSubscribeRequest.FilterSubscribeType {
     return this.proto.filterSubscribeType;
   }
 
-  get requestId(): string {
+  public get requestId(): string {
     return this.proto.requestId;
   }
 
-  get pubsubTopic(): string | undefined {
+  public get pubsubTopic(): string | undefined {
     return this.proto.pubsubTopic;
   }
 
-  get contentTopics(): string[] {
+  public get contentTopics(): string[] {
     return this.proto.contentTopics;
   }
 }
@@ -108,24 +110,24 @@ export class FilterSubscribeRpc {
 export class FilterSubscribeResponse {
   public constructor(public proto: proto.FilterSubscribeResponse) {}
 
-  static decode(bytes: Uint8Array): FilterSubscribeResponse {
+  public static decode(bytes: Uint8Array): FilterSubscribeResponse {
     const res = proto.FilterSubscribeResponse.decode(bytes);
     return new FilterSubscribeResponse(res);
   }
 
-  encode(): Uint8Array {
+  public encode(): Uint8Array {
     return proto.FilterSubscribeResponse.encode(this.proto);
   }
 
-  get statusCode(): number {
+  public get statusCode(): number {
     return this.proto.statusCode;
   }
 
-  get statusDesc(): string | undefined {
+  public get statusDesc(): string | undefined {
     return this.proto.statusDesc;
   }
 
-  get requestId(): string {
+  public get requestId(): string {
     return this.proto.requestId;
   }
 }

package/src/lib/filter/index.ts

@@ -32,10 +32,11 @@ export const FilterCodecs = {
 };
 
 export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
-  constructor(
+  public constructor(
     private handleIncomingMessage: (
       pubsubTopic: PubsubTopic,
-      wakuMessage: WakuMessage
+      wakuMessage: WakuMessage,
+      peerIdStr: string
     ) => Promise<void>,
     libp2p: Libp2p,
     options?: ProtocolCreateOptions
@@ -48,48 +49,16 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
       options
     );
 
-    libp2p.handle(FilterCodecs.PUSH, this.onRequest.bind(this)).catch((e) => {
-      log.error("Failed to register ", FilterCodecs.PUSH, e);
-    });
+    libp2p
+      .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
+        maxInboundStreams: 100
+      })
+      .catch((e) => {
+        log.error("Failed to register ", FilterCodecs.PUSH, e);
+      });
   }
 
-  private onRequest(streamData: IncomingStreamData): void {
-    const { connection, stream } = streamData;
-    const { remotePeer } = connection;
-    log.info(`Received message from ${remotePeer.toString()}`);
-    try {
-      pipe(stream, lp.decode, async (source) => {
-        for await (const bytes of source) {
-          const response = FilterPushRpc.decode(bytes.slice());
-
-          const { pubsubTopic, wakuMessage } = response;
-
-          if (!wakuMessage) {
-            log.error("Received empty message");
-            return;
-          }
-
-          if (!pubsubTopic) {
-            log.error("Pubsub topic missing from push message");
-            return;
-          }
-
-          await this.handleIncomingMessage(pubsubTopic, wakuMessage);
-        }
-      }).then(
-        () => {
-          log.info("Receiving pipe closed.");
-        },
-        (e) => {
-          log.error("Error with receiving pipe", e);
-        }
-      );
-    } catch (e) {
-      log.error("Error decoding message", e);
-    }
-  }
-
-  async subscribe(
+  public async subscribe(
     pubsubTopic: PubsubTopic,
     peer: Peer,
     contentTopics: ContentTopic[]
@@ -143,7 +112,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     };
   }
 
-  async unsubscribe(
+  public async unsubscribe(
     pubsubTopic: PubsubTopic,
     peer: Peer,
     contentTopics: ContentTopic[]
@@ -189,7 +158,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     };
   }
 
-  async unsubscribeAll(
+  public async unsubscribeAll(
     pubsubTopic: PubsubTopic,
     peer: Peer
   ): Promise<CoreProtocolResult> {
@@ -237,7 +206,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     };
   }
 
-  async ping(peer: Peer): Promise<CoreProtocolResult> {
+  public async ping(peer: Peer): Promise<CoreProtocolResult> {
     let stream: Stream | undefined;
     try {
       stream = await this.getStream(peer);
@@ -307,4 +276,44 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
       failure: null
     };
   }
+
+  private onRequest(streamData: IncomingStreamData): void {
+    const { connection, stream } = streamData;
+    const { remotePeer } = connection;
+    log.info(`Received message from ${remotePeer.toString()}`);
+    try {
+      pipe(stream, lp.decode, async (source) => {
+        for await (const bytes of source) {
+          const response = FilterPushRpc.decode(bytes.slice());
+
+          const { pubsubTopic, wakuMessage } = response;
+
+          if (!wakuMessage) {
+            log.error("Received empty message");
+            return;
+          }
+
+          if (!pubsubTopic) {
+            log.error("Pubsub topic missing from push message");
+            return;
+          }
+
+          await this.handleIncomingMessage(
+            pubsubTopic,
+            wakuMessage,
+            connection.remotePeer.toString()
+          );
+        }
+      }).then(
+        () => {
+          log.info("Receiving pipe closed.");
+        },
+        (e) => {
+          log.error("Error with receiving pipe", e);
+        }
+      );
+    } catch (e) {
+      log.error("Error decoding message", e);
+    }
+  }
 }

package/src/lib/keep_alive_manager.ts

@@ -1,6 +1,5 @@
-import type { PeerId, PeerStore } from "@libp2p/interface";
-import type { PingService } from "@libp2p/ping";
-import type { IRelay, PeerIdStr } from "@waku/interfaces";
+import type { PeerId } from "@libp2p/interface";
+import type { IRelay, Libp2p, PeerIdStr } from "@waku/interfaces";
 import type { KeepAliveOptions } from "@waku/interfaces";
 import { Logger, pubsubTopicToSingleShardInfo } from "@waku/utils";
 import { utf8ToBytes } from "@waku/utils/bytes";
@@ -10,24 +9,34 @@ import { createEncoder } from "./message/version_0.js";
 export const RelayPingContentTopic = "/relay-ping/1/ping/null";
 const log = new Logger("keep-alive");
 
+type CreateKeepAliveManagerOptions = {
+  options: KeepAliveOptions;
+  libp2p: Libp2p;
+  relay?: IRelay;
+};
+
 export class KeepAliveManager {
-  private pingKeepAliveTimers: Map<string, ReturnType<typeof setInterval>>;
-  private relayKeepAliveTimers: Map<PeerId, ReturnType<typeof setInterval>[]>;
-  private options: KeepAliveOptions;
-  private relay?: IRelay;
-
-  constructor(options: KeepAliveOptions, relay?: IRelay) {
-    this.pingKeepAliveTimers = new Map();
-    this.relayKeepAliveTimers = new Map();
+  private readonly relay?: IRelay;
+  private readonly libp2p: Libp2p;
+
+  private readonly options: KeepAliveOptions;
+
+  private pingKeepAliveTimers: Map<string, ReturnType<typeof setInterval>> =
+    new Map();
+  private relayKeepAliveTimers: Map<PeerId, ReturnType<typeof setInterval>[]> =
+    new Map();
+
+  public constructor({
+    options,
+    relay,
+    libp2p
+  }: CreateKeepAliveManagerOptions) {
     this.options = options;
     this.relay = relay;
+    this.libp2p = libp2p;
   }
 
-  public start(
-    peerId: PeerId,
-    libp2pPing: PingService,
-    peerStore: PeerStore
-  ): void {
+  public start(peerId: PeerId): void {
     // Just in case a timer already exists for this peer
     this.stop(peerId);
 
@@ -46,7 +55,7 @@ export class KeepAliveManager {
             // ping the peer for keep alive
             // also update the peer store with the latency
             try {
-              ping = await libp2pPing.ping(peerId);
+              ping = await this.libp2p.services.ping.ping(peerId);
               log.info(`Ping succeeded (${peerIdStr})`, ping);
             } catch (error) {
               log.error(`Ping failed for peer (${peerIdStr}).
@@ -56,7 +65,7 @@ export class KeepAliveManager {
             }
 
             try {
-              await peerStore.merge(peerId, {
+              await this.libp2p.peerStore.merge(peerId, {
                 metadata: {
                   ping: utf8ToBytes(ping.toString())
                 }

package/src/lib/light_push/index.ts

@@ -32,7 +32,7 @@ type PreparePushMessageResult = ThisOrThat<"query", PushRpc>;
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
  */
 export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
-  constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
+  public constructor(libp2p: Libp2p, options?: ProtocolCreateOptions) {
     super(
       LightPushCodec,
       libp2p.components,
@@ -78,7 +78,7 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
     }
   }
 
-  async send(
+  public async send(
     encoder: IEncoder,
     message: IMessage,
     peer: Peer

package/src/lib/light_push/push_rpc.ts

@@ -5,7 +5,7 @@ import { v4 as uuid } from "uuid";
 export class PushRpc {
   public constructor(public proto: proto.PushRpc) {}
 
-  static createRequest(
+  public static createRequest(
     message: proto.WakuMessage,
     pubsubTopic: string
   ): PushRpc {
@@ -19,20 +19,20 @@ export class PushRpc {
     });
   }
 
-  static decode(bytes: Uint8ArrayList): PushRpc {
+  public static decode(bytes: Uint8ArrayList): PushRpc {
     const res = proto.PushRpc.decode(bytes);
     return new PushRpc(res);
   }
 
-  encode(): Uint8Array {
+  public encode(): Uint8Array {
     return proto.PushRpc.encode(this.proto);
   }
 
-  get query(): proto.PushRequest | undefined {
+  public get query(): proto.PushRequest | undefined {
     return this.proto.request;
   }
 
-  get response(): proto.PushResponse | undefined {
+  public get response(): proto.PushResponse | undefined {
     return this.proto.response;
   }
 }