@waku/core 0.0.31-ce62600.0 → 0.0.31

package/src/lib/filter/index.ts

@@ -5,7 +5,6 @@ import {
   type CoreProtocolResult,
   type IBaseProtocolCore,
   type Libp2p,
-  type ProtocolCreateOptions,
   ProtocolError,
   type PubsubTopic
 } from "@waku/interfaces";
@@ -32,21 +31,16 @@ 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
+    public readonly pubsubTopics: PubsubTopic[],
+    libp2p: Libp2p
   ) {
-    super(
-      FilterCodecs.SUBSCRIBE,
-      libp2p.components,
-      log,
-      options!.pubsubTopics!,
-      options
-    );
+    super(FilterCodecs.SUBSCRIBE, libp2p.components, log, pubsubTopics);
 
     libp2p
       .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
@@ -57,43 +51,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 +105,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     };
   }
 
-  async unsubscribe(
+  public async unsubscribe(
     pubsubTopic: PubsubTopic,
     peer: Peer,
     contentTopics: ContentTopic[]
@@ -163,7 +121,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
       return {
         success: null,
         failure: {
-          error: ProtocolError.REMOTE_PEER_FAULT,
+          error: ProtocolError.NO_STREAM_AVAILABLE,
           peerId: peer.id
         }
       };
@@ -193,7 +151,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     };
   }
 
-  async unsubscribeAll(
+  public async unsubscribeAll(
     pubsubTopic: PubsubTopic,
     peer: Peer
   ): Promise<CoreProtocolResult> {
@@ -212,7 +170,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     if (!res || !res.length) {
       return {
         failure: {
-          error: ProtocolError.REMOTE_PEER_FAULT,
+          error: ProtocolError.NO_RESPONSE,
           peerId: peer.id
         },
         success: null
@@ -241,7 +199,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);
@@ -253,7 +211,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
       return {
         success: null,
         failure: {
-          error: ProtocolError.REMOTE_PEER_FAULT,
+          error: ProtocolError.NO_STREAM_AVAILABLE,
           peerId: peer.id
         }
       };
@@ -285,7 +243,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
       return {
         success: null,
         failure: {
-          error: ProtocolError.REMOTE_PEER_FAULT,
+          error: ProtocolError.NO_RESPONSE,
           peerId: peer.id
         }
       };
@@ -311,4 +269,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/health_manager.ts

@@ -0,0 +1,90 @@
+import {
+  HealthStatus,
+  type IHealthManager,
+  NodeHealth,
+  type ProtocolHealth,
+  Protocols
+} from "@waku/interfaces";
+
+class HealthManager implements IHealthManager {
+  public static instance: HealthManager;
+  private readonly health: NodeHealth;
+
+  private constructor() {
+    this.health = {
+      overallStatus: HealthStatus.Unhealthy,
+      protocolStatuses: new Map()
+    };
+  }
+
+  public static getInstance(): HealthManager {
+    if (!HealthManager.instance) {
+      HealthManager.instance = new HealthManager();
+    }
+    return HealthManager.instance;
+  }
+
+  public getHealthStatus(): HealthStatus {
+    return this.health.overallStatus;
+  }
+
+  public getProtocolStatus(protocol: Protocols): ProtocolHealth | undefined {
+    return this.health.protocolStatuses.get(protocol);
+  }
+
+  public updateProtocolHealth(
+    multicodec: string,
+    connectedPeers: number
+  ): void {
+    const protocol = this.getNameFromMulticodec(multicodec);
+
+    let status: HealthStatus = HealthStatus.Unhealthy;
+    if (connectedPeers == 1) {
+      status = HealthStatus.MinimallyHealthy;
+    } else if (connectedPeers >= 2) {
+      status = HealthStatus.SufficientlyHealthy;
+    }
+
+    this.health.protocolStatuses.set(protocol, {
+      name: protocol,
+      status: status,
+      lastUpdate: new Date()
+    });
+
+    this.updateOverallHealth();
+  }
+
+  private getNameFromMulticodec(multicodec: string): Protocols {
+    let name: Protocols;
+    if (multicodec.includes("filter")) {
+      name = Protocols.Filter;
+    } else if (multicodec.includes("lightpush")) {
+      name = Protocols.LightPush;
+    } else if (multicodec.includes("store")) {
+      name = Protocols.Store;
+    } else {
+      throw new Error(`Unknown protocol: ${multicodec}`);
+    }
+    return name;
+  }
+
+  private updateOverallHealth(): void {
+    const relevantProtocols = [Protocols.LightPush, Protocols.Filter];
+    const statuses = relevantProtocols.map(
+      (p) => this.getProtocolStatus(p)?.status
+    );
+
+    if (statuses.some((status) => status === HealthStatus.Unhealthy)) {
+      this.health.overallStatus = HealthStatus.Unhealthy;
+    } else if (
+      statuses.some((status) => status === HealthStatus.MinimallyHealthy)
+    ) {
+      this.health.overallStatus = HealthStatus.MinimallyHealthy;
+    } else {
+      this.health.overallStatus = HealthStatus.SufficientlyHealthy;
+    }
+  }
+}
+
+export const getHealthManager = (): HealthManager =>
+  HealthManager.getInstance();

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

@@ -5,8 +5,8 @@ import {
   type IEncoder,
   type IMessage,
   type Libp2p,
-  type ProtocolCreateOptions,
   ProtocolError,
+  PubsubTopic,
   type ThisOrThat
 } from "@waku/interfaces";
 import { PushResponse } from "@waku/proto";
@@ -20,6 +20,7 @@ import { Uint8ArrayList } from "uint8arraylist";
 import { BaseProtocol } from "../base_protocol.js";
 
 import { PushRpc } from "./push_rpc.js";
+import { isRLNResponseError, matchRLNErrorMessage } from "./utils.js";
 
 const log = new Logger("light-push");
 
@@ -32,14 +33,11 @@ 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) {
-    super(
-      LightPushCodec,
-      libp2p.components,
-      log,
-      options!.pubsubTopics!,
-      options
-    );
+  public constructor(
+    public readonly pubsubTopics: PubsubTopic[],
+    libp2p: Libp2p
+  ) {
+    super(LightPushCodec, libp2p.components, log, pubsubTopics);
   }
 
   private async preparePushMessage(
@@ -78,7 +76,7 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
     }
   }
 
-  async send(
+  public async send(
     encoder: IEncoder,
     message: IMessage,
     peer: Peer
@@ -156,7 +154,19 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
       return {
         success: null,
         failure: {
-          error: ProtocolError.REMOTE_PEER_FAULT,
+          error: ProtocolError.NO_RESPONSE,
+          peerId: peer.id
+        }
+      };
+    }
+
+    if (isRLNResponseError(response.info)) {
+      const rlnErrorCase = matchRLNErrorMessage(response.info!);
+      log.error("Remote peer rejected the message: ", rlnErrorCase);
+      return {
+        success: null,
+        failure: {
+          error: rlnErrorCase,
           peerId: peer.id
         }
       };

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/light_push/utils.ts

@@ -0,0 +1,31 @@
+import { ProtocolError } from "@waku/interfaces";
+
+// should match nwaku
+// https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/waku/waku_rln_relay/rln_relay.nim#L309
+// https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/tests/waku_rln_relay/rln/waku_rln_relay_utils.nim#L20
+const RLN_GENERATION_PREFIX_ERROR = "could not generate rln-v2 proof";
+
+export const isRLNResponseError = (info?: string): boolean => {
+  if (!info) {
+    return false;
+  }
+
+  return info.includes(RLN_GENERATION_PREFIX_ERROR);
+};
+
+export const matchRLNErrorMessage = (info: string): ProtocolError => {
+  const rlnErrorMap: { [key: string]: ProtocolError } = {
+    [ProtocolError.RLN_IDENTITY_MISSING]: ProtocolError.RLN_IDENTITY_MISSING,
+    [ProtocolError.RLN_MEMBERSHIP_INDEX]: ProtocolError.RLN_MEMBERSHIP_INDEX,
+    [ProtocolError.RLN_LIMIT_MISSING]: ProtocolError.RLN_LIMIT_MISSING
+  };
+
+  const infoLowerCase = info.toLowerCase();
+  for (const errorKey in rlnErrorMap) {
+    if (infoLowerCase.includes(errorKey.toLowerCase())) {
+      return rlnErrorMap[errorKey];
+    }
+  }
+
+  return ProtocolError.RLN_PROOF_GENERATION;
+};

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> {