@waku/core 0.0.18 → 0.0.19

package/CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The file is maintained by [Release Please](https://github.com/googleapis/release-please) based on [Conventional Commits](https://www.conventionalcommits.org) specification,
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.19](https://github.com/waku-org/js-waku/compare/core-v0.0.18...core-v0.0.19) (2023-05-26)
+
+
+### ⚠ BREAKING CHANGES
+
+* filter v2 ([#1332](https://github.com/waku-org/js-waku/issues/1332))
+
+### Features
+
+* Filter v2 ([#1332](https://github.com/waku-org/js-waku/issues/1332)) ([8d0e647](https://github.com/waku-org/js-waku/commit/8d0e64796695fbafad0a033552eb4412bdff3d78))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @waku/interfaces bumped from 0.0.13 to 0.0.14
+    * @waku/proto bumped from * to 0.0.5
+    * @waku/utils bumped from 0.0.6 to 0.0.7
+
 ## [0.0.18](https://github.com/waku-org/js-waku/compare/core-v0.0.17...core-v0.0.18) (2023-05-18)
 
 

package/bundle/index.js

@@ -1,6 +1,6 @@
 import { g as getDefaultExportFromCjs, d as debug } from './browser-bde977a3.js';
-import { c as createEncoder, v as version_0, F as FilterRpc$1, P as PushRpc$1, a as PushResponse, H as HistoryRpc$1, b as PagingInfo, d as HistoryResponse } from './version_0-c6b47311.js';
-export { e as createDecoder } from './version_0-c6b47311.js';
+import { c as createEncoder, v as version_0, F as FilterRpc$1, M as MessagePush, a as FilterSubscribeRequest, b as FilterSubscribeResponse$1, P as PushRpc$1, d as PushResponse, H as HistoryRpc$1, e as PagingInfo, f as HistoryResponse } from './version_0-9c941081.js';
+export { g as createDecoder } from './version_0-9c941081.js';
 import { BaseProtocol } from './lib/base_protocol.js';
 
 const symbol$2 = Symbol.for('@libp2p/peer-id');
@@ -2975,7 +2975,7 @@ var Tags;
 })(Tags || (Tags = {}));
 
 const RelayPingContentTopic = "/relay-ping/1/ping/null";
-const log$6 = debug("waku:keep-alive");
+const log$7 = debug("waku:keep-alive");
 class KeepAliveManager {
     pingKeepAliveTimers;
     relayKeepAliveTimers;
@@ -2995,7 +2995,7 @@ class KeepAliveManager {
         if (pingPeriodSecs !== 0) {
             const interval = setInterval(() => {
                 libp2pPing(peerId).catch((e) => {
-                    log$6(`Ping failed (${peerIdStr})`, e);
+                    log$7(`Ping failed (${peerIdStr})`, e);
                 });
             }, pingPeriodSecs * 1000);
             this.pingKeepAliveTimers.set(peerIdStr, interval);
@@ -3007,10 +3007,10 @@ class KeepAliveManager {
                 ephemeral: true,
             });
             const interval = setInterval(() => {
-                log$6("Sending Waku Relay ping message");
+                log$7("Sending Waku Relay ping message");
                 relay
                     .send(encoder, { payload: new Uint8Array([1]) })
-                    .catch((e) => log$6("Failed to send relay ping", e));
+                    .catch((e) => log$7("Failed to send relay ping", e));
             }, relayPeriodSecs * 1000);
             this.relayKeepAliveTimers.set(peerId, interval);
         }
@@ -3038,7 +3038,7 @@ class KeepAliveManager {
     }
 }
 
-const log$5 = debug("waku:connection-manager");
+const log$6 = debug("waku:connection-manager");
 const DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED = 1;
 const DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER = 3;
 class ConnectionManager {
@@ -3065,8 +3065,8 @@ class ConnectionManager {
         };
         this.keepAliveManager = new KeepAliveManager(keepAliveOptions, relay);
         this.run()
-            .then(() => log$5(`Connection Manager is now running`))
-            .catch((error) => log$5(`Unexpected error while running service`, error));
+            .then(() => log$6(`Connection Manager is now running`))
+            .catch((error) => log$6(`Unexpected error while running service`, error));
     }
     async run() {
         // start event listeners
@@ -3084,7 +3084,7 @@ class ConnectionManager {
         let dialAttempt = 0;
         while (dialAttempt <= this.options.maxDialAttemptsForPeer) {
             try {
-                log$5(`Dialing peer ${peerId.toString()}`);
+                log$6(`Dialing peer ${peerId.toString()}`);
                 await this.libp2pComponents.dial(peerId);
                 const tags = await this.getTagNamesForPeer(peerId);
                 // add tag to connection describing discovery mechanism
@@ -3098,16 +3098,16 @@ class ConnectionManager {
             catch (e) {
                 const error = e;
                 this.dialErrorsForPeer.set(peerId.toString(), error);
-                log$5(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
+                log$6(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
                 dialAttempt = this.dialAttemptsForPeer.get(peerId.toString()) ?? 1;
                 this.dialAttemptsForPeer.set(peerId.toString(), dialAttempt + 1);
                 if (dialAttempt <= this.options.maxDialAttemptsForPeer) {
-                    log$5(`Reattempting dial (${dialAttempt})`);
+                    log$6(`Reattempting dial (${dialAttempt})`);
                 }
             }
         }
         try {
-            log$5(`Deleting undialable peer ${peerId.toString()} from peer store. Error: ${JSON.stringify(this.dialErrorsForPeer.get(peerId.toString()).errors[0])}
+            log$6(`Deleting undialable peer ${peerId.toString()} from peer store. Error: ${JSON.stringify(this.dialErrorsForPeer.get(peerId.toString()).errors[0])}
         }`);
             this.dialErrorsForPeer.delete(peerId.toString());
             return await this.libp2pComponents.peerStore.delete(peerId);
@@ -3142,7 +3142,7 @@ class ConnectionManager {
             const { id: peerId } = evt.detail;
             if (!(await this.shouldDialPeer(peerId)))
                 return;
-            this.dialPeer(peerId).catch((err) => log$5(`Error dialing peer ${peerId.toString()} : ${err}`));
+            this.dialPeer(peerId).catch((err) => log$6(`Error dialing peer ${peerId.toString()} : ${err}`));
         },
         "peer:connect": (evt) => {
             {
@@ -3191,7 +3191,7 @@ class ConnectionManager {
 const DefaultPingKeepAliveValueSecs = 0;
 const DefaultRelayKeepAliveValueSecs = 5 * 60;
 const DefaultUserAgent = "js-waku";
-const log$4 = debug("waku:waku");
+const log$5 = debug("waku:waku");
 class WakuNode {
     libp2p;
     relay;
@@ -3219,7 +3219,7 @@ class WakuNode {
             : 0;
         const peerId = this.libp2p.peerId.toString();
         this.connectionManager = ConnectionManager.create(peerId, libp2p, { pingKeepAlive, relayKeepAlive }, this.relay);
-        log$4("Waku node created", peerId, `relay: ${!!this.relay}, store: ${!!this.store}, light push: ${!!this
+        log$5("Waku node created", peerId, `relay: ${!!this.relay}, store: ${!!this.store}, light push: ${!!this
             .lightPush}, filter: ${!!this.filter}`);
     }
     /**
@@ -3243,7 +3243,7 @@ class WakuNode {
                 this.relay.gossipSub.multicodecs.forEach((codec) => codecs.push(codec));
             }
             else {
-                log$4("Relay codec not included in dial codec: protocol not mounted locally");
+                log$5("Relay codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.Store)) {
@@ -3251,7 +3251,7 @@ class WakuNode {
                 codecs.push(this.store.multicodec);
             }
             else {
-                log$4("Store codec not included in dial codec: protocol not mounted locally");
+                log$5("Store codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.LightPush)) {
@@ -3259,7 +3259,7 @@ class WakuNode {
                 codecs.push(this.lightPush.multicodec);
             }
             else {
-                log$4("Light Push codec not included in dial codec: protocol not mounted locally");
+                log$5("Light Push codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.Filter)) {
@@ -3267,10 +3267,10 @@ class WakuNode {
                 codecs.push(this.filter.multicodec);
             }
             else {
-                log$4("Filter codec not included in dial codec: protocol not mounted locally");
+                log$5("Filter codec not included in dial codec: protocol not mounted locally");
             }
         }
-        log$4(`Dialing to ${peerId.toString()} with protocols ${_protocols}`);
+        log$5(`Dialing to ${peerId.toString()} with protocols ${_protocols}`);
         return this.libp2p.dialProtocol(peerId, codecs);
     }
     async start() {
@@ -3315,7 +3315,7 @@ var waku = /*#__PURE__*/Object.freeze({
  */
 const DefaultPubSubTopic = "/waku/2/default-waku/proto";
 
-var index$3 = /*#__PURE__*/Object.freeze({
+var index$4 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     version_0: version_0
 });
@@ -4876,7 +4876,7 @@ class FilterRpc {
 }
 
 const FilterCodec = "/vac/waku/filter/2.0.0-beta1";
-const log$3 = debug("waku:filter");
+const log$4 = debug("waku:filter");
 /**
  * Implements client side of the [Waku v2 Filter protocol](https://rfc.vac.dev/spec/12/).
  *
@@ -4895,7 +4895,7 @@ class Filter extends BaseProtocol {
         this.subscriptions = new Map();
         this.libp2p
             .handle(this.multicodec, this.onRequest.bind(this))
-            .catch((e) => log$3("Failed to register filter protocol", e));
+            .catch((e) => log$4("Failed to register filter protocol", e));
     }
     /**
      * @param decoders Decoder or array of Decoders to use to decode messages, it also specifies the content topics.
@@ -4916,10 +4916,10 @@ class Filter extends BaseProtocol {
         const stream = await this.newStream(peer);
         try {
             const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
-            log$3("response", res);
+            log$4("response", res);
         }
         catch (e) {
-            log$3("Error subscribing to peer ", peer.id.toString(), "for content topics", contentTopics, ": ", e);
+            log$4("Error subscribing to peer ", peer.id.toString(), "for content topics", contentTopics, ": ", e);
             throw e;
         }
         const subscription = {
@@ -4947,7 +4947,7 @@ class Filter extends BaseProtocol {
         return map;
     }
     onRequest(streamData) {
-        log$3("Receiving message push");
+        log$4("Receiving message push");
         try {
             pipe(streamData.stream, decode, async (source) => {
                 for await (const bytes of source) {
@@ -4957,30 +4957,30 @@ class Filter extends BaseProtocol {
                     }
                 }
             }).then(() => {
-                log$3("Receiving pipe closed.");
+                log$4("Receiving pipe closed.");
             }, (e) => {
-                log$3("Error with receiving pipe", e);
+                log$4("Error with receiving pipe", e);
             });
         }
         catch (e) {
-            log$3("Error decoding message", e);
+            log$4("Error decoding message", e);
         }
     }
     async pushMessages(requestId, messages) {
         const subscription = this.subscriptions.get(requestId);
         if (!subscription) {
-            log$3(`No subscription locally registered for request ID ${requestId}`);
+            log$4(`No subscription locally registered for request ID ${requestId}`);
             return;
         }
         const { decoders, callback, pubSubTopic } = subscription;
         if (!decoders || !decoders.length) {
-            log$3(`No decoder registered for request ID ${requestId}`);
+            log$4(`No decoder registered for request ID ${requestId}`);
             return;
         }
         for (const protoMessage of messages) {
             const contentTopic = protoMessage.contentTopic;
             if (!contentTopic) {
-                log$3("Message has no content topic, skipping");
+                log$4("Message has no content topic, skipping");
                 return;
             }
             let didDecodeMsg = false;
@@ -4992,7 +4992,7 @@ class Filter extends BaseProtocol {
                     return;
                 const decoded = await dec.fromProtoObj(pubSubTopic, toProtoMessage(protoMessage));
                 if (!decoded) {
-                    log$3("Not able to decode message");
+                    log$4("Not able to decode message");
                     return;
                 }
                 // This is just to prevent more decoding attempt
@@ -5009,7 +5009,7 @@ class Filter extends BaseProtocol {
             await pipe([unsubscribeRequest.encode()], encode, stream.sink);
         }
         catch (e) {
-            log$3("Error unsubscribing", e);
+            log$4("Error unsubscribing", e);
             throw e;
         }
     }
@@ -5018,12 +5018,351 @@ function wakuFilter(init = {}) {
     return (libp2p) => new Filter(libp2p, init);
 }
 
-var index$2 = /*#__PURE__*/Object.freeze({
+var index$3 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     FilterCodec: FilterCodec,
     wakuFilter: wakuFilter
 });
 
+/**
+ * FilterPushRPC represents a message conforming to the Waku FilterPush protocol.
+ * Protocol documentation: https://rfc.vac.dev/spec/12/
+ */
+class FilterPushRpc {
+    proto;
+    constructor(proto) {
+        this.proto = proto;
+    }
+    static decode(bytes) {
+        const res = MessagePush.decode(bytes);
+        return new FilterPushRpc(res);
+    }
+    encode() {
+        return MessagePush.encode(this.proto);
+    }
+    get wakuMessage() {
+        return this.proto.wakuMessage;
+    }
+    /**
+     * Get the pubsub topic from the FilterPushRpc object.
+     * @returns string
+     */
+    get pubsubTopic() {
+        return this.proto.pubsubTopic;
+    }
+}
+class FilterSubscribeRpc {
+    proto;
+    constructor(proto) {
+        this.proto = proto;
+    }
+    static createSubscribeRequest(pubsubTopic, contentTopics) {
+        return new FilterSubscribeRpc({
+            requestId: v4(),
+            filterSubscribeType: FilterSubscribeRequest.FilterSubscribeType.SUBSCRIBE,
+            pubsubTopic,
+            contentTopics,
+        });
+    }
+    static createUnsubscribeRequest(pubsubTopic, contentTopics) {
+        return new FilterSubscribeRpc({
+            requestId: v4(),
+            filterSubscribeType: FilterSubscribeRequest.FilterSubscribeType.UNSUBSCRIBE,
+            pubsubTopic,
+            contentTopics,
+        });
+    }
+    static createUnsubscribeAllRequest(pubsubTopic) {
+        return new FilterSubscribeRpc({
+            requestId: v4(),
+            filterSubscribeType: FilterSubscribeRequest.FilterSubscribeType.UNSUBSCRIBE_ALL,
+            pubsubTopic,
+            contentTopics: [],
+        });
+    }
+    static createSubscriberPingRequest() {
+        return new FilterSubscribeRpc({
+            requestId: v4(),
+            filterSubscribeType: FilterSubscribeRequest.FilterSubscribeType.SUBSCRIBER_PING,
+            pubsubTopic: "",
+            contentTopics: [],
+        });
+    }
+    static decode(bytes) {
+        const res = FilterSubscribeRequest.decode(bytes);
+        return new FilterSubscribeRpc(res);
+    }
+    encode() {
+        return FilterSubscribeRequest.encode(this.proto);
+    }
+    get filterSubscribeType() {
+        return this.proto.filterSubscribeType;
+    }
+    get requestId() {
+        return this.proto.requestId;
+    }
+    get pubsubTopic() {
+        return this.proto.pubsubTopic;
+    }
+    get contentTopics() {
+        return this.proto.contentTopics;
+    }
+}
+class FilterSubscribeResponse {
+    proto;
+    constructor(proto) {
+        this.proto = proto;
+    }
+    static decode(bytes) {
+        const res = FilterSubscribeResponse$1.decode(bytes);
+        return new FilterSubscribeResponse(res);
+    }
+    encode() {
+        return FilterSubscribeResponse$1.encode(this.proto);
+    }
+    get statusCode() {
+        return this.proto.statusCode;
+    }
+    get statusDesc() {
+        return this.proto.statusDesc;
+    }
+    get requestId() {
+        return this.proto.requestId;
+    }
+}
+
+const log$3 = debug("waku:filter:v2");
+const FilterV2Codecs = {
+    SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
+    PUSH: "/vac/waku/filter-push/2.0.0-beta1",
+};
+class Subscription {
+    peer;
+    pubSubTopic;
+    newStream;
+    subscriptionCallbacks;
+    constructor(pubSubTopic, remotePeer, newStream) {
+        this.peer = remotePeer;
+        this.pubSubTopic = pubSubTopic;
+        this.newStream = newStream;
+        this.subscriptionCallbacks = new Map();
+    }
+    async subscribe(decoders, callback) {
+        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()], encode, stream, 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$3("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,
+            };
+            // 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) {
+        const stream = await this.newStream(this.peer);
+        const unsubscribeRequest = FilterSubscribeRpc.createUnsubscribeRequest(this.pubSubTopic, contentTopics);
+        try {
+            await pipe([unsubscribeRequest.encode()], encode, stream.sink);
+        }
+        catch (error) {
+            throw new Error("Error subscribing: " + error);
+        }
+        contentTopics.forEach((contentTopic) => {
+            this.subscriptionCallbacks.delete(contentTopic);
+        });
+    }
+    async ping() {
+        const stream = await this.newStream(this.peer);
+        const request = FilterSubscribeRpc.createSubscriberPingRequest();
+        try {
+            const res = await pipe([request.encode()], encode, stream, 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$3("Ping successful");
+        }
+        catch (error) {
+            log$3("Error pinging: ", error);
+            throw new Error("Error pinging: " + error);
+        }
+    }
+    async unsubscribeAll() {
+        const stream = await this.newStream(this.peer);
+        const request = FilterSubscribeRpc.createUnsubscribeAllRequest(this.pubSubTopic);
+        try {
+            const res = await pipe([request.encode()], encode, stream, 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$3("Unsubscribed from all content topics");
+        }
+        catch (error) {
+            throw new Error("Error unsubscribing from all content topics: " + error);
+        }
+    }
+    async processMessage(message) {
+        const contentTopic = message.contentTopic;
+        const subscriptionCallback = this.subscriptionCallbacks.get(contentTopic);
+        if (!subscriptionCallback) {
+            log$3("No subscription callback available for ", contentTopic);
+            return;
+        }
+        await pushMessage(subscriptionCallback, this.pubSubTopic, message);
+    }
+}
+class FilterV2 extends BaseProtocol {
+    libp2p;
+    options;
+    activeSubscriptions = new Map();
+    getActiveSubscription(pubSubTopic, peerIdStr) {
+        return this.activeSubscriptions.get(`${pubSubTopic}_${peerIdStr}`);
+    }
+    setActiveSubscription(pubSubTopic, peerIdStr, subscription) {
+        this.activeSubscriptions.set(`${pubSubTopic}_${peerIdStr}`, subscription);
+        return subscription;
+    }
+    constructor(libp2p, options) {
+        super(FilterV2Codecs.SUBSCRIBE, libp2p.peerStore, libp2p.getConnections.bind(libp2p));
+        this.libp2p = libp2p;
+        this.libp2p
+            .handle(FilterV2Codecs.PUSH, this.onRequest.bind(this))
+            .catch((e) => {
+            log$3("Failed to register ", FilterV2Codecs.PUSH, e);
+        });
+        this.activeSubscriptions = new Map();
+        this.options = options ?? {};
+    }
+    async createSubscription(pubSubTopic, peerId) {
+        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;
+    }
+    toSubscriptionIterator(decoders, opts) {
+        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(decoders, callback, opts) {
+        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);
+        };
+    }
+    onRequest(streamData) {
+        log$3("Receiving message push");
+        try {
+            pipe(streamData.stream, decode, async (source) => {
+                for await (const bytes of source) {
+                    const response = FilterPushRpc.decode(bytes.slice());
+                    const { pubsubTopic, wakuMessage } = response;
+                    if (!wakuMessage) {
+                        log$3("Received empty message");
+                        return;
+                    }
+                    if (!pubsubTopic) {
+                        log$3("PubSub topic missing from push message");
+                        return;
+                    }
+                    const peerIdStr = streamData.connection.remotePeer.toString();
+                    const subscription = this.getActiveSubscription(pubsubTopic, peerIdStr);
+                    if (!subscription) {
+                        log$3(`No subscription locally registered for topic ${pubsubTopic}`);
+                        return;
+                    }
+                    await subscription.processMessage(wakuMessage);
+                }
+            }).then(() => {
+                log$3("Receiving pipe closed.");
+            }, (e) => {
+                log$3("Error with receiving pipe", e);
+            });
+        }
+        catch (e) {
+            log$3("Error decoding message", e);
+        }
+    }
+}
+function wakuFilterV2(init = {}) {
+    return (libp2p) => new FilterV2(libp2p, init);
+}
+async function pushMessage(subscriptionCallback, pubSubTopic, message) {
+    const { decoders, callback } = subscriptionCallback;
+    const { contentTopic } = message;
+    if (!contentTopic) {
+        log$3("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) => {
+        if (didDecodeMsg)
+            return;
+        const decoded = await dec.fromProtoObj(pubSubTopic, message);
+        // const decoded = await dec.fromProtoObj(pubSubTopic, message);
+        if (!decoded) {
+            log$3("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);
+    });
+}
+
+var index$2 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    wakuFilterV2: wakuFilterV2
+});
+
 class PushRpc {
     proto;
     constructor(proto) {
@@ -6074,4 +6413,4 @@ function getEnabledProtocols(waku) {
     return protocols;
 }
 
-export { ConnectionManager, DefaultPubSubTopic, DefaultUserAgent, KeepAliveManager, LightPushCodec, PageDirection, StoreCodec, WakuNode, createCursor, createEncoder, index$3 as message, waitForRemotePeer, waku, wakuFilter, wakuLightPush, wakuStore, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };
+export { ConnectionManager, DefaultPubSubTopic, DefaultUserAgent, KeepAliveManager, LightPushCodec, PageDirection, StoreCodec, WakuNode, createCursor, createEncoder, index$4 as message, waitForRemotePeer, waku, wakuFilter as wakuFilterV1, wakuFilterV2, wakuLightPush, wakuStore, index$3 as waku_filter_v1, index$2 as waku_filter_v2, index$1 as waku_light_push, index as waku_store };

package/bundle/lib/message/version_0.js

@@ -1,2 +1,2 @@
-export { D as DecodedMessage, f as Decoder, E as Encoder, V as Version, e as createDecoder, c as createEncoder, m as proto } from '../../version_0-c6b47311.js';
+export { D as DecodedMessage, h as Decoder, E as Encoder, V as Version, g as createDecoder, c as createEncoder, m as proto } from '../../version_0-9c941081.js';
 import '../../browser-bde977a3.js';