@waku/core 0.0.9 → 0.0.11

package/src/lib/filter/filter_rpc.ts

@@ -8,16 +8,16 @@ export type ContentFilter = {
 /**
  * FilterRPC represents a message conforming to the Waku Filter protocol
  */
-export class FilterRPC {
-  public constructor(public proto: proto.FilterRPC) {}
+export class FilterRpc {
+  public constructor(public proto: proto.FilterRpc) {}
 
   static createRequest(
     topic: string,
     contentFilters: ContentFilter[],
     requestId?: string,
     subscribe = true
-  ): FilterRPC {
-    return new FilterRPC({
+  ): FilterRpc {
+    return new FilterRpc({
       requestId: requestId || uuid(),
       request: {
         subscribe,
@@ -31,11 +31,11 @@ export class FilterRPC {
   /**
    *
    * @param bytes Uint8Array of bytes from a FilterRPC message
-   * @returns FilterRPC
+   * @returns FilterRpc
    */
-  static decode(bytes: Uint8Array): FilterRPC {
-    const res = proto.FilterRPC.decode(bytes);
-    return new FilterRPC(res);
+  static decode(bytes: Uint8Array): FilterRpc {
+    const res = proto.FilterRpc.decode(bytes);
+    return new FilterRpc(res);
   }
 
   /**
@@ -43,14 +43,14 @@ export class FilterRPC {
    * @returns Uint8Array
    */
   encode(): Uint8Array {
-    return proto.FilterRPC.encode(this.proto);
+    return proto.FilterRpc.encode(this.proto);
   }
 
   get push(): proto.MessagePush | undefined {
     return this.proto.push;
   }
 
-  get requestId(): string | undefined {
+  get requestId(): string {
     return this.proto.requestId;
   }
 }

package/src/lib/filter/index.ts

@@ -1,35 +1,26 @@
-import type { Stream } from "@libp2p/interface-connection";
-import type { ConnectionManager } from "@libp2p/interface-connection-manager";
-import type { PeerId } from "@libp2p/interface-peer-id";
-import type { PeerStore } from "@libp2p/interface-peer-store";
+import type { Libp2p } from "@libp2p/interface-libp2p";
 import type { Peer } from "@libp2p/interface-peer-store";
 import type { IncomingStreamData } from "@libp2p/interface-registrar";
-import type { Registrar } from "@libp2p/interface-registrar";
 import type {
   Callback,
   IDecodedMessage,
   IDecoder,
   IFilter,
-  IMessage,
+  ProtocolCreateOptions,
   ProtocolOptions,
 } from "@waku/interfaces";
-import {
-  getPeersForProtocol,
-  selectConnection,
-  selectPeerForProtocol,
-  selectRandomPeer,
-} from "@waku/libp2p-utils";
 import { WakuMessage as WakuMessageProto } from "@waku/proto";
 import debug from "debug";
 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 { groupByContentTopic } from "../group_by.js";
 import { toProtoMessage } from "../to_proto_message.js";
 
-import { ContentFilter, FilterRPC } from "./filter_rpc.js";
+import { ContentFilter, FilterRpc } from "./filter_rpc.js";
 
 export { ContentFilter };
 
@@ -37,25 +28,14 @@ export const FilterCodec = "/vac/waku/filter/2.0.0-beta1";
 
 const log = debug("waku:filter");
 
-export interface FilterComponents {
-  peerStore: PeerStore;
-  registrar: Registrar;
-  connectionManager: ConnectionManager;
-}
-
-export interface CreateOptions {
-  /**
-   * The PubSub Topic to use. Defaults to {@link DefaultPubSubTopic}.
-   *
-   * The usage of the default pubsub topic is recommended.
-   * See [Waku v2 Topic Usage Recommendations](https://rfc.vac.dev/spec/23/) for details.
-   *
-   * @default {@link DefaultPubSubTopic}
-   */
-  pubSubTopic?: string;
-}
-
 export type UnsubscribeFunction = () => Promise<void>;
+export type RequestID = string;
+
+type Subscription<T extends IDecodedMessage> = {
+  decoders: IDecoder<T>[];
+  callback: Callback<T>;
+  pubSubTopic: string;
+};
 
 /**
  * Implements client side of the [Waku v2 Filter protocol](https://rfc.vac.dev/spec/12/).
@@ -64,20 +44,16 @@ export type UnsubscribeFunction = () => Promise<void>;
  * - https://github.com/status-im/go-waku/issues/245
  * - https://github.com/status-im/nwaku/issues/948
  */
-class Filter implements IFilter {
-  pubSubTopic: string;
-  private subscriptions: Map<string, Callback<any>>;
-  private decoders: Map<
-    string, // content topic
-    Set<IDecoder<any>>
-  >;
+class Filter extends BaseProtocol implements IFilter {
+  options: ProtocolCreateOptions;
+  private subscriptions: Map<RequestID, unknown>;
 
-  constructor(public components: FilterComponents, options?: CreateOptions) {
+  constructor(public libp2p: Libp2p, options?: ProtocolCreateOptions) {
+    super(FilterCodec, libp2p.peerStore, libp2p.getConnections.bind(libp2p));
+    this.options = options ?? {};
     this.subscriptions = new Map();
-    this.decoders = new Map();
-    this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
-    this.components.registrar
-      .handle(FilterCodec, this.onRequest.bind(this))
+    this.libp2p
+      .handle(this.multicodec, this.onRequest.bind(this))
       .catch((e) => log("Failed to register filter protocol", e));
   }
 
@@ -92,26 +68,21 @@ class Filter implements IFilter {
     callback: Callback<T>,
     opts?: ProtocolOptions
   ): Promise<UnsubscribeFunction> {
-    const topic = opts?.pubSubTopic ?? this.pubSubTopic;
+    const { pubSubTopic = DefaultPubSubTopic } = this.options;
 
-    const groupedDecoders = groupByContentTopic(decoders);
-    const contentTopics = Array.from(groupedDecoders.keys());
+    const contentTopics = Array.from(groupByContentTopic(decoders).keys());
 
     const contentFilters = contentTopics.map((contentTopic) => ({
       contentTopic,
     }));
-    const request = FilterRPC.createRequest(
-      topic,
+    const request = FilterRpc.createRequest(
+      pubSubTopic,
       contentFilters,
       undefined,
       true
     );
 
     const requestId = request.requestId;
-    if (!requestId)
-      throw new Error(
-        "Internal error: createRequest expected to set `requestId`"
-      );
 
     const peer = await this.getPeer(opts?.peerId);
     const stream = await this.newStream(peer);
@@ -138,26 +109,21 @@ class Filter implements IFilter {
       throw e;
     }
 
-    this.addDecoders(groupedDecoders);
-    this.addCallback(requestId, callback);
+    const subscription: Subscription<T> = { callback, decoders, pubSubTopic };
+    this.subscriptions.set(requestId, subscription);
 
     return async () => {
-      await this.unsubscribe(topic, contentFilters, requestId, peer);
-      this.deleteDecoders(groupedDecoders);
-      this.deleteCallback(requestId);
+      await this.unsubscribe(pubSubTopic, contentFilters, requestId, peer);
+      this.subscriptions.delete(requestId);
     };
   }
 
-  get peerStore(): PeerStore {
-    return this.components.peerStore;
-  }
-
   private onRequest(streamData: IncomingStreamData): void {
     log("Receiving message push");
     try {
       pipe(streamData.stream, lp.decode(), async (source) => {
         for await (const bytes of source) {
-          const res = FilterRPC.decode(bytes.slice());
+          const res = FilterRpc.decode(bytes.slice());
           if (res.requestId && res.push?.messages?.length) {
             await this.pushMessages(res.requestId, res.push.messages);
           }
@@ -175,13 +141,21 @@ class Filter implements IFilter {
     }
   }
 
-  private async pushMessages(
+  private async pushMessages<T extends IDecodedMessage>(
     requestId: string,
     messages: WakuMessageProto[]
   ): Promise<void> {
-    const callback = this.subscriptions.get(requestId);
-    if (!callback) {
-      log(`No callback registered for request ID ${requestId}`);
+    const subscription = this.subscriptions.get(requestId) as
+      | Subscription<T>
+      | undefined;
+    if (!subscription) {
+      log(`No subscription locally registered for request ID ${requestId}`);
+      return;
+    }
+    const { decoders, callback, pubSubTopic } = subscription;
+
+    if (!decoders || !decoders.length) {
+      log(`No decoder registered for request ID ${requestId}`);
       return;
     }
 
@@ -192,72 +166,35 @@ class Filter implements IFilter {
         return;
       }
 
-      const decoders = this.decoders.get(contentTopic);
-      if (!decoders) {
-        log("No decoder for", contentTopic);
-        return;
-      }
-
-      let msg: IMessage | undefined;
+      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) => {
-        if (msg) return;
-        const decoded = await dec.fromProtoObj(toProtoMessage(protoMessage));
+      decoders.forEach(async (dec: IDecoder<T>) => {
+        if (didDecodeMsg) return;
+        const decoded = await dec.fromProtoObj(
+          pubSubTopic,
+          toProtoMessage(protoMessage)
+        );
         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
-        msg = decoded;
+        didDecodeMsg = Boolean(decoded);
         await callback(decoded);
       });
     }
   }
 
-  private addCallback(requestId: string, callback: Callback<any>): void {
-    this.subscriptions.set(requestId, callback);
-  }
-
-  private deleteCallback(requestId: string): void {
-    this.subscriptions.delete(requestId);
-  }
-
-  private addDecoders<T extends IDecodedMessage>(
-    decoders: Map<string, Array<IDecoder<T>>>
-  ): void {
-    decoders.forEach((decoders, contentTopic) => {
-      const currDecs = this.decoders.get(contentTopic);
-      if (!currDecs) {
-        this.decoders.set(contentTopic, new Set(decoders));
-      } else {
-        this.decoders.set(contentTopic, new Set([...currDecs, ...decoders]));
-      }
-    });
-  }
-
-  private deleteDecoders<T extends IDecodedMessage>(
-    decoders: Map<string, Array<IDecoder<T>>>
-  ): void {
-    decoders.forEach((decoders, contentTopic) => {
-      const currDecs = this.decoders.get(contentTopic);
-      if (currDecs) {
-        decoders.forEach((dec) => {
-          currDecs.delete(dec);
-        });
-      }
-    });
-  }
-
   private async unsubscribe(
     topic: string,
     contentFilters: ContentFilter[],
     requestId: string,
     peer: Peer
   ): Promise<void> {
-    const unsubscribeRequest = FilterRPC.createRequest(
+    const unsubscribeRequest = FilterRpc.createRequest(
       topic,
       contentFilters,
       requestId,
@@ -272,42 +209,10 @@ class Filter implements IFilter {
       throw e;
     }
   }
-
-  private async newStream(peer: Peer): Promise<Stream> {
-    const connections = this.components.connectionManager.getConnections(
-      peer.id
-    );
-    const connection = selectConnection(connections);
-    if (!connection) {
-      throw new Error("Failed to get a connection to the peer");
-    }
-
-    return connection.newStream(FilterCodec);
-  }
-
-  private async getPeer(peerId?: PeerId): Promise<Peer> {
-    const res = await selectPeerForProtocol(
-      this.components.peerStore,
-      [FilterCodec],
-      peerId
-    );
-    if (!res) {
-      throw new Error(`Failed to select peer for ${FilterCodec}`);
-    }
-    return res.peer;
-  }
-
-  async peers(): Promise<Peer[]> {
-    return getPeersForProtocol(this.components.peerStore, [FilterCodec]);
-  }
-
-  async randomPeer(): Promise<Peer | undefined> {
-    return selectRandomPeer(await this.peers());
-  }
 }
 
 export function wakuFilter(
-  init: Partial<CreateOptions> = {}
-): (components: FilterComponents) => IFilter {
-  return (components: FilterComponents) => new Filter(components, init);
+  init: Partial<ProtocolCreateOptions> = {}
+): (libp2p: Libp2p) => IFilter {
+  return (libp2p: Libp2p) => new Filter(libp2p, init);
 }

package/src/lib/group_by.ts

@@ -1,5 +1,5 @@
 export function groupByContentTopic<T extends { contentTopic: string }>(
-  values: T[]
+  values: readonly T[]
 ): Map<string, Array<T>> {
   const groupedDecoders = new Map();
   values.forEach((value) => {

package/src/lib/keep_alive_manager.ts

@@ -0,0 +1,89 @@
+import type { PeerId } from "@libp2p/interface-peer-id";
+import type { IRelay } from "@waku/interfaces";
+import debug from "debug";
+import type { Libp2p } from "libp2p";
+
+import { createEncoder } from "../index.js";
+
+import { RelayPingContentTopic } from "./relay/constants.js";
+
+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>>;
+  private options: KeepAliveOptions;
+  private relay?: IRelay;
+
+  constructor(options: KeepAliveOptions, relay?: IRelay) {
+    this.pingKeepAliveTimers = new Map();
+    this.relayKeepAliveTimers = new Map();
+    this.options = options;
+    this.relay = relay;
+  }
+
+  public start(peerId: PeerId, libp2pPing: Libp2p["ping"]): void {
+    // Just in case a timer already exist for this peer
+    this.stop(peerId);
+
+    const { pingKeepAlive: pingPeriodSecs, relayKeepAlive: relayPeriodSecs } =
+      this.options;
+
+    const peerIdStr = peerId.toString();
+
+    if (pingPeriodSecs !== 0) {
+      const interval = setInterval(() => {
+        libp2pPing(peerId).catch((e) => {
+          log(`Ping failed (${peerIdStr})`, e);
+        });
+      }, pingPeriodSecs * 1000);
+      this.pingKeepAliveTimers.set(peerIdStr, interval);
+    }
+
+    const relay = this.relay;
+    if (relay && relayPeriodSecs !== 0) {
+      const encoder = createEncoder({
+        contentTopic: RelayPingContentTopic,
+        ephemeral: true,
+      });
+      const interval = setInterval(() => {
+        log("Sending Waku Relay ping message");
+        relay
+          .send(encoder, { payload: new Uint8Array([1]) })
+          .catch((e) => log("Failed to send relay ping", e));
+      }, relayPeriodSecs * 1000);
+      this.relayKeepAliveTimers.set(peerId, interval);
+    }
+  }
+
+  public stop(peerId: PeerId): void {
+    const peerIdStr = peerId.toString();
+
+    if (this.pingKeepAliveTimers.has(peerIdStr)) {
+      clearInterval(this.pingKeepAliveTimers.get(peerIdStr));
+      this.pingKeepAliveTimers.delete(peerIdStr);
+    }
+
+    if (this.relayKeepAliveTimers.has(peerId)) {
+      clearInterval(this.relayKeepAliveTimers.get(peerId));
+      this.relayKeepAliveTimers.delete(peerId);
+    }
+  }
+
+  public stopAll(): void {
+    for (const timer of [
+      ...Object.values(this.pingKeepAliveTimers),
+      ...Object.values(this.relayKeepAliveTimers),
+    ]) {
+      clearInterval(timer);
+    }
+
+    this.pingKeepAliveTimers.clear();
+    this.relayKeepAliveTimers.clear();
+  }
+}

package/src/lib/light_push/index.ts

@@ -1,20 +1,13 @@
-import { ConnectionManager } from "@libp2p/interface-connection-manager";
+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 { PeerStore } from "@libp2p/interface-peer-store";
 import type {
   IEncoder,
   ILightPush,
   IMessage,
+  ProtocolCreateOptions,
   ProtocolOptions,
   SendResult,
 } from "@waku/interfaces";
-import {
-  getPeersForProtocol,
-  selectConnection,
-  selectPeerForProtocol,
-  selectRandomPeer,
-} from "@waku/libp2p-utils";
 import { PushResponse } from "@waku/proto";
 import debug from "debug";
 import all from "it-all";
@@ -22,40 +15,25 @@ import * as lp from "it-length-prefixed";
 import { pipe } from "it-pipe";
 import { Uint8ArrayList } from "uint8arraylist";
 
+import { BaseProtocol } from "../base_protocol.js";
 import { DefaultPubSubTopic } from "../constants.js";
 
-import { PushRPC } from "./push_rpc.js";
+import { PushRpc } from "./push_rpc.js";
 
 const log = debug("waku:light-push");
 
 export const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 export { PushResponse };
 
-export interface LightPushComponents {
-  peerStore: PeerStore;
-  connectionManager: ConnectionManager;
-}
-
-export interface CreateOptions {
-  /**
-   * The PubSub Topic to use. Defaults to {@link DefaultPubSubTopic}.
-   *
-   * The usage of the default pubsub topic is recommended.
-   * See [Waku v2 Topic Usage Recommendations](https://rfc.vac.dev/spec/23/) for details.
-   *
-   * @default {@link DefaultPubSubTopic}
-   */
-  pubSubTopic?: string;
-}
-
 /**
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
  */
-class LightPush implements ILightPush {
-  pubSubTopic: string;
+class LightPush extends BaseProtocol implements ILightPush {
+  options: ProtocolCreateOptions;
 
-  constructor(public components: LightPushComponents, options?: CreateOptions) {
-    this.pubSubTopic = options?.pubSubTopic ?? DefaultPubSubTopic;
+  constructor(public libp2p: Libp2p, options?: ProtocolCreateOptions) {
+    super(LightPushCodec, libp2p.peerStore, libp2p.getConnections.bind(libp2p));
+    this.options = options || {};
   }
 
   async push(
@@ -63,27 +41,10 @@ class LightPush implements ILightPush {
     message: IMessage,
     opts?: ProtocolOptions
   ): Promise<SendResult> {
-    const pubSubTopic = opts?.pubSubTopic ? opts.pubSubTopic : this.pubSubTopic;
-
-    const res = await selectPeerForProtocol(
-      this.components.peerStore,
-      [LightPushCodec],
-      opts?.peerId
-    );
-
-    if (!res) {
-      throw new Error("Failed to get a peer");
-    }
-    const { peer } = res;
-
-    const connections = this.components.connectionManager.getConnections(
-      peer.id
-    );
-    const connection = selectConnection(connections);
+    const { pubSubTopic = DefaultPubSubTopic } = this.options;
 
-    if (!connection) throw "Failed to get a connection to the peer";
-
-    const stream = await connection.newStream(LightPushCodec);
+    const peer = await this.getPeer(opts?.peerId);
+    const stream = await this.newStream(peer);
 
     const recipients: PeerId[] = [];
 
@@ -93,7 +54,7 @@ class LightPush implements ILightPush {
         log("Failed to encode to protoMessage, aborting push");
         return { recipients };
       }
-      const query = PushRPC.createRequest(protoMessage, pubSubTopic);
+      const query = PushRpc.createRequest(protoMessage, pubSubTopic);
       const res = await pipe(
         [query.encode()],
         lp.encode(),
@@ -107,7 +68,7 @@ class LightPush implements ILightPush {
           bytes.append(chunk);
         });
 
-        const response = PushRPC.decode(bytes).response;
+        const response = PushRpc.decode(bytes).response;
 
         if (!response) {
           log("No response in PushRPC");
@@ -125,32 +86,10 @@ class LightPush implements ILightPush {
     }
     return { recipients };
   }
-
-  /**
-   * Returns known peers from the address book (`libp2p.peerStore`) that support
-   * light push protocol. Waku may or may not be currently connected to these
-   * peers.
-   */
-  async peers(): Promise<Peer[]> {
-    return getPeersForProtocol(this.components.peerStore, [LightPushCodec]);
-  }
-
-  /**
-   * Returns a random peer that supports light push protocol from the address
-   * book (`libp2p.peerStore`). Waku may or  may not be currently connected to
-   * this peer.
-   */
-  async randomPeer(): Promise<Peer | undefined> {
-    return selectRandomPeer(await this.peers());
-  }
-
-  get peerStore(): PeerStore {
-    return this.components.peerStore;
-  }
 }
 
 export function wakuLightPush(
-  init: Partial<CreateOptions> = {}
-): (components: LightPushComponents) => ILightPush {
-  return (components: LightPushComponents) => new LightPush(components, init);
+  init: Partial<ProtocolCreateOptions> = {}
+): (libp2p: Libp2p) => ILightPush {
+  return (libp2p: Libp2p) => new LightPush(libp2p, init);
 }

package/src/lib/light_push/push_rpc.ts

@@ -2,30 +2,30 @@ import { proto_lightpush as proto } from "@waku/proto";
 import type { Uint8ArrayList } from "uint8arraylist";
 import { v4 as uuid } from "uuid";
 
-export class PushRPC {
-  public constructor(public proto: proto.PushRPC) {}
+export class PushRpc {
+  public constructor(public proto: proto.PushRpc) {}
 
   static createRequest(
     message: proto.WakuMessage,
     pubSubTopic: string
-  ): PushRPC {
-    return new PushRPC({
+  ): PushRpc {
+    return new PushRpc({
       requestId: uuid(),
       request: {
         message: message,
-        pubSubTopic: pubSubTopic,
+        pubsubTopic: pubSubTopic,
       },
       response: undefined,
     });
   }
 
-  static decode(bytes: Uint8ArrayList): PushRPC {
-    const res = proto.PushRPC.decode(bytes);
-    return new PushRPC(res);
+  static decode(bytes: Uint8ArrayList): PushRpc {
+    const res = proto.PushRpc.decode(bytes);
+    return new PushRpc(res);
   }
 
   encode(): Uint8Array {
-    return proto.PushRPC.encode(this.proto);
+    return proto.PushRpc.encode(this.proto);
   }
 
   get query(): proto.PushRequest | undefined {