@waku/core 0.0.29 → 0.0.30-e49e728.0

package/src/lib/filter/index.ts

@@ -1,17 +1,20 @@
-import type { Peer } from "@libp2p/interface";
+import type { Peer, Stream } from "@libp2p/interface";
 import type { IncomingStreamData } from "@libp2p/interface-internal";
-import type {
-  ContentTopic,
-  IBaseProtocolCore,
-  Libp2p,
-  ProtocolCreateOptions,
-  PubsubTopic
+import {
+  type ContentTopic,
+  type CoreProtocolResult,
+  type IBaseProtocolCore,
+  type Libp2p,
+  type ProtocolCreateOptions,
+  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";
 
@@ -90,7 +93,7 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     pubsubTopic: PubsubTopic,
     peer: Peer,
     contentTopics: ContentTopic[]
-  ): Promise<void> {
+  ): Promise<CoreProtocolResult> {
     const stream = await this.getStream(peer);
 
     const request = FilterSubscribeRpc.createSubscribeRequest(
@@ -98,45 +101,98 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
       contentTopics
     );
 
-    const res = await pipe(
-      [request.encode()],
-      lp.encode,
-      stream,
-      lp.decode,
-      async (source) => await all(source)
-    );
-
-    if (!res || !res.length) {
-      throw Error(
-        `No response received for request ${request.requestId}: ${res}`
+    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) {
-      throw new Error(
+      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
+    };
   }
 
   async unsubscribe(
     pubsubTopic: PubsubTopic,
     peer: Peer,
     contentTopics: ContentTopic[]
-  ): Promise<void> {
-    const stream = await this.getStream(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.REMOTE_PEER_FAULT,
+          peerId: peer.id
+        }
+      };
+    }
+
     const unsubscribeRequest = FilterSubscribeRpc.createUnsubscribeRequest(
       pubsubTopic,
       contentTopics
     );
 
-    await pipe([unsubscribeRequest.encode()], lp.encode, stream.sink);
+    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
+    };
   }
 
-  async unsubscribeAll(pubsubTopic: PubsubTopic, peer: Peer): Promise<void> {
+  async unsubscribeAll(
+    pubsubTopic: PubsubTopic,
+    peer: Peer
+  ): Promise<CoreProtocolResult> {
     const stream = await this.getStream(peer);
 
     const request = FilterSubscribeRpc.createUnsubscribeAllRequest(pubsubTopic);
@@ -150,53 +206,105 @@ export class FilterCore extends BaseProtocol implements IBaseProtocolCore {
     );
 
     if (!res || !res.length) {
-      throw Error(
-        `No response received for request ${request.requestId}: ${res}`
-      );
+      return {
+        failure: {
+          error: ProtocolError.REMOTE_PEER_FAULT,
+          peerId: peer.id
+        },
+        success: null
+      };
     }
 
     const { statusCode, requestId, statusDesc } =
       FilterSubscribeResponse.decode(res[0].slice());
 
     if (statusCode < 200 || statusCode >= 300) {
-      throw new Error(
+      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
+    };
   }
 
-  async ping(peer: Peer): Promise<void> {
-    const stream = await this.getStream(peer);
+  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.REMOTE_PEER_FAULT,
+          peerId: peer.id
+        }
+      };
+    }
 
     const request = FilterSubscribeRpc.createSubscriberPingRequest();
 
+    let res: Uint8ArrayList[] | undefined;
     try {
-      const res = await pipe(
+      res = await pipe(
         [request.encode()],
         lp.encode,
         stream,
         lp.decode,
         async (source) => await all(source)
       );
-
-      if (!res || !res.length) {
-        throw Error(
-          `No response received for request ${request.requestId}: ${res}`
-        );
-      }
-
-      const { statusCode, requestId, statusDesc } =
-        FilterSubscribeResponse.decode(res[0].slice());
-
-      if (statusCode < 200 || statusCode >= 300) {
-        throw new Error(
-          `Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`
-        );
-      }
-      log.info(`Ping successful for peer ${peer.id.toString()}`);
     } catch (error) {
-      log.error("Error pinging: ", error);
-      throw error; // Rethrow the actual error instead of wrapping it
+      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.REMOTE_PEER_FAULT,
+          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
+    };
   }
 }

package/src/lib/light_push/index.ts

@@ -1,13 +1,13 @@
-import type { Peer, PeerId, Stream } from "@libp2p/interface";
+import type { Peer, Stream } from "@libp2p/interface";
 import {
-  Failure,
-  IBaseProtocolCore,
-  IEncoder,
-  IMessage,
-  Libp2p,
-  ProtocolCreateOptions,
+  type CoreProtocolResult,
+  type IBaseProtocolCore,
+  type IEncoder,
+  type IMessage,
+  type Libp2p,
+  type ProtocolCreateOptions,
   ProtocolError,
-  ProtocolResult
+  type ThisOrThat
 } from "@waku/interfaces";
 import { PushResponse } from "@waku/proto";
 import { isMessageSizeUnderCap } from "@waku/utils";
@@ -26,9 +26,7 @@ const log = new Logger("light-push");
 export const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 export { PushResponse };
 
-type PreparePushMessageResult = ProtocolResult<"query", PushRpc>;
-
-type CoreSendResult = ProtocolResult<"success", PeerId, "failure", Failure>;
+type PreparePushMessageResult = ThisOrThat<"query", PushRpc>;
 
 /**
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
@@ -84,7 +82,7 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
     encoder: IEncoder,
     message: IMessage,
     peer: Peer
-  ): Promise<CoreSendResult> {
+  ): Promise<CoreProtocolResult> {
     const { query, error: preparationError } = await this.preparePushMessage(
       encoder,
       message
@@ -100,18 +98,15 @@ export class LightPushCore extends BaseProtocol implements IBaseProtocolCore {
       };
     }
 
-    let stream: Stream | undefined;
+    let stream: Stream;
     try {
       stream = await this.getStream(peer);
-    } catch (err) {
-      log.error(
-        `Failed to get a stream for remote peer${peer.id.toString()}`,
-        err
-      );
+    } catch (error) {
+      log.error("Failed to get stream", error);
       return {
         success: null,
         failure: {
-          error: ProtocolError.REMOTE_PEER_FAULT,
+          error: ProtocolError.NO_STREAM_AVAILABLE,
           peerId: peer.id
         }
       };

package/src/lib/metadata/index.ts

@@ -3,9 +3,9 @@ import { IncomingStreamData } from "@libp2p/interface";
 import {
   type IMetadata,
   type Libp2pComponents,
+  type MetadataQueryResult,
   type PeerIdStr,
   ProtocolError,
-  QueryResult,
   type ShardInfo
 } from "@waku/interfaces";
 import { proto_metadata } from "@waku/proto";
@@ -74,7 +74,7 @@ class Metadata extends BaseProtocol implements IMetadata {
   /**
    * Make a metadata query to a peer
    */
-  async query(peerId: PeerId): Promise<QueryResult> {
+  async query(peerId: PeerId): Promise<MetadataQueryResult> {
     const request = proto_metadata.WakuMetadataRequest.encode(this.shardInfo);
 
     const peer = await this.peerStore.get(peerId);
@@ -85,7 +85,16 @@ class Metadata extends BaseProtocol implements IMetadata {
       };
     }
 
-    const stream = await this.getStream(peer);
+    let stream;
+    try {
+      stream = await this.getStream(peer);
+    } catch (error) {
+      log.error("Failed to get stream", error);
+      return {
+        shardInfo: null,
+        error: ProtocolError.NO_STREAM_AVAILABLE
+      };
+    }
 
     const encodedResponse = await pipe(
       [request],
@@ -112,7 +121,9 @@ class Metadata extends BaseProtocol implements IMetadata {
     };
   }
 
-  public async confirmOrAttemptHandshake(peerId: PeerId): Promise<QueryResult> {
+  public async confirmOrAttemptHandshake(
+    peerId: PeerId
+  ): Promise<MetadataQueryResult> {
     const shardInfo = this.handshakesConfirmed.get(peerId.toString());
     if (shardInfo) {
       return {
@@ -126,7 +137,7 @@ class Metadata extends BaseProtocol implements IMetadata {
 
   private decodeMetadataResponse(
     encodedResponse: Uint8ArrayList[]
-  ): QueryResult {
+  ): MetadataQueryResult {
     const bytes = new Uint8ArrayList();
 
     encodedResponse.forEach((chunk) => {

package/src/lib/store/index.ts

@@ -92,7 +92,13 @@ export class StoreCore extends BaseProtocol implements IStoreCore {
 
       const historyRpcQuery = HistoryRpc.createQuery(queryOpts);
 
-      const stream = await this.getStream(peer);
+      let stream;
+      try {
+        stream = await this.getStream(peer);
+      } catch (e) {
+        log.error("Failed to get stream", e);
+        break;
+      }
 
       const res = await pipe(
         [historyRpcQuery.encode()],

package/src/lib/stream_manager.ts

@@ -1,11 +1,15 @@
 import type { PeerUpdate, Stream } from "@libp2p/interface";
-import { Peer } from "@libp2p/interface";
+import type { Peer, PeerId } from "@libp2p/interface";
 import { Libp2p } from "@waku/interfaces";
 import { Logger } from "@waku/utils";
 import { selectConnection } from "@waku/utils/libp2p";
 
+const CONNECTION_TIMEOUT = 5_000;
+const RETRY_BACKOFF_BASE = 1_000;
+const MAX_RETRIES = 3;
+
 export class StreamManager {
-  private streamPool: Map<string, Promise<Stream | void>>;
+  private readonly streamPool: Map<string, Promise<Stream | void>>;
   private readonly log: Logger;
 
   constructor(
@@ -14,12 +18,8 @@ export class StreamManager {
     public addEventListener: Libp2p["addEventListener"]
   ) {
     this.log = new Logger(`stream-manager:${multicodec}`);
-    this.addEventListener(
-      "peer:update",
-      this.handlePeerUpdateStreamPool.bind(this)
-    );
-    this.getStream = this.getStream.bind(this);
     this.streamPool = new Map();
+    this.addEventListener("peer:update", this.handlePeerUpdateStreamPool);
   }
 
   public async getStream(peer: Peer): Promise<Stream> {
@@ -27,47 +27,88 @@ export class StreamManager {
     const streamPromise = this.streamPool.get(peerIdStr);
 
     if (!streamPromise) {
-      return this.newStream(peer); // fallback by creating a new stream on the spot
+      return this.createStream(peer);
     }
 
-    // We have the stream, let's remove it from the map
     this.streamPool.delete(peerIdStr);
+    this.prepareStream(peer);
 
-    this.prepareNewStream(peer);
-
-    const stream = await streamPromise;
-
-    if (!stream || stream.status === "closed") {
-      return this.newStream(peer); // fallback by creating a new stream on the spot
+    try {
+      const stream = await streamPromise;
+      if (stream && stream.status !== "closed") {
+        return stream;
+      }
+    } catch (error) {
+      this.log.warn(`Failed to get stream for ${peerIdStr} -- `, error);
+      this.log.warn("Attempting to create a new stream for the peer");
     }
 
-    return stream;
+    return this.createStream(peer);
   }
 
-  private async newStream(peer: Peer): Promise<Stream> {
+  private async createStream(peer: Peer, retries = 0): Promise<Stream> {
     const connections = this.getConnections(peer.id);
     const connection = selectConnection(connections);
+
     if (!connection) {
       throw new Error("Failed to get a connection to the peer");
     }
-    return connection.newStream(this.multicodec);
+
+    try {
+      return await connection.newStream(this.multicodec);
+    } catch (error) {
+      if (retries < MAX_RETRIES) {
+        const backoff = RETRY_BACKOFF_BASE * Math.pow(2, retries);
+        await new Promise((resolve) => setTimeout(resolve, backoff));
+        return this.createStream(peer, retries + 1);
+      }
+      throw new Error(
+        `Failed to create a new stream for ${peer.id.toString()} -- ` + error
+      );
+    }
   }
 
-  private prepareNewStream(peer: Peer): void {
-    const streamPromise = this.newStream(peer).catch(() => {
-      // No error thrown as this call is not triggered by the user
+  private prepareStream(peer: Peer): void {
+    const timeoutPromise = new Promise<void>((resolve) =>
+      setTimeout(resolve, CONNECTION_TIMEOUT)
+    );
+
+    const streamPromise = Promise.race([
+      this.createStream(peer),
+      timeoutPromise.then(() => {
+        throw new Error("Connection timeout");
+      })
+    ]).catch((error) => {
       this.log.error(
-        `Failed to prepare a new stream for ${peer.id.toString()}`
+        `Failed to prepare a new stream for ${peer.id.toString()} -- `,
+        error
       );
     });
+
     this.streamPool.set(peer.id.toString(), streamPromise);
   }
 
   private handlePeerUpdateStreamPool = (evt: CustomEvent<PeerUpdate>): void => {
-    const peer = evt.detail.peer;
+    const { peer } = evt.detail;
+
     if (peer.protocols.includes(this.multicodec)) {
-      this.log.info(`Preemptively opening a stream to ${peer.id.toString()}`);
-      this.prepareNewStream(peer);
+      const isConnected = this.isConnectedTo(peer.id);
+
+      if (isConnected) {
+        this.log.info(`Preemptively opening a stream to ${peer.id.toString()}`);
+        this.prepareStream(peer);
+      } else {
+        const peerIdStr = peer.id.toString();
+        this.streamPool.delete(peerIdStr);
+        this.log.info(
+          `Removed pending stream for disconnected peer ${peerIdStr}`
+        );
+      }
     }
   };
+
+  private isConnectedTo(peerId: PeerId): boolean {
+    const connections = this.getConnections(peerId);
+    return connections.some((connection) => connection.status === "open");
+  }
 }