@waku/core 0.0.19 → 0.0.21

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, 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 { c as createEncoder, v as version_0, M as MessagePush, F as FilterSubscribeRequest, a as FilterSubscribeResponse$1, P as PushRpc$1, b as PushResponse, H as HistoryRpc$1, d as PagingInfo, e as HistoryResponse } from './version_0-86411fdf.js';
+export { f as createDecoder } from './version_0-86411fdf.js';
 import { BaseProtocol } from './lib/base_protocol.js';
 
 const symbol$2 = Symbol.for('@libp2p/peer-id');
@@ -1891,7 +1891,7 @@ const BASES = {
     'utf-8': string,
     hex: bases.base16,
     latin1: ascii,
-    ascii: ascii,
+    ascii,
     binary: ascii,
     ...bases
 };
@@ -2608,6 +2608,8 @@ function protoFromTuple(tup) {
  * AbortSignal.
  */
 class CodeError extends Error {
+    code;
+    props;
     constructor(message, code, props) {
         super(message);
         this.code = code;
@@ -2973,9 +2975,86 @@ var Tags;
     Tags["BOOTSTRAP"] = "bootstrap";
     Tags["PEER_EXCHANGE"] = "peer-exchange";
 })(Tags || (Tags = {}));
+var EPeersByDiscoveryEvents;
+(function (EPeersByDiscoveryEvents) {
+    EPeersByDiscoveryEvents["PEER_DISCOVERY_BOOTSTRAP"] = "peer:discovery:bootstrap";
+    EPeersByDiscoveryEvents["PEER_DISCOVERY_PEER_EXCHANGE"] = "peer:discovery:peer-exchange";
+    EPeersByDiscoveryEvents["PEER_CONNECT_BOOTSTRAP"] = "peer:connected:bootstrap";
+    EPeersByDiscoveryEvents["PEER_CONNECT_PEER_EXCHANGE"] = "peer:connected:peer-exchange";
+})(EPeersByDiscoveryEvents || (EPeersByDiscoveryEvents = {}));
+
+/**
+ * Adds types to the EventTarget class. Hopefully this won't be necessary forever.
+ *
+ * https://github.com/microsoft/TypeScript/issues/28357
+ * https://github.com/microsoft/TypeScript/issues/43477
+ * https://github.com/microsoft/TypeScript/issues/299
+ * etc
+ */
+class EventEmitter extends EventTarget {
+    #listeners = new Map();
+    listenerCount(type) {
+        const listeners = this.#listeners.get(type);
+        if (listeners == null) {
+            return 0;
+        }
+        return listeners.length;
+    }
+    addEventListener(type, listener, options) {
+        super.addEventListener(type, listener, options);
+        let list = this.#listeners.get(type);
+        if (list == null) {
+            list = [];
+            this.#listeners.set(type, list);
+        }
+        list.push({
+            callback: listener,
+            once: (options !== true && options !== false && options?.once) ?? false
+        });
+    }
+    removeEventListener(type, listener, options) {
+        super.removeEventListener(type.toString(), listener ?? null, options);
+        let list = this.#listeners.get(type);
+        if (list == null) {
+            return;
+        }
+        list = list.filter(({ callback }) => callback !== listener);
+        this.#listeners.set(type, list);
+    }
+    dispatchEvent(event) {
+        const result = super.dispatchEvent(event);
+        let list = this.#listeners.get(event.type);
+        if (list == null) {
+            return result;
+        }
+        list = list.filter(({ once }) => !once);
+        this.#listeners.set(event.type, list);
+        return result;
+    }
+    safeDispatchEvent(type, detail) {
+        return this.dispatchEvent(new CustomEvent(type, detail));
+    }
+}
+/**
+ * CustomEvent is a standard event but it's not supported by node.
+ *
+ * Remove this when https://github.com/nodejs/node/issues/40678 is closed.
+ *
+ * Ref: https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent
+ */
+class CustomEventPolyfill extends Event {
+    /** Returns any custom data event was created with. Typically used for synthetic events. */
+    detail;
+    constructor(message, data) {
+        super(message, data);
+        // @ts-expect-error could be undefined
+        this.detail = data?.detail;
+    }
+}
+const CustomEvent = globalThis.CustomEvent ?? CustomEventPolyfill;
 
 const RelayPingContentTopic = "/relay-ping/1/ping/null";
-const log$7 = debug("waku:keep-alive");
+const log$6 = debug("waku:keep-alive");
 class KeepAliveManager {
     pingKeepAliveTimers;
     relayKeepAliveTimers;
@@ -2994,8 +3073,8 @@ class KeepAliveManager {
         const peerIdStr = peerId.toString();
         if (pingPeriodSecs !== 0) {
             const interval = setInterval(() => {
-                libp2pPing(peerId).catch((e) => {
-                    log$7(`Ping failed (${peerIdStr})`, e);
+                libp2pPing.ping(peerId).catch((e) => {
+                    log$6(`Ping failed (${peerIdStr})`, e);
                 });
             }, pingPeriodSecs * 1000);
             this.pingKeepAliveTimers.set(peerIdStr, interval);
@@ -3007,10 +3086,10 @@ class KeepAliveManager {
                 ephemeral: true,
             });
             const interval = setInterval(() => {
-                log$7("Sending Waku Relay ping message");
+                log$6("Sending Waku Relay ping message");
                 relay
                     .send(encoder, { payload: new Uint8Array([1]) })
-                    .catch((e) => log$7("Failed to send relay ping", e));
+                    .catch((e) => log$6("Failed to send relay ping", e));
             }, relayPeriodSecs * 1000);
             this.relayKeepAliveTimers.set(peerId, interval);
         }
@@ -3038,16 +3117,19 @@ class KeepAliveManager {
     }
 }
 
-const log$6 = debug("waku:connection-manager");
+const log$5 = debug("waku:connection-manager");
 const DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED = 1;
 const DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER = 3;
-class ConnectionManager {
+const DEFAULT_MAX_PARALLEL_DIALS = 3;
+class ConnectionManager extends EventEmitter {
     static instances = new Map();
     keepAliveManager;
     options;
-    libp2pComponents;
+    libp2p;
     dialAttemptsForPeer = new Map();
     dialErrorsForPeer = new Map();
+    currentActiveDialCount = 0;
+    pendingPeerDialQueue = [];
     static create(peerId, libp2p, keepAliveOptions, relay, options) {
         let instance = ConnectionManager.instances.get(peerId);
         if (!instance) {
@@ -3056,17 +3138,77 @@ class ConnectionManager {
         }
         return instance;
     }
-    constructor(libp2pComponents, keepAliveOptions, relay, options) {
-        this.libp2pComponents = libp2pComponents;
+    async getPeersByDiscovery() {
+        const peersDiscovered = await this.libp2p.peerStore.all();
+        const peersConnected = this.libp2p
+            .getConnections()
+            .map((conn) => conn.remotePeer);
+        const peersDiscoveredByBootstrap = [];
+        const peersDiscoveredByPeerExchange = [];
+        const peersConnectedByBootstrap = [];
+        const peersConnectedByPeerExchange = [];
+        for (const peer of peersDiscovered) {
+            const tags = await this.getTagNamesForPeer(peer.id);
+            if (tags.includes(Tags.BOOTSTRAP)) {
+                peersDiscoveredByBootstrap.push(peer);
+            }
+            else if (tags.includes(Tags.PEER_EXCHANGE)) {
+                peersDiscoveredByPeerExchange.push(peer);
+            }
+        }
+        for (const peerId of peersConnected) {
+            const peer = await this.libp2p.peerStore.get(peerId);
+            const tags = await this.getTagNamesForPeer(peerId);
+            if (tags.includes(Tags.BOOTSTRAP)) {
+                peersConnectedByBootstrap.push(peer);
+            }
+            else if (tags.includes(Tags.PEER_EXCHANGE)) {
+                peersConnectedByPeerExchange.push(peer);
+            }
+        }
+        return {
+            DISCOVERED: {
+                [Tags.BOOTSTRAP]: peersDiscoveredByBootstrap,
+                [Tags.PEER_EXCHANGE]: peersDiscoveredByPeerExchange,
+            },
+            CONNECTED: {
+                [Tags.BOOTSTRAP]: peersConnectedByBootstrap,
+                [Tags.PEER_EXCHANGE]: peersConnectedByPeerExchange,
+            },
+        };
+    }
+    constructor(libp2p, keepAliveOptions, relay, options) {
+        super();
+        this.libp2p = libp2p;
         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$6(`Connection Manager is now running`))
-            .catch((error) => log$6(`Unexpected error while running service`, error));
+            .then(() => log$5(`Connection Manager is now running`))
+            .catch((error) => log$5(`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().catch((error) => log$5(`Unexpected error while dialing peer store peers`, error));
+    }
+    async dialPeerStorePeers() {
+        const peerInfos = await this.libp2p.peerStore.all();
+        const dialPromises = [];
+        for (const peerInfo of peerInfos) {
+            if (this.libp2p.getConnections().find((c) => c.remotePeer === peerInfo.id))
+                continue;
+            dialPromises.push(this.attemptDial(peerInfo.id));
+        }
+        try {
+            await Promise.all(dialPromises);
+        }
+        catch (error) {
+            log$5(`Unexpected error while dialing peer store peers`, error);
+        }
     }
     async run() {
         // start event listeners
@@ -3076,20 +3218,21 @@ class ConnectionManager {
     }
     stop() {
         this.keepAliveManager.stopAll();
-        this.libp2pComponents.removeEventListener("peer:connect", this.onEventHandlers["peer:connect"]);
-        this.libp2pComponents.removeEventListener("peer:disconnect", this.onEventHandlers["peer:disconnect"]);
-        this.libp2pComponents.removeEventListener("peer:discovery", this.onEventHandlers["peer:discovery"]);
+        this.libp2p.removeEventListener("peer:connect", this.onEventHandlers["peer:connect"]);
+        this.libp2p.removeEventListener("peer:disconnect", this.onEventHandlers["peer:disconnect"]);
+        this.libp2p.removeEventListener("peer:discovery", this.onEventHandlers["peer:discovery"]);
     }
     async dialPeer(peerId) {
+        this.currentActiveDialCount += 1;
         let dialAttempt = 0;
         while (dialAttempt <= this.options.maxDialAttemptsForPeer) {
             try {
-                log$6(`Dialing peer ${peerId.toString()}`);
-                await this.libp2pComponents.dial(peerId);
+                log$5(`Dialing peer ${peerId.toString()}`);
+                await this.libp2p.dial(peerId);
                 const tags = await this.getTagNamesForPeer(peerId);
                 // add tag to connection describing discovery mechanism
                 // don't add duplicate tags
-                this.libp2pComponents
+                this.libp2p
                     .getConnections(peerId)
                     .forEach((conn) => (conn.tags = Array.from(new Set([...conn.tags, ...tags]))));
                 this.dialAttemptsForPeer.delete(peerId.toString());
@@ -3098,29 +3241,54 @@ class ConnectionManager {
             catch (e) {
                 const error = e;
                 this.dialErrorsForPeer.set(peerId.toString(), error);
-                log$6(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
+                log$5(`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$6(`Reattempting dial (${dialAttempt})`);
+                    log$5(`Reattempting dial (${dialAttempt})`);
                 }
             }
         }
         try {
-            log$6(`Deleting undialable peer ${peerId.toString()} from peer store. Error: ${JSON.stringify(this.dialErrorsForPeer.get(peerId.toString()).errors[0])}
+            log$5(`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);
+            return await this.libp2p.peerStore.delete(peerId);
         }
         catch (error) {
             throw `Error deleting undialable peer ${peerId.toString()} from peer store - ${error}`;
         }
+        finally {
+            this.currentActiveDialCount -= 1;
+            this.processDialQueue();
+        }
+    }
+    async dropConnection(peerId) {
+        try {
+            this.keepAliveManager.stop(peerId);
+            await this.libp2p.hangUp(peerId);
+            log$5(`Dropped connection with peer ${peerId.toString()}`);
+        }
+        catch (error) {
+            log$5(`Error dropping connection with peer ${peerId.toString()} - ${error}`);
+        }
+    }
+    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$5(error);
+            });
+        }
     }
     startPeerDiscoveryListener() {
-        this.libp2pComponents.peerStore.addEventListener("peer", this.onEventHandlers["peer:discovery"]);
+        this.libp2p.addEventListener("peer:discovery", this.onEventHandlers["peer:discovery"]);
     }
     startPeerConnectionListener() {
-        this.libp2pComponents.addEventListener("peer:connect", this.onEventHandlers["peer:connect"]);
+        this.libp2p.addEventListener("peer:connect", this.onEventHandlers["peer:connect"]);
     }
     startPeerDisconnectionListener() {
         // TODO: ensure that these following issues are updated and confirmed
@@ -3135,23 +3303,71 @@ class ConnectionManager {
          * >this event will **only** be triggered when the last connection is closed.
          * @see https://github.com/libp2p/js-libp2p/blob/bad9e8c0ff58d60a78314077720c82ae331cc55b/doc/API.md?plain=1#L2100
          */
-        this.libp2pComponents.addEventListener("peer:disconnect", this.onEventHandlers["peer:disconnect"]);
+        this.libp2p.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$6(`Error dialing peer ${peerId.toString()} : ${err}`));
+        "peer:discovery": (evt) => {
+            void (async () => {
+                const { id: peerId } = evt.detail;
+                const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(Tags.BOOTSTRAP);
+                if (isBootstrap) {
+                    this.dispatchEvent(new CustomEvent(EPeersByDiscoveryEvents.PEER_DISCOVERY_BOOTSTRAP, {
+                        detail: peerId,
+                    }));
+                }
+                else {
+                    this.dispatchEvent(new CustomEvent(EPeersByDiscoveryEvents.PEER_DISCOVERY_PEER_EXCHANGE, {
+                        detail: peerId,
+                    }));
+                }
+                try {
+                    await this.attemptDial(peerId);
+                }
+                catch (error) {
+                    log$5(`Error dialing peer ${peerId.toString()} : ${error}`);
+                }
+            })();
         },
         "peer:connect": (evt) => {
-            {
-                this.keepAliveManager.start(evt.detail.remotePeer, this.libp2pComponents.ping.bind(this));
-            }
+            void (async () => {
+                const peerId = evt.detail;
+                this.keepAliveManager.start(peerId, this.libp2p.services.ping);
+                const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(Tags.BOOTSTRAP);
+                if (isBootstrap) {
+                    const bootstrapConnections = this.libp2p
+                        .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);
+                    }
+                    else {
+                        this.dispatchEvent(new CustomEvent(EPeersByDiscoveryEvents.PEER_CONNECT_BOOTSTRAP, {
+                            detail: peerId,
+                        }));
+                    }
+                }
+                else {
+                    this.dispatchEvent(new CustomEvent(EPeersByDiscoveryEvents.PEER_CONNECT_PEER_EXCHANGE, {
+                        detail: peerId,
+                    }));
+                }
+            })();
         },
         "peer:disconnect": () => {
             return (evt) => {
-                this.keepAliveManager.stop(evt.detail.remotePeer);
+                this.keepAliveManager.stop(evt.detail);
             };
         },
     };
@@ -3161,15 +3377,16 @@ class ConnectionManager {
      * 2. If the peer is not a bootstrap peer
      */
     async shouldDialPeer(peerId) {
-        const isConnected = this.libp2pComponents.getConnections(peerId).length > 0;
+        const isConnected = this.libp2p.getConnections(peerId).length > 0;
         if (isConnected)
             return false;
-        const isBootstrap = (await this.getTagNamesForPeer(peerId)).some((tagName) => tagName === Tags.BOOTSTRAP);
+        const tagNames = await this.getTagNamesForPeer(peerId);
+        const isBootstrap = tagNames.some((tagName) => tagName === Tags.BOOTSTRAP);
         if (isBootstrap) {
-            const currentBootstrapConnections = this.libp2pComponents
+            const currentBootstrapConnections = this.libp2p
                 .getConnections()
                 .filter((conn) => {
-                conn.tags.find((name) => name === Tags.BOOTSTRAP);
+                return conn.tags.find((name) => name === Tags.BOOTSTRAP);
             }).length;
             if (currentBootstrapConnections < this.options.maxBootstrapPeersAllowed)
                 return true;
@@ -3183,15 +3400,21 @@ class ConnectionManager {
      * Fetches the tag names for a given peer
      */
     async getTagNamesForPeer(peerId) {
-        const tags = (await this.libp2pComponents.peerStore.getTags(peerId)).map((tag) => tag.name);
-        return tags;
+        try {
+            const peer = await this.libp2p.peerStore.get(peerId);
+            return Array.from(peer.tags.keys());
+        }
+        catch (error) {
+            log$5(`Failed to get peer ${peerId}, error: ${error}`);
+            return [];
+        }
     }
 }
 
 const DefaultPingKeepAliveValueSecs = 0;
 const DefaultRelayKeepAliveValueSecs = 5 * 60;
 const DefaultUserAgent = "js-waku";
-const log$5 = debug("waku:waku");
+const log$4 = debug("waku:waku");
 class WakuNode {
     libp2p;
     relay;
@@ -3219,7 +3442,7 @@ class WakuNode {
             : 0;
         const peerId = this.libp2p.peerId.toString();
         this.connectionManager = ConnectionManager.create(peerId, libp2p, { pingKeepAlive, relayKeepAlive }, this.relay);
-        log$5("Waku node created", peerId, `relay: ${!!this.relay}, store: ${!!this.store}, light push: ${!!this
+        log$4("Waku node created", peerId, `relay: ${!!this.relay}, store: ${!!this.store}, light push: ${!!this
             .lightPush}, filter: ${!!this.filter}`);
     }
     /**
@@ -3243,7 +3466,7 @@ class WakuNode {
                 this.relay.gossipSub.multicodecs.forEach((codec) => codecs.push(codec));
             }
             else {
-                log$5("Relay codec not included in dial codec: protocol not mounted locally");
+                log$4("Relay codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.Store)) {
@@ -3251,7 +3474,7 @@ class WakuNode {
                 codecs.push(this.store.multicodec);
             }
             else {
-                log$5("Store codec not included in dial codec: protocol not mounted locally");
+                log$4("Store codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.LightPush)) {
@@ -3259,7 +3482,7 @@ class WakuNode {
                 codecs.push(this.lightPush.multicodec);
             }
             else {
-                log$5("Light Push codec not included in dial codec: protocol not mounted locally");
+                log$4("Light Push codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.Filter)) {
@@ -3267,10 +3490,10 @@ class WakuNode {
                 codecs.push(this.filter.multicodec);
             }
             else {
-                log$5("Filter codec not included in dial codec: protocol not mounted locally");
+                log$4("Filter codec not included in dial codec: protocol not mounted locally");
             }
         }
-        log$5(`Dialing to ${peerId.toString()} with protocols ${_protocols}`);
+        log$4(`Dialing to ${peerId.toString()} with protocols ${_protocols}`);
         return this.libp2p.dialProtocol(peerId, codecs);
     }
     async start() {
@@ -3315,7 +3538,7 @@ var waku = /*#__PURE__*/Object.freeze({
  */
 const DefaultPubSubTopic = "/waku/2/default-waku/proto";
 
-var index$4 = /*#__PURE__*/Object.freeze({
+var index$3 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     version_0: version_0
 });
@@ -3397,11 +3620,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 +4381,7 @@ const unsigned = {
     }
 };
 
-function isAsyncIterable(thing) {
+function isAsyncIterable$2(thing) {
     return thing[Symbol.asyncIterator] != null;
 }
 
@@ -4191,7 +4414,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 +4570,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 +4885,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,19 +4955,59 @@ function pipe(first, ...rest) {
     }
     return rawPipe(...fns);
 }
-
-const EmptyMessage = {
-    payload: new Uint8Array(),
-    contentTopic: "",
-    version: undefined,
-    timestamp: undefined,
-    meta: undefined,
-    rateLimitProof: undefined,
-    ephemeral: undefined,
+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;
+    };
 };
-function toProtoMessage(wire) {
-    return { ...EmptyMessage, ...wire };
-}
 
 // Unique ID creation requires a high quality random # generator. In the browser we therefore
 // require the crypto API and do not support built-in fallback to lower quality random number
@@ -4832,198 +5074,6 @@ function v4(options, buf, offset) {
   return unsafeStringify(rnds);
 }
 
-/**
- * FilterRPC represents a message conforming to the Waku Filter protocol
- */
-class FilterRpc {
-    proto;
-    constructor(proto) {
-        this.proto = proto;
-    }
-    static createRequest(topic, contentFilters, requestId, subscribe = true) {
-        return new FilterRpc({
-            requestId: requestId || v4(),
-            request: {
-                subscribe,
-                topic,
-                contentFilters,
-            },
-            push: undefined,
-        });
-    }
-    /**
-     *
-     * @param bytes Uint8Array of bytes from a FilterRPC message
-     * @returns FilterRpc
-     */
-    static decode(bytes) {
-        const res = FilterRpc$1.decode(bytes);
-        return new FilterRpc(res);
-    }
-    /**
-     * Encode the current FilterRPC request to bytes
-     * @returns Uint8Array
-     */
-    encode() {
-        return FilterRpc$1.encode(this.proto);
-    }
-    get push() {
-        return this.proto.push;
-    }
-    get requestId() {
-        return this.proto.requestId;
-    }
-}
-
-const FilterCodec = "/vac/waku/filter/2.0.0-beta1";
-const log$4 = debug("waku:filter");
-/**
- * Implements client side of the [Waku v2 Filter protocol](https://rfc.vac.dev/spec/12/).
- *
- * Note this currently only works in NodeJS when the Waku node is listening on a port, see:
- * - https://github.com/status-im/go-waku/issues/245
- * - https://github.com/status-im/nwaku/issues/948
- */
-class Filter extends BaseProtocol {
-    libp2p;
-    options;
-    subscriptions;
-    constructor(libp2p, options) {
-        super(FilterCodec, libp2p.peerStore, libp2p.getConnections.bind(libp2p));
-        this.libp2p = libp2p;
-        this.options = options ?? {};
-        this.subscriptions = new Map();
-        this.libp2p
-            .handle(this.multicodec, this.onRequest.bind(this))
-            .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.
-     * @param callback A function that will be called on each message returned by the filter.
-     * @param opts The FilterSubscriptionOpts used to narrow which messages are returned, and which peer to connect to.
-     * @returns Unsubscribe function that can be used to end the subscription.
-     */
-    async subscribe(decoders, callback, opts) {
-        const decodersArray = Array.isArray(decoders) ? decoders : [decoders];
-        const { pubSubTopic = DefaultPubSubTopic } = this.options;
-        const contentTopics = Array.from(groupByContentTopic(decodersArray).keys());
-        const contentFilters = contentTopics.map((contentTopic) => ({
-            contentTopic,
-        }));
-        const request = FilterRpc.createRequest(pubSubTopic, contentFilters, undefined, true);
-        const requestId = request.requestId;
-        const peer = await this.getPeer(opts?.peerId);
-        const stream = await this.newStream(peer);
-        try {
-            const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
-            log$4("response", res);
-        }
-        catch (e) {
-            log$4("Error subscribing to peer ", peer.id.toString(), "for content topics", contentTopics, ": ", e);
-            throw e;
-        }
-        const subscription = {
-            callback,
-            decoders: decodersArray,
-            pubSubTopic,
-        };
-        this.subscriptions.set(requestId, subscription);
-        return async () => {
-            await this.unsubscribe(pubSubTopic, contentFilters, requestId, peer);
-            this.subscriptions.delete(requestId);
-        };
-    }
-    toSubscriptionIterator(decoders, opts) {
-        return toAsyncIterator(this, decoders, opts);
-    }
-    getActiveSubscriptions() {
-        const map = new Map();
-        const subscriptions = this.subscriptions;
-        for (const item of subscriptions.values()) {
-            const values = map.get(item.pubSubTopic) || [];
-            const nextValues = item.decoders.map((decoder) => decoder.contentTopic);
-            map.set(item.pubSubTopic, [...values, ...nextValues]);
-        }
-        return map;
-    }
-    onRequest(streamData) {
-        log$4("Receiving message push");
-        try {
-            pipe(streamData.stream, decode, async (source) => {
-                for await (const bytes of source) {
-                    const res = FilterRpc.decode(bytes.slice());
-                    if (res.requestId && res.push?.messages?.length) {
-                        await this.pushMessages(res.requestId, res.push.messages);
-                    }
-                }
-            }).then(() => {
-                log$4("Receiving pipe closed.");
-            }, (e) => {
-                log$4("Error with receiving pipe", e);
-            });
-        }
-        catch (e) {
-            log$4("Error decoding message", e);
-        }
-    }
-    async pushMessages(requestId, messages) {
-        const subscription = this.subscriptions.get(requestId);
-        if (!subscription) {
-            log$4(`No subscription locally registered for request ID ${requestId}`);
-            return;
-        }
-        const { decoders, callback, pubSubTopic } = subscription;
-        if (!decoders || !decoders.length) {
-            log$4(`No decoder registered for request ID ${requestId}`);
-            return;
-        }
-        for (const protoMessage of messages) {
-            const contentTopic = protoMessage.contentTopic;
-            if (!contentTopic) {
-                log$4("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, toProtoMessage(protoMessage));
-                if (!decoded) {
-                    log$4("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);
-            });
-        }
-    }
-    async unsubscribe(topic, contentFilters, requestId, peer) {
-        const unsubscribeRequest = FilterRpc.createRequest(topic, contentFilters, requestId, false);
-        const stream = await this.newStream(peer);
-        try {
-            await pipe([unsubscribeRequest.encode()], encode, stream.sink);
-        }
-        catch (e) {
-            log$4("Error unsubscribing", e);
-            throw e;
-        }
-    }
-}
-function wakuFilter(init = {}) {
-    return (libp2p) => new Filter(libp2p, init);
-}
-
-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/
@@ -5132,7 +5182,7 @@ class FilterSubscribeResponse {
 }
 
 const log$3 = debug("waku:filter:v2");
-const FilterV2Codecs = {
+const FilterCodecs = {
     SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
     PUSH: "/vac/waku/filter-push/2.0.0-beta1",
 };
@@ -5239,8 +5289,7 @@ class Subscription {
         await pushMessage(subscriptionCallback, this.pubSubTopic, message);
     }
 }
-class FilterV2 extends BaseProtocol {
-    libp2p;
+class Filter extends BaseProtocol {
     options;
     activeSubscriptions = new Map();
     getActiveSubscription(pubSubTopic, peerIdStr) {
@@ -5251,12 +5300,9 @@ class FilterV2 extends BaseProtocol {
         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);
+        super(FilterCodecs.SUBSCRIBE, libp2p.components);
+        libp2p.handle(FilterCodecs.PUSH, this.onRequest.bind(this)).catch((e) => {
+            log$3("Failed to register ", FilterCodecs.PUSH, e);
         });
         this.activeSubscriptions = new Map();
         this.options = options ?? {};
@@ -5288,7 +5334,7 @@ class FilterV2 extends BaseProtocol {
      */
     async subscribe(decoders, callback, opts) {
         const subscription = await this.createSubscription(undefined, opts?.peerId);
-        subscription.subscribe(decoders, callback);
+        await subscription.subscribe(decoders, callback);
         const contentTopics = Array.from(groupByContentTopic(Array.isArray(decoders) ? decoders : [decoders]).keys());
         return async () => {
             await subscription.unsubscribe(contentTopics);
@@ -5328,8 +5374,8 @@ class FilterV2 extends BaseProtocol {
         }
     }
 }
-function wakuFilterV2(init = {}) {
-    return (libp2p) => new FilterV2(libp2p, init);
+function wakuFilter(init = {}) {
+    return (libp2p) => new Filter(libp2p, init);
 }
 async function pushMessage(subscriptionCallback, pubSubTopic, message) {
     const { decoders, callback } = subscriptionCallback;
@@ -5342,25 +5388,24 @@ async function pushMessage(subscriptionCallback, pubSubTopic, message) {
     // 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) => {
+    for (const dec of decoders) {
         if (didDecodeMsg)
-            return;
+            break;
         const decoded = await dec.fromProtoObj(pubSubTopic, message);
-        // const decoded = await dec.fromProtoObj(pubSubTopic, message);
         if (!decoded) {
             log$3("Not able to decode message");
-            return;
+            continue;
         }
         // 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
+    wakuFilter: wakuFilter
 });
 
 class PushRpc {
@@ -5399,11 +5444,9 @@ const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
  */
 class LightPush extends BaseProtocol {
-    libp2p;
     options;
     constructor(libp2p, options) {
-        super(LightPushCodec, libp2p.peerStore, libp2p.getConnections.bind(libp2p));
-        this.libp2p = libp2p;
+        super(LightPushCodec, libp2p.components);
         this.options = options || {};
     }
     async send(encoder, message, opts) {
@@ -5804,6 +5847,19 @@ function concat(byteArrays, totalLength) {
     return res;
 }
 
+const EmptyMessage = {
+    payload: new Uint8Array(),
+    contentTopic: "",
+    version: undefined,
+    timestamp: undefined,
+    meta: undefined,
+    rateLimitProof: undefined,
+    ephemeral: undefined,
+};
+function toProtoMessage(wire) {
+    return { ...EmptyMessage, ...wire };
+}
+
 const OneMillion = BigInt(1000000);
 var PageDirection;
 (function (PageDirection) {
@@ -5884,11 +5940,9 @@ const DefaultPageSize = 10;
  * The Waku Store protocol can be used to retrieved historical messages.
  */
 class Store extends BaseProtocol {
-    libp2p;
     options;
     constructor(libp2p, options) {
-        super(StoreCodec, libp2p.peerStore, libp2p.getConnections.bind(libp2p));
-        this.libp2p = libp2p;
+        super(StoreCodec, libp2p.components);
         this.options = options ?? {};
     }
     /**
@@ -6313,7 +6367,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
@@ -6372,13 +6426,13 @@ async function waitForConnectedPeer(protocol) {
     }
     await new Promise((resolve) => {
         const cb = (evt) => {
-            if (evt.detail.protocols.includes(codec)) {
+            if (evt.detail?.protocols?.includes(codec)) {
                 log("Resolving for", codec, evt.detail.protocols);
-                protocol.peerStore.removeEventListener("change:protocols", cb);
+                protocol.removeLibp2pEventListener("peer:identify", cb);
                 resolve();
             }
         };
-        protocol.peerStore.addEventListener("change:protocols", cb);
+        protocol.addLibp2pEventListener("peer:identify", cb);
     });
 }
 /**
@@ -6413,4 +6467,4 @@ function getEnabledProtocols(waku) {
     return protocols;
 }
 
-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 };
+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 };