@waku/core 0.0.17 → 0.0.19

package/src/lib/filter/v2/index.ts

@@ -0,0 +1,413 @@
+import { Stream } from "@libp2p/interface-connection";
+import type { Libp2p } from "@libp2p/interface-libp2p";
+import type { PeerId } from "@libp2p/interface-peer-id";
+import type { Peer } from "@libp2p/interface-peer-store";
+import type { IncomingStreamData } from "@libp2p/interface-registrar";
+import type {
+  Callback,
+  ContentTopic,
+  IAsyncIterator,
+  IDecodedMessage,
+  IDecoder,
+  IFilterV2,
+  IProtoMessage,
+  IReceiver,
+  PeerIdStr,
+  ProtocolCreateOptions,
+  ProtocolOptions,
+  PubSubTopic,
+  Unsubscribe,
+} from "@waku/interfaces";
+import { WakuMessage } from "@waku/proto";
+import { groupByContentTopic, toAsyncIterator } from "@waku/utils";
+import debug from "debug";
+import all from "it-all";
+import * as lp from "it-length-prefixed";
+import { pipe } from "it-pipe";
+
+import { BaseProtocol } from "../../base_protocol.js";
+import { DefaultPubSubTopic } from "../../constants.js";
+
+import {
+  FilterPushRpc,
+  FilterSubscribeResponse,
+  FilterSubscribeRpc,
+} from "./filter_rpc.js";
+
+const log = debug("waku:filter:v2");
+
+type SubscriptionCallback<T extends IDecodedMessage> = {
+  decoders: IDecoder<T>[];
+  callback: Callback<T>;
+};
+
+const FilterV2Codecs = {
+  SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
+  PUSH: "/vac/waku/filter-push/2.0.0-beta1",
+};
+
+class Subscription {
+  private readonly peer: Peer;
+  private readonly pubSubTopic: PubSubTopic;
+  private newStream: (peer: Peer) => Promise<Stream>;
+
+  private subscriptionCallbacks: Map<
+    ContentTopic,
+    SubscriptionCallback<IDecodedMessage>
+  >;
+
+  constructor(
+    pubSubTopic: PubSubTopic,
+    remotePeer: Peer,
+    newStream: (peer: Peer) => Promise<Stream>
+  ) {
+    this.peer = remotePeer;
+    this.pubSubTopic = pubSubTopic;
+    this.newStream = newStream;
+    this.subscriptionCallbacks = new Map();
+  }
+
+  async subscribe<T extends IDecodedMessage>(
+    decoders: IDecoder<T> | IDecoder<T>[],
+    callback: Callback<T>
+  ): Promise<void> {
+    const decodersArray = Array.isArray(decoders) ? decoders : [decoders];
+    const decodersGroupedByCT = groupByContentTopic(decodersArray);
+    const contentTopics = Array.from(decodersGroupedByCT.keys());
+
+    const stream = await this.newStream(this.peer);
+
+    const request = FilterSubscribeRpc.createSubscribeRequest(
+      this.pubSubTopic,
+      contentTopics
+    );
+
+    try {
+      const res = await pipe(
+        [request.encode()],
+        lp.encode,
+        stream,
+        lp.decode,
+        async (source) => await all(source)
+      );
+
+      const { statusCode, requestId, statusDesc } =
+        FilterSubscribeResponse.decode(res[0].slice());
+
+      if (statusCode < 200 || statusCode >= 300) {
+        throw new Error(
+          `Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`
+        );
+      }
+
+      log(
+        "Subscribed to peer ",
+        this.peer.id.toString(),
+        "for content topics",
+        contentTopics
+      );
+    } catch (e) {
+      throw new Error(
+        "Error subscribing to peer: " +
+          this.peer.id.toString() +
+          " for content topics: " +
+          contentTopics +
+          ": " +
+          e
+      );
+    }
+
+    // Save the callback functions by content topics so they
+    // can easily be removed (reciprocally replaced) if `unsubscribe` (reciprocally `subscribe`)
+    // is called for those content topics
+    decodersGroupedByCT.forEach((decoders, contentTopic) => {
+      // Cast the type because a given `subscriptionCallbacks` map may hold
+      // Decoder that decode to different implementations of `IDecodedMessage`
+      const subscriptionCallback = {
+        decoders,
+        callback,
+      } as unknown as SubscriptionCallback<IDecodedMessage>;
+
+      // The callback and decoder may override previous values, this is on
+      // purpose as the user may call `subscribe` to refresh the subscription
+      this.subscriptionCallbacks.set(contentTopic, subscriptionCallback);
+    });
+  }
+
+  async unsubscribe(contentTopics: ContentTopic[]): Promise<void> {
+    const stream = await this.newStream(this.peer);
+    const unsubscribeRequest = FilterSubscribeRpc.createUnsubscribeRequest(
+      this.pubSubTopic,
+      contentTopics
+    );
+
+    try {
+      await pipe([unsubscribeRequest.encode()], lp.encode, stream.sink);
+    } catch (error) {
+      throw new Error("Error subscribing: " + error);
+    }
+
+    contentTopics.forEach((contentTopic: string) => {
+      this.subscriptionCallbacks.delete(contentTopic);
+    });
+  }
+
+  async ping(): Promise<void> {
+    const stream = await this.newStream(this.peer);
+
+    const request = FilterSubscribeRpc.createSubscriberPingRequest();
+
+    try {
+      const res = await pipe(
+        [request.encode()],
+        lp.encode,
+        stream,
+        lp.decode,
+        async (source) => await all(source)
+      );
+
+      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("Ping successful");
+    } catch (error) {
+      log("Error pinging: ", error);
+      throw new Error("Error pinging: " + error);
+    }
+  }
+
+  async unsubscribeAll(): Promise<void> {
+    const stream = await this.newStream(this.peer);
+
+    const request = FilterSubscribeRpc.createUnsubscribeAllRequest(
+      this.pubSubTopic
+    );
+
+    try {
+      const res = await pipe(
+        [request.encode()],
+        lp.encode,
+        stream,
+        lp.decode,
+        async (source) => await all(source)
+      );
+
+      const { statusCode, requestId, statusDesc } =
+        FilterSubscribeResponse.decode(res[0].slice());
+
+      if (statusCode < 200 || statusCode >= 300) {
+        throw new Error(
+          `Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`
+        );
+      }
+
+      this.subscriptionCallbacks.clear();
+      log("Unsubscribed from all content topics");
+    } catch (error) {
+      throw new Error("Error unsubscribing from all content topics: " + error);
+    }
+  }
+
+  async processMessage(message: WakuMessage): Promise<void> {
+    const contentTopic = message.contentTopic;
+    const subscriptionCallback = this.subscriptionCallbacks.get(contentTopic);
+    if (!subscriptionCallback) {
+      log("No subscription callback available for ", contentTopic);
+      return;
+    }
+    await pushMessage(subscriptionCallback, this.pubSubTopic, message);
+  }
+}
+
+class FilterV2 extends BaseProtocol implements IReceiver {
+  private readonly options: ProtocolCreateOptions;
+  private activeSubscriptions = new Map<string, Subscription>();
+
+  private getActiveSubscription(
+    pubSubTopic: PubSubTopic,
+    peerIdStr: PeerIdStr
+  ): Subscription | undefined {
+    return this.activeSubscriptions.get(`${pubSubTopic}_${peerIdStr}`);
+  }
+
+  private setActiveSubscription(
+    pubSubTopic: PubSubTopic,
+    peerIdStr: PeerIdStr,
+    subscription: Subscription
+  ): Subscription {
+    this.activeSubscriptions.set(`${pubSubTopic}_${peerIdStr}`, subscription);
+    return subscription;
+  }
+
+  constructor(public libp2p: Libp2p, options?: ProtocolCreateOptions) {
+    super(
+      FilterV2Codecs.SUBSCRIBE,
+      libp2p.peerStore,
+      libp2p.getConnections.bind(libp2p)
+    );
+
+    this.libp2p
+      .handle(FilterV2Codecs.PUSH, this.onRequest.bind(this))
+      .catch((e) => {
+        log("Failed to register ", FilterV2Codecs.PUSH, e);
+      });
+
+    this.activeSubscriptions = new Map();
+
+    this.options = options ?? {};
+  }
+
+  async createSubscription(
+    pubSubTopic?: string,
+    peerId?: PeerId
+  ): Promise<Subscription> {
+    const _pubSubTopic =
+      pubSubTopic ?? this.options.pubSubTopic ?? DefaultPubSubTopic;
+
+    const peer = await this.getPeer(peerId);
+
+    const subscription =
+      this.getActiveSubscription(_pubSubTopic, peer.id.toString()) ??
+      this.setActiveSubscription(
+        _pubSubTopic,
+        peer.id.toString(),
+        new Subscription(_pubSubTopic, peer, this.newStream.bind(this, peer))
+      );
+
+    return subscription;
+  }
+
+  public toSubscriptionIterator<T extends IDecodedMessage>(
+    decoders: IDecoder<T> | IDecoder<T>[],
+    opts?: ProtocolOptions | undefined
+  ): Promise<IAsyncIterator<T>> {
+    return toAsyncIterator(this, decoders, opts);
+  }
+
+  /**
+   * This method is used to satisfy the `IReceiver` interface.
+   *
+   * @hidden
+   *
+   * @param decoders The decoders to use for the subscription.
+   * @param callback The callback function to use for the subscription.
+   * @param opts Optional protocol options for the subscription.
+   *
+   * @returns A Promise that resolves to a function that unsubscribes from the subscription.
+   *
+   * @remarks
+   * This method should not be used directly.
+   * Instead, use `createSubscription` to create a new subscription.
+   */
+  async subscribe<T extends IDecodedMessage>(
+    decoders: IDecoder<T> | IDecoder<T>[],
+    callback: Callback<T>,
+    opts?: ProtocolOptions
+  ): Promise<Unsubscribe> {
+    const subscription = await this.createSubscription(undefined, opts?.peerId);
+
+    subscription.subscribe(decoders, callback);
+
+    const contentTopics = Array.from(
+      groupByContentTopic(
+        Array.isArray(decoders) ? decoders : [decoders]
+      ).keys()
+    );
+
+    return async () => {
+      await subscription.unsubscribe(contentTopics);
+    };
+  }
+
+  private onRequest(streamData: IncomingStreamData): void {
+    log("Receiving message push");
+    try {
+      pipe(streamData.stream, lp.decode, async (source) => {
+        for await (const bytes of source) {
+          const response = FilterPushRpc.decode(bytes.slice());
+
+          const { pubsubTopic, wakuMessage } = response;
+
+          if (!wakuMessage) {
+            log("Received empty message");
+            return;
+          }
+
+          if (!pubsubTopic) {
+            log("PubSub topic missing from push message");
+            return;
+          }
+
+          const peerIdStr = streamData.connection.remotePeer.toString();
+          const subscription = this.getActiveSubscription(
+            pubsubTopic,
+            peerIdStr
+          );
+
+          if (!subscription) {
+            log(`No subscription locally registered for topic ${pubsubTopic}`);
+            return;
+          }
+
+          await subscription.processMessage(wakuMessage);
+        }
+      }).then(
+        () => {
+          log("Receiving pipe closed.");
+        },
+        (e) => {
+          log("Error with receiving pipe", e);
+        }
+      );
+    } catch (e) {
+      log("Error decoding message", e);
+    }
+  }
+}
+
+export function wakuFilterV2(
+  init: Partial<ProtocolCreateOptions> = {}
+): (libp2p: Libp2p) => IFilterV2 {
+  return (libp2p: Libp2p) => new FilterV2(libp2p, init);
+}
+
+async function pushMessage<T extends IDecodedMessage>(
+  subscriptionCallback: SubscriptionCallback<T>,
+  pubSubTopic: PubSubTopic,
+  message: WakuMessage
+): Promise<void> {
+  const { decoders, callback } = subscriptionCallback;
+
+  const { contentTopic } = message;
+  if (!contentTopic) {
+    log("Message has no content topic, skipping");
+    return;
+  }
+
+  let didDecodeMsg = false;
+  // We don't want to wait for decoding failure, just attempt to decode
+  // all messages and do the call back on the one that works
+  // noinspection ES6MissingAwait
+  decoders.forEach(async (dec: IDecoder<T>) => {
+    if (didDecodeMsg) return;
+    const decoded = await dec.fromProtoObj(
+      pubSubTopic,
+      message as IProtoMessage
+    );
+    // const decoded = await dec.fromProtoObj(pubSubTopic, message);
+    if (!decoded) {
+      log("Not able to decode message");
+      return;
+    }
+    // This is just to prevent more decoding attempt
+    // TODO: Could be better if we were to abort promises
+    didDecodeMsg = Boolean(decoded);
+    await callback(decoded);
+  });
+}

package/src/lib/keep_alive_manager.ts

@@ -5,8 +5,7 @@ import type { Libp2p } from "libp2p";
 
 import { createEncoder } from "../index.js";
 
-import { RelayPingContentTopic } from "./relay/constants.js";
-
+export const RelayPingContentTopic = "/relay-ping/1/ping/null";
 const log = debug("waku:keep-alive");
 
 export interface KeepAliveOptions {

package/src/lib/light_push/index.ts

@@ -1,14 +1,16 @@
 import type { Libp2p } from "@libp2p/interface-libp2p";
 import type { PeerId } from "@libp2p/interface-peer-id";
-import type {
+import {
   IEncoder,
   ILightPush,
   IMessage,
   ProtocolCreateOptions,
   ProtocolOptions,
+  SendError,
   SendResult,
 } from "@waku/interfaces";
 import { PushResponse } from "@waku/proto";
+import { isSizeValid } from "@waku/utils";
 import debug from "debug";
 import all from "it-all";
 import * as lp from "it-length-prefixed";
@@ -47,12 +49,24 @@ class LightPush extends BaseProtocol implements ILightPush {
     const stream = await this.newStream(peer);
 
     const recipients: PeerId[] = [];
+    let error: undefined | SendError = undefined;
 
     try {
+      if (!isSizeValid(message.payload)) {
+        log("Failed to send waku light push: message is bigger that 1MB");
+        return {
+          recipients,
+          error: SendError.SIZE_TOO_BIG,
+        };
+      }
+
       const protoMessage = await encoder.toProtoObj(message);
       if (!protoMessage) {
         log("Failed to encode to protoMessage, aborting push");
-        return { recipients };
+        return {
+          recipients,
+          error: SendError.ENCODE_FAILED,
+        };
       }
       const query = PushRpc.createRequest(protoMessage, pubSubTopic);
       const res = await pipe(
@@ -70,21 +84,24 @@ class LightPush extends BaseProtocol implements ILightPush {
 
         const response = PushRpc.decode(bytes).response;
 
-        if (!response) {
-          log("No response in PushRPC");
-          return { recipients };
-        }
-
-        if (response.isSuccess) {
+        if (response?.isSuccess) {
           recipients.push(peer.id);
+        } else {
+          log("No response in PushRPC");
+          error = SendError.NO_RPC_RESPONSE;
         }
       } catch (err) {
         log("Failed to decode push reply", err);
+        error = SendError.DECODE_FAILED;
       }
     } catch (err) {
       log("Failed to send waku light push request", err);
+      error = SendError.GENERIC_FAIL;
     }
-    return { recipients };
+    return {
+      error,
+      recipients,
+    };
   }
 }
 

package/src/lib/message/index.ts

@@ -1,2 +1 @@
 export * as version_0 from "./version_0.js";
-export * as topic_only_message from "./topic_only_message.js";

package/src/lib/message/version_0.ts

@@ -1,10 +1,10 @@
-import { IMetaSetter } from "@waku/interfaces";
 import type {
   EncoderOptions,
   IDecodedMessage,
   IDecoder,
   IEncoder,
   IMessage,
+  IMetaSetter,
   IProtoMessage,
   IRateLimitProof,
 } from "@waku/interfaces";

package/src/lib/waku.ts

@@ -1,11 +1,10 @@
 import type { Stream } from "@libp2p/interface-connection";
 import type { Libp2p } from "@libp2p/interface-libp2p";
-import type { PeerId } from "@libp2p/interface-peer-id";
-import { isPeerId } from "@libp2p/interface-peer-id";
-import type { Multiaddr, MultiaddrInput } from "@multiformats/multiaddr";
-import { multiaddr } from "@multiformats/multiaddr";
+import { isPeerId, PeerId } from "@libp2p/interface-peer-id";
+import { multiaddr, Multiaddr, MultiaddrInput } from "@multiformats/multiaddr";
 import type {
   IFilter,
+  IFilterV2,
   ILightPush,
   IRelay,
   IStore,
@@ -48,7 +47,7 @@ export class WakuNode implements Waku {
   public libp2p: Libp2p;
   public relay?: IRelay;
   public store?: IStore;
-  public filter?: IFilter;
+  public filter?: IFilter | IFilterV2;
   public lightPush?: ILightPush;
   public connectionManager: ConnectionManager;
 
@@ -57,7 +56,7 @@ export class WakuNode implements Waku {
     libp2p: Libp2p,
     store?: (libp2p: Libp2p) => IStore,
     lightPush?: (libp2p: Libp2p) => ILightPush,
-    filter?: (libp2p: Libp2p) => IFilter,
+    filter?: (libp2p: Libp2p) => IFilter | IFilterV2,
     relay?: (libp2p: Libp2p) => IRelay
   ) {
     this.libp2p = libp2p;
@@ -192,7 +191,6 @@ export class WakuNode implements Waku {
     return localMultiaddr + "/p2p/" + this.libp2p.peerId.toString();
   }
 }
-
 function mapToPeerIdOrMultiaddr(
   peerId: PeerId | MultiaddrInput
 ): PeerId | Multiaddr {

package/bundle/lib/message/topic_only_message.js

@@ -1,3 +0,0 @@
-import '../../peer_exchange-1229c8b0.js';
-import '../../browser-2f1afe46.js';
-export { T as TopicOnlyDecoder, a as TopicOnlyMessage } from '../../topic_only_message-e8406994.js';

package/bundle/topic_only_message-e8406994.js

@@ -1,43 +0,0 @@
-import { T as TopicOnlyMessage$1 } from './peer_exchange-1229c8b0.js';
-import { d as debug } from './browser-2f1afe46.js';
-
-const log = debug("waku:message:topic-only");
-class TopicOnlyMessage {
-    constructor(pubSubTopic, proto) {
-        this.pubSubTopic = pubSubTopic;
-        this.proto = proto;
-        this.payload = new Uint8Array();
-    }
-    get contentTopic() {
-        return this.proto.contentTopic;
-    }
-}
-class TopicOnlyDecoder {
-    constructor() {
-        this.contentTopic = "";
-    }
-    fromWireToProtoObj(bytes) {
-        const protoMessage = TopicOnlyMessage$1.decode(bytes);
-        log("Message decoded", protoMessage);
-        return Promise.resolve({
-            contentTopic: protoMessage.contentTopic,
-            payload: new Uint8Array(),
-            rateLimitProof: undefined,
-            timestamp: undefined,
-            meta: undefined,
-            version: undefined,
-            ephemeral: undefined,
-        });
-    }
-    async fromProtoObj(pubSubTopic, proto) {
-        return new TopicOnlyMessage(pubSubTopic, proto);
-    }
-}
-
-var topic_only_message = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    TopicOnlyDecoder: TopicOnlyDecoder,
-    TopicOnlyMessage: TopicOnlyMessage
-});
-
-export { TopicOnlyDecoder as T, TopicOnlyMessage as a, topic_only_message as t };