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

package/src/lib/base_protocol.ts

@@ -14,7 +14,7 @@ import {
 } from "@waku/utils/libp2p";
 
 import { filterPeersByDiscovery } from "./filterPeers.js";
-import { StreamManager } from "./stream_manager.js";
+import { StreamManager } from "./stream_manager/index.js";
 
 /**
  * A class with predefined helpers, to be used as a base to implement Waku
@@ -25,7 +25,7 @@ export class BaseProtocol implements IBaseProtocolCore {
   public readonly removeLibp2pEventListener: Libp2p["removeEventListener"];
   protected streamManager: StreamManager;
 
-  constructor(
+  protected constructor(
     public multicodec: string,
     private components: Libp2pComponents,
     private log: Logger,
@@ -47,6 +47,7 @@ export class BaseProtocol implements IBaseProtocolCore {
       this.addLibp2pEventListener
     );
   }
+
   protected async getStream(peer: Peer): Promise<Stream> {
     return this.streamManager.getStream(peer);
   }
@@ -81,7 +82,7 @@ export class BaseProtocol implements IBaseProtocolCore {
 
   * @returns A list of peers that support the protocol sorted by latency.
   */
-  async getPeers(
+  public async getPeers(
     {
       numPeers,
       maxBootstrapPeers

package/src/lib/connection_manager.ts

@@ -89,7 +89,7 @@ export class ConnectionManager
     return instance;
   }
 
-  stop(): void {
+  public stop(): void {
     this.keepAliveManager.stopAll();
     this.libp2p.removeEventListener(
       "peer:connect",
@@ -105,7 +105,7 @@ export class ConnectionManager
     );
   }
 
-  async dropConnection(peerId: PeerId): Promise<void> {
+  public async dropConnection(peerId: PeerId): Promise<void> {
     try {
       this.keepAliveManager.stop(peerId);
       await this.libp2p.hangUp(peerId);
@@ -187,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`))
@@ -250,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) {
@@ -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
@@ -57,43 +58,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
       });
   }
 
-  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[]
@@ -147,7 +112,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     };
   }
 
-  async unsubscribe(
+  public async unsubscribe(
     pubsubTopic: PubsubTopic,
     peer: Peer,
     contentTopics: ContentTopic[]
@@ -193,7 +158,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     };
   }
 
-  async unsubscribeAll(
+  public async unsubscribeAll(
     pubsubTopic: PubsubTopic,
     peer: Peer
   ): Promise<CoreProtocolResult> {
@@ -241,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);
@@ -311,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;
   }
 }

package/src/lib/message/version_0.ts

@@ -20,28 +20,28 @@ export const Version = 0;
 export { proto };
 
 export class DecodedMessage implements IDecodedMessage {
-  constructor(
+  public constructor(
     public pubsubTopic: string,
     protected proto: proto.WakuMessage
   ) {}
 
-  get ephemeral(): boolean {
+  public get ephemeral(): boolean {
     return Boolean(this.proto.ephemeral);
   }
 
-  get payload(): Uint8Array {
+  public get payload(): Uint8Array {
     return this.proto.payload;
   }
 
-  get contentTopic(): string {
+  public get contentTopic(): string {
     return this.proto.contentTopic;
   }
 
-  get _rawTimestamp(): bigint | undefined {
+  public get _rawTimestamp(): bigint | undefined {
     return this.proto.timestamp;
   }
 
-  get timestamp(): Date | undefined {
+  public get timestamp(): Date | undefined {
     // In the case we receive a value that is bigger than JS's max number,
     // we catch the error and return undefined.
     try {
@@ -56,23 +56,23 @@ export class DecodedMessage implements IDecodedMessage {
     }
   }
 
-  get meta(): Uint8Array | undefined {
+  public get meta(): Uint8Array | undefined {
     return this.proto.meta;
   }
 
-  get version(): number {
+  public get version(): number {
     // https://rfc.vac.dev/spec/14/
     // > If omitted, the value SHOULD be interpreted as version 0.
     return this.proto.version ?? 0;
   }
 
-  get rateLimitProof(): IRateLimitProof | undefined {
+  public get rateLimitProof(): IRateLimitProof | undefined {
     return this.proto.rateLimitProof;
   }
 }
 
 export class Encoder implements IEncoder {
-  constructor(
+  public constructor(
     public contentTopic: string,
     public ephemeral: boolean = false,
     public pubsubTopic: PubsubTopic,
@@ -83,11 +83,11 @@ export class Encoder implements IEncoder {
     }
   }
 
-  async toWire(message: IMessage): Promise<Uint8Array> {
+  public async toWire(message: IMessage): Promise<Uint8Array> {
     return proto.WakuMessage.encode(await this.toProtoObj(message));
   }
 
-  async toProtoObj(message: IMessage): Promise<IProtoMessage> {
+  public async toProtoObj(message: IMessage): Promise<IProtoMessage> {
     const timestamp = message.timestamp ?? new Date();
 
     const protoMessage = {
@@ -133,7 +133,7 @@ export function createEncoder({
 }
 
 export class Decoder implements IDecoder<DecodedMessage> {
-  constructor(
+  public constructor(
     public pubsubTopic: PubsubTopic,
     public contentTopic: string
   ) {
@@ -142,7 +142,9 @@ export class Decoder implements IDecoder<DecodedMessage> {
     }
   }
 
-  fromWireToProtoObj(bytes: Uint8Array): Promise<IProtoMessage | undefined> {
+  public fromWireToProtoObj(
+    bytes: Uint8Array
+  ): Promise<IProtoMessage | undefined> {
     const protoMessage = proto.WakuMessage.decode(bytes);
     return Promise.resolve({
       payload: protoMessage.payload,
@@ -155,7 +157,7 @@ export class Decoder implements IDecoder<DecodedMessage> {
     });
   }
 
-  async fromProtoObj(
+  public async fromProtoObj(
     pubsubTopic: string,
     proto: IProtoMessage
   ): Promise<DecodedMessage | undefined> {