@waku/core 0.0.33-f599932.0 → 0.0.34-09108d9.0

package/src/lib/filter/index.ts

@@ -1,323 +1 @@
-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>,
-    private handleError: (error: Error) => Promise<void>,
-    public readonly pubsubTopics: PubsubTopic[],
-    libp2p: Libp2p
-  ) {
-    super(FilterCodecs.SUBSCRIBE, libp2p.components, log, 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",
-            e,
-            " -- ",
-            "on peer ",
-            connection.remotePeer.toString(),
-            " -- ",
-            "stream ",
-            stream
-          );
-          await this.handleError(e);
-        }
-      );
-    } catch (e) {
-      log.error("Error decoding message", e);
-    }
-  }
-}
+export { FilterCodecs, FilterCore } from "./filter.js";

package/src/lib/light_push/index.ts

@@ -1,188 +1 @@
-import type { Peer, Stream } from "@libp2p/interface";
-import {
-  type CoreProtocolResult,
-  type IBaseProtocolCore,
-  type IEncoder,
-  type IMessage,
-  type Libp2p,
-  ProtocolError,
-  PubsubTopic,
-  type ThisOrThat
-} from "@waku/interfaces";
-import { PushResponse } from "@waku/proto";
-import { isMessageSizeUnderCap } from "@waku/utils";
-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 { PushRpc } from "./push_rpc.js";
-import { isRLNResponseError, matchRLNErrorMessage } from "./utils.js";
-
-const log = new Logger("light-push");
-
-export const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
-export { PushResponse };
-
-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 {
-  public constructor(
-    public readonly pubsubTopics: PubsubTopic[],
-    libp2p: Libp2p
-  ) {
-    super(LightPushCodec, libp2p.components, log, pubsubTopics);
-  }
-
-  private async preparePushMessage(
-    encoder: IEncoder,
-    message: IMessage
-  ): Promise<PreparePushMessageResult> {
-    try {
-      if (!message.payload || message.payload.length === 0) {
-        log.error("Failed to send waku light push: payload is empty");
-        return { query: null, error: ProtocolError.EMPTY_PAYLOAD };
-      }
-
-      if (!(await isMessageSizeUnderCap(encoder, message))) {
-        log.error("Failed to send waku light push: message is bigger than 1MB");
-        return { query: null, error: ProtocolError.SIZE_TOO_BIG };
-      }
-
-      const protoMessage = await encoder.toProtoObj(message);
-      if (!protoMessage) {
-        log.error("Failed to encode to protoMessage, aborting push");
-        return {
-          query: null,
-          error: ProtocolError.ENCODE_FAILED
-        };
-      }
-
-      const query = PushRpc.createRequest(protoMessage, encoder.pubsubTopic);
-      return { query, error: null };
-    } catch (error) {
-      log.error("Failed to prepare push message", error);
-
-      return {
-        query: null,
-        error: ProtocolError.GENERIC_FAIL
-      };
-    }
-  }
-
-  public async send(
-    encoder: IEncoder,
-    message: IMessage,
-    peer: Peer
-  ): Promise<CoreProtocolResult> {
-    const { query, error: preparationError } = await this.preparePushMessage(
-      encoder,
-      message
-    );
-
-    if (preparationError || !query) {
-      return {
-        success: null,
-        failure: {
-          error: preparationError,
-          peerId: peer.id
-        }
-      };
-    }
-
-    let stream: Stream;
-    try {
-      stream = await this.getStream(peer);
-    } catch (error) {
-      log.error("Failed to get stream", error);
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.NO_STREAM_AVAILABLE,
-          peerId: peer.id
-        }
-      };
-    }
-
-    let res: Uint8ArrayList[] | undefined;
-    try {
-      res = await pipe(
-        [query.encode()],
-        lp.encode,
-        stream,
-        lp.decode,
-        async (source) => await all(source)
-      );
-    } catch (err) {
-      log.error("Failed to send waku light push request", err);
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.GENERIC_FAIL,
-          peerId: peer.id
-        }
-      };
-    }
-
-    const bytes = new Uint8ArrayList();
-    res.forEach((chunk) => {
-      bytes.append(chunk);
-    });
-
-    let response: PushResponse | undefined;
-    try {
-      response = PushRpc.decode(bytes).response;
-    } catch (err) {
-      log.error("Failed to decode push reply", err);
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.DECODE_FAILED,
-          peerId: peer.id
-        }
-      };
-    }
-
-    if (!response) {
-      log.error("Remote peer fault: No response in PushRPC");
-      return {
-        success: null,
-        failure: {
-          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
-        }
-      };
-    }
-
-    if (!response.isSuccess) {
-      log.error("Remote peer rejected the message: ", response.info);
-      return {
-        success: null,
-        failure: {
-          error: ProtocolError.REMOTE_PEER_REJECTED,
-          peerId: peer.id
-        }
-      };
-    }
-
-    return { success: peer.id, failure: null };
-  }
-}
+export { LightPushCore, LightPushCodec, PushResponse } from "./light_push.js";

package/src/lib/light_push/light_push.ts

@@ -0,0 +1,188 @@
+import type { PeerId, Stream } from "@libp2p/interface";
+import {
+  type CoreProtocolResult,
+  type IBaseProtocolCore,
+  type IEncoder,
+  type IMessage,
+  type Libp2p,
+  ProtocolError,
+  PubsubTopic,
+  type ThisOrThat
+} from "@waku/interfaces";
+import { PushResponse } from "@waku/proto";
+import { isMessageSizeUnderCap } from "@waku/utils";
+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 { PushRpc } from "./push_rpc.js";
+import { isRLNResponseError } from "./utils.js";
+
+const log = new Logger("light-push");
+
+export const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
+export { PushResponse };
+
+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 {
+  public constructor(
+    public readonly pubsubTopics: PubsubTopic[],
+    libp2p: Libp2p
+  ) {
+    super(LightPushCodec, libp2p.components, pubsubTopics);
+  }
+
+  private async preparePushMessage(
+    encoder: IEncoder,
+    message: IMessage
+  ): Promise<PreparePushMessageResult> {
+    try {
+      if (!message.payload || message.payload.length === 0) {
+        log.error("Failed to send waku light push: payload is empty");
+        return { query: null, error: ProtocolError.EMPTY_PAYLOAD };
+      }
+
+      if (!(await isMessageSizeUnderCap(encoder, message))) {
+        log.error("Failed to send waku light push: message is bigger than 1MB");
+        return { query: null, error: ProtocolError.SIZE_TOO_BIG };
+      }
+
+      const protoMessage = await encoder.toProtoObj(message);
+      if (!protoMessage) {
+        log.error("Failed to encode to protoMessage, aborting push");
+        return {
+          query: null,
+          error: ProtocolError.ENCODE_FAILED
+        };
+      }
+
+      const query = PushRpc.createRequest(protoMessage, encoder.pubsubTopic);
+      return { query, error: null };
+    } catch (error) {
+      log.error("Failed to prepare push message", error);
+
+      return {
+        query: null,
+        error: ProtocolError.GENERIC_FAIL
+      };
+    }
+  }
+
+  public async send(
+    encoder: IEncoder,
+    message: IMessage,
+    peerId: PeerId
+  ): Promise<CoreProtocolResult> {
+    const { query, error: preparationError } = await this.preparePushMessage(
+      encoder,
+      message
+    );
+
+    if (preparationError || !query) {
+      return {
+        success: null,
+        failure: {
+          error: preparationError,
+          peerId
+        }
+      };
+    }
+
+    let stream: Stream;
+    try {
+      stream = await this.getStream(peerId);
+    } catch (error) {
+      log.error("Failed to get stream", error);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.NO_STREAM_AVAILABLE,
+          peerId: peerId
+        }
+      };
+    }
+
+    let res: Uint8ArrayList[] | undefined;
+    try {
+      res = await pipe(
+        [query.encode()],
+        lp.encode,
+        stream,
+        lp.decode,
+        async (source) => await all(source)
+      );
+    } catch (err) {
+      // can fail only because of `stream` abortion
+      log.error("Failed to send waku light push request", err);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.STREAM_ABORTED,
+          peerId: peerId
+        }
+      };
+    }
+
+    const bytes = new Uint8ArrayList();
+    res.forEach((chunk) => {
+      bytes.append(chunk);
+    });
+
+    let response: PushResponse | undefined;
+    try {
+      response = PushRpc.decode(bytes).response;
+    } catch (err) {
+      log.error("Failed to decode push reply", err);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.DECODE_FAILED,
+          peerId: peerId
+        }
+      };
+    }
+
+    if (!response) {
+      log.error("Remote peer fault: No response in PushRPC");
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.NO_RESPONSE,
+          peerId: peerId
+        }
+      };
+    }
+
+    if (isRLNResponseError(response.info)) {
+      log.error("Remote peer fault: RLN generation");
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.RLN_PROOF_GENERATION,
+          peerId: peerId
+        }
+      };
+    }
+
+    if (!response.isSuccess) {
+      log.error("Remote peer rejected the message: ", response.info);
+      return {
+        success: null,
+        failure: {
+          error: ProtocolError.REMOTE_PEER_REJECTED,
+          peerId: peerId
+        }
+      };
+    }
+
+    return { success: peerId, failure: null };
+  }
+}