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

package/src/lib/connection_manager/connection_manager.ts

@@ -1,5 +1,14 @@
-import type { Peer, PeerId, PeerInfo, PeerStore } from "@libp2p/interface";
-import { TypedEventEmitter } from "@libp2p/interface";
+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 {
   ConnectionManagerOptions,
   DiscoveryTrigger,
@@ -230,15 +239,60 @@ export class ConnectionManager
     this.startNetworkStatusListener();
   }
 
-  private async dialPeer(peerId: PeerId): Promise<void> {
+  /**
+   * 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()!;
+
     this.currentActiveParallelDialCount += 1;
     let dialAttempt = 0;
     while (dialAttempt < this.options.maxDialAttemptsForPeer) {
       try {
-        log.info(
-          `Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`
-        );
-        await this.libp2p.dial(peerId);
+        log.info(`Dialing peer ${peerDialInfo} on attempt ${dialAttempt + 1}`);
+        connection = await this.libp2p.dial(peerDialInfo);
+        peerId = connection.remotePeer;
 
         const tags = await this.getTagNamesForPeer(peerId);
         // add tag to connection describing discovery mechanism
@@ -257,21 +311,17 @@ export class ConnectionManager
       } catch (error) {
         if (error instanceof AggregateError) {
           // Handle AggregateError
-          log.error(
-            `Error dialing peer ${peerId.toString()} - ${error.errors}`
-          );
+          log.error(`Error dialing peer ${peerIdStr} - ${error.errors}`);
         } else {
           // Handle generic error
           log.error(
-            `Error dialing peer ${peerId.toString()} - ${
-              (error as any).message
-            }`
+            `Error dialing peer ${peerIdStr} - ${(error as any).message}`
           );
         }
-        this.dialErrorsForPeer.set(peerId.toString(), error);
+        this.dialErrorsForPeer.set(peerIdStr, error);
 
         dialAttempt++;
-        this.dialAttemptsForPeer.set(peerId.toString(), dialAttempt);
+        this.dialAttemptsForPeer.set(peerIdStr, dialAttempt);
       }
     }
 
@@ -282,7 +332,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(peerId.toString());
+        const error = this.dialErrorsForPeer.get(peerIdStr);
 
         if (error) {
           let errorMessage;
@@ -299,21 +349,65 @@ export class ConnectionManager
           }
 
           log.info(
-            `Deleting undialable peer ${peerId.toString()} from peer store. Reason: ${errorMessage}`
+            `Deleting undialable peer ${peerIdStr} from peer store. Reason: ${errorMessage}`
           );
         }
 
-        this.dialErrorsForPeer.delete(peerId.toString());
-        await this.libp2p.peerStore.delete(peerId);
+        this.dialErrorsForPeer.delete(peerIdStr);
+        if (peerId) {
+          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 ${peerId.toString()} from peer store - ${error}`
+          `Error deleting undialable peer ${peerIdStr} 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/filter.ts

@@ -0,0 +1,315 @@
+import type { PeerId, 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,
+    peerId: PeerId,
+    contentTopics: ContentTopic[]
+  ): Promise<CoreProtocolResult> {
+    const stream = await this.getStream(peerId);
+
+    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: peerId
+        }
+      };
+    }
+
+    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: peerId
+        },
+        success: null
+      };
+    }
+
+    return {
+      failure: null,
+      success: peerId
+    };
+  }
+
+  public async unsubscribe(
+    pubsubTopic: PubsubTopic,
+    peerId: PeerId,
+    contentTopics: ContentTopic[]
+  ): Promise<CoreProtocolResult> {
+    let stream: Stream | undefined;
+    try {
+      stream = await this.getStream(peerId);
+    } catch (error) {
+      log.error(
+        `Failed to get a stream for remote peer${peerId.toString()}`,
+        error
+      );
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.NO_STREAM_AVAILABLE,
+          peerId: peerId
+        }
+      };
+    }
+
+    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: peerId
+        }
+      };
+    }
+
+    return {
+      success: peerId,
+      failure: null
+    };
+  }
+
+  public async unsubscribeAll(
+    pubsubTopic: PubsubTopic,
+    peerId: PeerId
+  ): Promise<CoreProtocolResult> {
+    const stream = await this.getStream(peerId);
+
+    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: peerId
+        },
+        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: peerId
+        },
+        success: null
+      };
+    }
+
+    return {
+      failure: null,
+      success: peerId
+    };
+  }
+
+  public async ping(peerId: PeerId): Promise<CoreProtocolResult> {
+    let stream: Stream | undefined;
+    try {
+      stream = await this.getStream(peerId);
+    } catch (error) {
+      log.error(
+        `Failed to get a stream for remote peer${peerId.toString()}`,
+        error
+      );
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.NO_STREAM_AVAILABLE,
+          peerId: peerId
+        }
+      };
+    }
+
+    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: peerId
+        }
+      };
+    }
+
+    if (!res || !res.length) {
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.NO_RESPONSE,
+          peerId: peerId
+        }
+      };
+    }
+
+    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: peerId
+        }
+      };
+    }
+    return {
+      success: peerId,
+      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);
+    }
+  }
+}