@waku/core 0.0.34-c41b319.0 → 0.0.34-c43cec2.0

package/src/lib/connection_manager/connection_manager.ts

@@ -1,14 +1,5 @@
-import {
-  type Connection,
-  isPeerId,
-  type Peer,
-  type PeerId,
-  type PeerInfo,
-  type PeerStore,
-  type Stream,
-  TypedEventEmitter
-} from "@libp2p/interface";
-import { Multiaddr, multiaddr, MultiaddrInput } from "@multiformats/multiaddr";
+import type { Peer, PeerId, PeerInfo, PeerStore } from "@libp2p/interface";
+import { TypedEventEmitter } from "@libp2p/interface";
 import {
   ConnectionManagerOptions,
   DiscoveryTrigger,
@@ -239,60 +230,15 @@ export class ConnectionManager
     this.startNetworkStatusListener();
   }
 
-  /**
-   * Attempts to establish a connection with a peer and set up specified protocols.
-   * The method handles both PeerId and Multiaddr inputs, manages connection attempts,
-   * and maintains the connection state.
-   *
-   * The dialing process includes:
-   * 1. Converting input to dialable peer info
-   * 2. Managing parallel dial attempts
-   * 3. Attempting to establish protocol-specific connections
-   * 4. Handling connection failures and retries
-   * 5. Updating the peer store and connection state
-   *
-   * @param {PeerId | MultiaddrInput} peer - The peer to connect to, either as a PeerId or multiaddr
-   * @param {string[]} [protocolCodecs] - Optional array of protocol-specific codec strings to establish
-   *                                      (e.g., for LightPush, Filter, Store protocols)
-   *
-   * @throws {Error} If the multiaddr is missing a peer ID
-   * @throws {Error} If the maximum dial attempts are reached and the peer cannot be dialed
-   * @throws {Error} If there's an error deleting an undialable peer from the peer store
-   *
-   * @example
-   * ```typescript
-   * // Dial using PeerId
-   * await connectionManager.dialPeer(peerId);
-   *
-   * // Dial using multiaddr with specific protocols
-   * await connectionManager.dialPeer(multiaddr, [
-   *   "/vac/waku/relay/2.0.0",
-   *   "/vac/waku/lightpush/2.0.0-beta1"
-   * ]);
-   * ```
-   *
-   * @remarks
-   * - The method implements exponential backoff through multiple dial attempts
-   * - Maintains a queue for parallel dial attempts (limited by maxParallelDials)
-   * - Integrates with the KeepAliveManager for connection maintenance
-   * - Updates the peer store and connection state after successful/failed attempts
-   * - If all dial attempts fail, triggers DNS discovery as a fallback
-   */
-  public async dialPeer(peer: PeerId | MultiaddrInput): Promise<Connection> {
-    let connection: Connection | undefined;
-    let peerId: PeerId | undefined;
-    const peerDialInfo = this.getDialablePeerInfo(peer);
-    const peerIdStr = isPeerId(peerDialInfo)
-      ? peerDialInfo.toString()
-      : peerDialInfo.getPeerId()!;
-
+  private async dialPeer(peerId: PeerId): Promise<void> {
     this.currentActiveParallelDialCount += 1;
     let dialAttempt = 0;
     while (dialAttempt < this.options.maxDialAttemptsForPeer) {
       try {
-        log.info(`Dialing peer ${peerDialInfo} on attempt ${dialAttempt + 1}`);
-        connection = await this.libp2p.dial(peerDialInfo);
-        peerId = connection.remotePeer;
+        log.info(
+          `Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`
+        );
+        await this.libp2p.dial(peerId);
 
         const tags = await this.getTagNamesForPeer(peerId);
         // add tag to connection describing discovery mechanism
@@ -311,17 +257,21 @@ export class ConnectionManager
       } catch (error) {
         if (error instanceof AggregateError) {
           // Handle AggregateError
-          log.error(`Error dialing peer ${peerIdStr} - ${error.errors}`);
+          log.error(
+            `Error dialing peer ${peerId.toString()} - ${error.errors}`
+          );
         } else {
           // Handle generic error
           log.error(
-            `Error dialing peer ${peerIdStr} - ${(error as any).message}`
+            `Error dialing peer ${peerId.toString()} - ${
+              (error as any).message
+            }`
           );
         }
-        this.dialErrorsForPeer.set(peerIdStr, error);
+        this.dialErrorsForPeer.set(peerId.toString(), error);
 
         dialAttempt++;
-        this.dialAttemptsForPeer.set(peerIdStr, dialAttempt);
+        this.dialAttemptsForPeer.set(peerId.toString(), dialAttempt);
       }
     }
 
@@ -332,7 +282,7 @@ export class ConnectionManager
     // If max dial attempts reached and dialing failed, delete the peer
     if (dialAttempt === this.options.maxDialAttemptsForPeer) {
       try {
-        const error = this.dialErrorsForPeer.get(peerIdStr);
+        const error = this.dialErrorsForPeer.get(peerId.toString());
 
         if (error) {
           let errorMessage;
@@ -349,65 +299,21 @@ export class ConnectionManager
           }
 
           log.info(
-            `Deleting undialable peer ${peerIdStr} from peer store. Reason: ${errorMessage}`
+            `Deleting undialable peer ${peerId.toString()} from peer store. Reason: ${errorMessage}`
           );
         }
 
-        this.dialErrorsForPeer.delete(peerIdStr);
-        if (peerId) {
-          await this.libp2p.peerStore.delete(peerId);
-        }
+        this.dialErrorsForPeer.delete(peerId.toString());
+        await this.libp2p.peerStore.delete(peerId);
 
         // if it was last available peer - attempt DNS discovery
         await this.attemptDnsDiscovery();
       } catch (error) {
         throw new Error(
-          `Error deleting undialable peer ${peerIdStr} from peer store - ${error}`
+          `Error deleting undialable peer ${peerId.toString()} from peer store - ${error}`
         );
       }
     }
-
-    if (!connection) {
-      throw new Error(`Failed to dial peer ${peerDialInfo}`);
-    }
-
-    return connection;
-  }
-
-  /**
-   * Dial a peer with specific protocols.
-   * This method is a raw proxy to the libp2p dialProtocol method.
-   * @param peer - The peer to connect to, either as a PeerId or multiaddr
-   * @param protocolCodecs - Optional array of protocol-specific codec strings to establish
-   * @returns A stream to the peer
-   */
-  public async rawDialPeerWithProtocols(
-    peer: PeerId | MultiaddrInput,
-    protocolCodecs: string[]
-  ): Promise<Stream> {
-    const peerDialInfo = this.getDialablePeerInfo(peer);
-    return await this.libp2p.dialProtocol(peerDialInfo, protocolCodecs);
-  }
-
-  /**
-   * Internal utility to extract a PeerId or Multiaddr from a peer input.
-   * This is used internally by the connection manager to handle different peer input formats.
-   * @internal
-   */
-  private getDialablePeerInfo(
-    peer: PeerId | MultiaddrInput
-  ): PeerId | Multiaddr {
-    if (isPeerId(peer)) {
-      return peer;
-    } else {
-      // peer is of MultiaddrInput type
-      const ma = multiaddr(peer);
-      const peerIdStr = ma.getPeerId();
-      if (!peerIdStr) {
-        throw new Error("Failed to dial multiaddr: missing peer ID");
-      }
-      return ma;
-    }
   }
 
   private async attemptDnsDiscovery(): Promise<void> {

package/src/lib/filter/index.ts

@@ -1 +1,315 @@
-export { FilterCodecs, FilterCore } from "./filter.js";
+import type { Peer, Stream } from "@libp2p/interface";
+import type { IncomingStreamData } from "@libp2p/interface-internal";
+import {
+  type ContentTopic,
+  type CoreProtocolResult,
+  type IBaseProtocolCore,
+  type Libp2p,
+  ProtocolError,
+  type PubsubTopic
+} from "@waku/interfaces";
+import { WakuMessage } from "@waku/proto";
+import { Logger } from "@waku/utils";
+import all from "it-all";
+import * as lp from "it-length-prefixed";
+import { pipe } from "it-pipe";
+import { Uint8ArrayList } from "uint8arraylist";
+
+import { BaseProtocol } from "../base_protocol.js";
+
+import {
+  FilterPushRpc,
+  FilterSubscribeResponse,
+  FilterSubscribeRpc
+} from "./filter_rpc.js";
+
+const log = new Logger("filter:v2");
+
+export const FilterCodecs = {
+  SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
+  PUSH: "/vac/waku/filter-push/2.0.0-beta1"
+};
+
+export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
+  public constructor(
+    private handleIncomingMessage: (
+      pubsubTopic: PubsubTopic,
+      wakuMessage: WakuMessage,
+      peerIdStr: string
+    ) => Promise<void>,
+    public readonly pubsubTopics: PubsubTopic[],
+    libp2p: Libp2p
+  ) {
+    super(FilterCodecs.SUBSCRIBE, libp2p.components, pubsubTopics);
+
+    libp2p
+      .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
+        maxInboundStreams: 100
+      })
+      .catch((e) => {
+        log.error("Failed to register ", FilterCodecs.PUSH, e);
+      });
+  }
+
+  public async subscribe(
+    pubsubTopic: PubsubTopic,
+    peer: Peer,
+    contentTopics: ContentTopic[]
+  ): Promise<CoreProtocolResult> {
+    const stream = await this.getStream(peer);
+
+    const request = FilterSubscribeRpc.createSubscribeRequest(
+      pubsubTopic,
+      contentTopics
+    );
+
+    let res: Uint8ArrayList[] | undefined;
+    try {
+      res = await pipe(
+        [request.encode()],
+        lp.encode,
+        stream,
+        lp.decode,
+        async (source) => await all(source)
+      );
+    } catch (error) {
+      log.error("Failed to send subscribe request", error);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.GENERIC_FAIL,
+          peerId: peer.id
+        }
+      };
+    }
+
+    const { statusCode, requestId, statusDesc } =
+      FilterSubscribeResponse.decode(res[0].slice());
+
+    if (statusCode < 200 || statusCode >= 300) {
+      log.error(
+        `Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`
+      );
+      return {
+        failure: {
+          error: ProtocolError.REMOTE_PEER_REJECTED,
+          peerId: peer.id
+        },
+        success: null
+      };
+    }
+
+    return {
+      failure: null,
+      success: peer.id
+    };
+  }
+
+  public async unsubscribe(
+    pubsubTopic: PubsubTopic,
+    peer: Peer,
+    contentTopics: ContentTopic[]
+  ): Promise<CoreProtocolResult> {
+    let stream: Stream | undefined;
+    try {
+      stream = await this.getStream(peer);
+    } catch (error) {
+      log.error(
+        `Failed to get a stream for remote peer${peer.id.toString()}`,
+        error
+      );
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.NO_STREAM_AVAILABLE,
+          peerId: peer.id
+        }
+      };
+    }
+
+    const unsubscribeRequest = FilterSubscribeRpc.createUnsubscribeRequest(
+      pubsubTopic,
+      contentTopics
+    );
+
+    try {
+      await pipe([unsubscribeRequest.encode()], lp.encode, stream.sink);
+    } catch (error) {
+      log.error("Failed to send unsubscribe request", error);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.GENERIC_FAIL,
+          peerId: peer.id
+        }
+      };
+    }
+
+    return {
+      success: peer.id,
+      failure: null
+    };
+  }
+
+  public async unsubscribeAll(
+    pubsubTopic: PubsubTopic,
+    peer: Peer
+  ): Promise<CoreProtocolResult> {
+    const stream = await this.getStream(peer);
+
+    const request = FilterSubscribeRpc.createUnsubscribeAllRequest(pubsubTopic);
+
+    const res = await pipe(
+      [request.encode()],
+      lp.encode,
+      stream,
+      lp.decode,
+      async (source) => await all(source)
+    );
+
+    if (!res || !res.length) {
+      return {
+        failure: {
+          error: ProtocolError.NO_RESPONSE,
+          peerId: peer.id
+        },
+        success: null
+      };
+    }
+
+    const { statusCode, requestId, statusDesc } =
+      FilterSubscribeResponse.decode(res[0].slice());
+
+    if (statusCode < 200 || statusCode >= 300) {
+      log.error(
+        `Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`
+      );
+      return {
+        failure: {
+          error: ProtocolError.REMOTE_PEER_REJECTED,
+          peerId: peer.id
+        },
+        success: null
+      };
+    }
+
+    return {
+      failure: null,
+      success: peer.id
+    };
+  }
+
+  public async ping(peer: Peer): Promise<CoreProtocolResult> {
+    let stream: Stream | undefined;
+    try {
+      stream = await this.getStream(peer);
+    } catch (error) {
+      log.error(
+        `Failed to get a stream for remote peer${peer.id.toString()}`,
+        error
+      );
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.NO_STREAM_AVAILABLE,
+          peerId: peer.id
+        }
+      };
+    }
+
+    const request = FilterSubscribeRpc.createSubscriberPingRequest();
+
+    let res: Uint8ArrayList[] | undefined;
+    try {
+      res = await pipe(
+        [request.encode()],
+        lp.encode,
+        stream,
+        lp.decode,
+        async (source) => await all(source)
+      );
+    } catch (error) {
+      log.error("Failed to send ping request", error);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.GENERIC_FAIL,
+          peerId: peer.id
+        }
+      };
+    }
+
+    if (!res || !res.length) {
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.NO_RESPONSE,
+          peerId: peer.id
+        }
+      };
+    }
+
+    const { statusCode, requestId, statusDesc } =
+      FilterSubscribeResponse.decode(res[0].slice());
+
+    if (statusCode < 200 || statusCode >= 300) {
+      log.error(
+        `Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`
+      );
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.REMOTE_PEER_REJECTED,
+          peerId: peer.id
+        }
+      };
+    }
+    return {
+      success: peer.id,
+      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.");
+        },
+        async (e) => {
+          log.error(
+            `Error with receiving pipe on peer:${connection.remotePeer.toString()} -- stream:${stream.id} -- protocol:${stream.protocol}: `,
+            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();