@waku/core 0.0.18 → 0.0.20

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,9 +3038,10 @@ 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;
+const DEFAULT_MAX_PARALLEL_DIALS = 3;
 class ConnectionManager {
     static instances = new Map();
     keepAliveManager;
@@ -3048,6 +3049,8 @@ class ConnectionManager {
     libp2pComponents;
     dialAttemptsForPeer = new Map();
     dialErrorsForPeer = new Map();
+    currentActiveDialCount = 0;
+    pendingPeerDialQueue = [];
     static create(peerId, libp2p, keepAliveOptions, relay, options) {
         let instance = ConnectionManager.instances.get(peerId);
         if (!instance) {
@@ -3061,12 +3064,34 @@ class ConnectionManager {
         this.options = {
             maxDialAttemptsForPeer: DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER,
             maxBootstrapPeersAllowed: DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED,
+            maxParallelDials: DEFAULT_MAX_PARALLEL_DIALS,
             ...options,
         };
         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));
+        // libp2p emits `peer:discovery` events during its initialization
+        // which means that before the ConnectionManager is initialized, some peers may have been discovered
+        // we will dial the peers in peerStore ONCE before we start to listen to the `peer:discovery` events within the ConnectionManager
+        this.dialPeerStorePeers();
+    }
+    async dialPeerStorePeers() {
+        const peerInfos = await this.libp2pComponents.peerStore.all();
+        const dialPromises = [];
+        for (const peerInfo of peerInfos) {
+            if (this.libp2pComponents
+                .getConnections()
+                .find((c) => c.remotePeer === peerInfo.id))
+                continue;
+            dialPromises.push(this.attemptDial(peerInfo.id));
+        }
+        try {
+            await Promise.all(dialPromises);
+        }
+        catch (error) {
+            log$6(`Unexpected error while dialing peer store peers`, error);
+        }
     }
     async run() {
         // start event listeners
@@ -3081,10 +3106,11 @@ class ConnectionManager {
         this.libp2pComponents.removeEventListener("peer:discovery", this.onEventHandlers["peer:discovery"]);
     }
     async dialPeer(peerId) {
+        this.currentActiveDialCount += 1;
         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 +3124,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);
@@ -3115,6 +3141,30 @@ class ConnectionManager {
         catch (error) {
             throw `Error deleting undialable peer ${peerId.toString()} from peer store - ${error}`;
         }
+        finally {
+            this.currentActiveDialCount -= 1;
+            this.processDialQueue();
+        }
+    }
+    async dropConnection(peerId) {
+        try {
+            await this.libp2pComponents.hangUp(peerId);
+            log$6(`Dropped connection with peer ${peerId.toString()}`);
+        }
+        catch (error) {
+            log$6(`Error dropping connection with peer ${peerId.toString()} - ${error}`);
+        }
+    }
+    async processDialQueue() {
+        if (this.pendingPeerDialQueue.length > 0 &&
+            this.currentActiveDialCount < this.options.maxParallelDials) {
+            const peerId = this.pendingPeerDialQueue.shift();
+            if (!peerId)
+                return;
+            this.attemptDial(peerId).catch((error) => {
+                log$6(error);
+            });
+        }
     }
     startPeerDiscoveryListener() {
         this.libp2pComponents.peerStore.addEventListener("peer", this.onEventHandlers["peer:discovery"]);
@@ -3137,16 +3187,34 @@ class ConnectionManager {
          */
         this.libp2pComponents.addEventListener("peer:disconnect", this.onEventHandlers["peer:disconnect"]);
     }
+    async attemptDial(peerId) {
+        if (this.currentActiveDialCount >= this.options.maxParallelDials) {
+            this.pendingPeerDialQueue.push(peerId);
+            return;
+        }
+        if (!(await this.shouldDialPeer(peerId)))
+            return;
+        this.dialPeer(peerId).catch((err) => {
+            throw `Error dialing peer ${peerId.toString()} : ${err}`;
+        });
+    }
     onEventHandlers = {
         "peer:discovery": async (evt) => {
             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.attemptDial(peerId).catch((err) => log$6(`Error dialing peer ${peerId.toString()} : ${err}`));
         },
-        "peer:connect": (evt) => {
-            {
-                this.keepAliveManager.start(evt.detail.remotePeer, this.libp2pComponents.ping.bind(this));
+        "peer:connect": async (evt) => {
+            const { remotePeer: peerId } = evt.detail;
+            this.keepAliveManager.start(peerId, this.libp2pComponents.ping.bind(this));
+            const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(Tags.BOOTSTRAP);
+            if (isBootstrap) {
+                const bootstrapConnections = this.libp2pComponents
+                    .getConnections()
+                    .filter((conn) => conn.tags.includes(Tags.BOOTSTRAP));
+                // If we have too many bootstrap connections, drop one
+                if (bootstrapConnections.length > this.options.maxBootstrapPeersAllowed) {
+                    await this.dropConnection(peerId);
+                }
             }
         },
         "peer:disconnect": () => {
@@ -3191,7 +3259,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 +3287,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 +3311,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 +3319,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 +3327,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 +3335,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 +3383,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
 });
@@ -3397,11 +3465,11 @@ const isSizeValid = (payload) => {
     return true;
 };
 
-function isAsyncIterable$1(thing) {
+function isAsyncIterable$3(thing) {
     return thing[Symbol.asyncIterator] != null;
 }
 function all(source) {
-    if (isAsyncIterable$1(source)) {
+    if (isAsyncIterable$3(source)) {
         return (async () => {
             const arr = [];
             for await (const entry of source) {
@@ -4158,7 +4226,7 @@ const unsigned = {
     }
 };
 
-function isAsyncIterable(thing) {
+function isAsyncIterable$2(thing) {
     return thing[Symbol.asyncIterator] != null;
 }
 
@@ -4191,7 +4259,7 @@ function encode(source, options) {
             yield* chunk;
         }
     }
-    if (isAsyncIterable(source)) {
+    if (isAsyncIterable$2(source)) {
         return (async function* () {
             for await (const chunk of source) {
                 yield* maybeYield(chunk);
@@ -4347,7 +4415,7 @@ function decode(source, options) {
             }
         }
     }
-    if (isAsyncIterable(source)) {
+    if (isAsyncIterable$2(source)) {
         return (async function* () {
             for await (const buf of source) {
                 buffer.append(buf);
@@ -4662,77 +4730,56 @@ function _pushable(getNext, options) {
     return pushable;
 }
 
-/**
- * Treat one or more iterables as a single iterable.
- *
- * Nb. sources are iterated over in parallel so the
- * order of emitted items is not guaranteed.
- */
-async function* merge(...sources) {
-    const output = pushable({
-        objectMode: true
-    });
-    void Promise.resolve().then(async () => {
-        try {
-            await Promise.all(sources.map(async (source) => {
-                for await (const item of source) {
-                    output.push(item);
-                }
-            }));
-            output.end();
-        }
-        catch (err) {
-            output.end(err);
+function isAsyncIterable$1(thing) {
+    return thing[Symbol.asyncIterator] != null;
+}
+function merge(...sources) {
+    const syncSources = [];
+    for (const source of sources) {
+        if (!isAsyncIterable$1(source)) {
+            syncSources.push(source);
         }
-    });
-    yield* output;
+    }
+    if (syncSources.length === sources.length) {
+        // all sources are synchronous
+        return (function* () {
+            for (const source of syncSources) {
+                yield* source;
+            }
+        })();
+    }
+    return (async function* () {
+        const output = pushable({
+            objectMode: true
+        });
+        void Promise.resolve().then(async () => {
+            try {
+                await Promise.all(sources.map(async (source) => {
+                    for await (const item of source) {
+                        output.push(item);
+                    }
+                }));
+                output.end();
+            }
+            catch (err) {
+                output.end(err);
+            }
+        });
+        yield* output;
+    })();
 }
 
-const rawPipe = (...fns) => {
-    let res;
-    while (fns.length > 0) {
-        res = fns.shift()(res);
-    }
-    return res;
-};
-const isIterable = (obj) => {
-    return obj != null && (typeof obj[Symbol.asyncIterator] === 'function' ||
-        typeof obj[Symbol.iterator] === 'function' ||
-        typeof obj.next === 'function' // Probably, right?
-    );
-};
-const isDuplex = (obj) => {
-    return obj != null && typeof obj.sink === 'function' && isIterable(obj.source);
-};
-const duplexPipelineFn = (duplex) => {
-    return (source) => {
-        const p = duplex.sink(source);
-        if (p.then != null) {
-            const stream = pushable({
-                objectMode: true
-            });
-            p.then(() => {
-                stream.end();
-            }, (err) => {
-                stream.end(err);
-            });
-            const sourceWrap = async function* () {
-                yield* duplex.source;
-                stream.end();
-            };
-            return merge(stream, sourceWrap());
-        }
-        return duplex.source;
-    };
-};
 function pipe(first, ...rest) {
+    if (first == null) {
+        throw new Error('Empty pipeline');
+    }
     // Duplex at start: wrap in function and return duplex source
     if (isDuplex(first)) {
         const duplex = first;
         first = () => duplex.source;
         // Iterable at start: wrap in function
     }
-    else if (isIterable(first)) {
+    else if (isIterable(first) || isAsyncIterable(first)) {
         const source = first;
         first = () => source;
     }
@@ -4753,6 +4800,59 @@ function pipe(first, ...rest) {
     }
     return rawPipe(...fns);
 }
+const rawPipe = (...fns) => {
+    let res;
+    while (fns.length > 0) {
+        res = fns.shift()(res);
+    }
+    return res;
+};
+const isAsyncIterable = (obj) => {
+    return obj?.[Symbol.asyncIterator] != null;
+};
+const isIterable = (obj) => {
+    return obj?.[Symbol.iterator] != null;
+};
+const isDuplex = (obj) => {
+    if (obj == null) {
+        return false;
+    }
+    return obj.sink != null && obj.source != null;
+};
+const duplexPipelineFn = (duplex) => {
+    return (source) => {
+        const p = duplex.sink(source);
+        if (p?.then != null) {
+            const stream = pushable({
+                objectMode: true
+            });
+            p.then(() => {
+                stream.end();
+            }, (err) => {
+                stream.end(err);
+            });
+            let sourceWrap;
+            const source = duplex.source;
+            if (isAsyncIterable(source)) {
+                sourceWrap = async function* () {
+                    yield* source;
+                    stream.end();
+                };
+            }
+            else if (isIterable(source)) {
+                sourceWrap = function* () {
+                    yield* source;
+                    stream.end();
+                };
+            }
+            else {
+                throw new Error('Unknown duplex source type - must be Iterable or AsyncIterable');
+            }
+            return merge(stream, sourceWrap());
+        }
+        return duplex.source;
+    };
+};
 
 const EmptyMessage = {
     payload: new Uint8Array(),
@@ -4876,7 +4976,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 +4995,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 +5016,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 +5047,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 +5057,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 +5092,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 +5109,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 +5118,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) {
@@ -5974,7 +6413,7 @@ const log = debug("waku:wait-for-remote-peer");
  * Wait for a remote peer to be ready given the passed protocols.
  * Must be used after attempting to connect to nodes, using
  * {@link @waku/core.WakuNode.dial} or a bootstrap method with
- * {@link @waku/create.createLightNode}.
+ * {@link @waku/sdk.createLightNode}.
  *
  * If the passed protocols is a GossipSub protocol, then it resolves only once
  * a peer is in a mesh, to help ensure that other peers will send and receive
@@ -6074,4 +6513,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 };