@waku/core 0.0.20 → 0.0.22

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,15 +3117,15 @@ 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;
 const DEFAULT_MAX_PARALLEL_DIALS = 3;
-class ConnectionManager {
+class ConnectionManager extends EventEmitter {
     static instances = new Map();
     keepAliveManager;
     options;
-    libp2pComponents;
+    libp2p;
     dialAttemptsForPeer = new Map();
     dialErrorsForPeer = new Map();
     currentActiveDialCount = 0;
@@ -3059,8 +3138,48 @@ 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,
@@ -3069,20 +3188,18 @@ class ConnectionManager {
         };
         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();
+        this.dialPeerStorePeers().catch((error) => log$5(`Unexpected error while dialing peer store peers`, error));
     }
     async dialPeerStorePeers() {
-        const peerInfos = await this.libp2pComponents.peerStore.all();
+        const peerInfos = await this.libp2p.peerStore.all();
         const dialPromises = [];
         for (const peerInfo of peerInfos) {
-            if (this.libp2pComponents
-                .getConnections()
-                .find((c) => c.remotePeer === peerInfo.id))
+            if (this.libp2p.getConnections().find((c) => c.remotePeer === peerInfo.id))
                 continue;
             dialPromises.push(this.attemptDial(peerInfo.id));
         }
@@ -3090,7 +3207,7 @@ class ConnectionManager {
             await Promise.all(dialPromises);
         }
         catch (error) {
-            log$6(`Unexpected error while dialing peer store peers`, error);
+            log$5(`Unexpected error while dialing peer store peers`, error);
         }
     }
     async run() {
@@ -3101,76 +3218,90 @@ 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) {
+        while (dialAttempt < this.options.maxDialAttemptsForPeer) {
             try {
-                log$6(`Dialing peer ${peerId.toString()}`);
-                await this.libp2pComponents.dial(peerId);
+                log$5(`Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`);
+                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
-                    .getConnections(peerId)
-                    .forEach((conn) => (conn.tags = Array.from(new Set([...conn.tags, ...tags]))));
+                this.libp2p.getConnections(peerId).forEach((conn) => {
+                    conn.tags = Array.from(new Set([...conn.tags, ...tags]));
+                });
                 this.dialAttemptsForPeer.delete(peerId.toString());
-                return;
+                // Dialing succeeded, break the loop
+                break;
             }
-            catch (e) {
-                const error = e;
-                this.dialErrorsForPeer.set(peerId.toString(), error);
-                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$6(`Reattempting dial (${dialAttempt})`);
+            catch (error) {
+                if (error instanceof AggregateError) {
+                    // Handle AggregateError
+                    log$5(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
                 }
+                else {
+                    // Handle generic error
+                    log$5(`Error dialing peer ${peerId.toString()} - ${error.message}`);
+                }
+                this.dialErrorsForPeer.set(peerId.toString(), error);
+                dialAttempt++;
+                this.dialAttemptsForPeer.set(peerId.toString(), dialAttempt);
             }
         }
-        try {
-            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);
-        }
-        catch (error) {
-            throw `Error deleting undialable peer ${peerId.toString()} from peer store - ${error}`;
-        }
-        finally {
-            this.currentActiveDialCount -= 1;
-            this.processDialQueue();
+        // Always decrease the active dial count and process the dial queue
+        this.currentActiveDialCount--;
+        this.processDialQueue();
+        // If max dial attempts reached and dialing failed, delete the peer
+        if (dialAttempt === this.options.maxDialAttemptsForPeer) {
+            try {
+                const error = this.dialErrorsForPeer.get(peerId.toString());
+                let errorMessage;
+                if (error instanceof AggregateError) {
+                    errorMessage = JSON.stringify(error.errors[0]);
+                }
+                else {
+                    errorMessage = error.message;
+                }
+                log$5(`Deleting undialable peer ${peerId.toString()} from peer store. Error: ${errorMessage}`);
+                this.dialErrorsForPeer.delete(peerId.toString());
+                await this.libp2p.peerStore.delete(peerId);
+            }
+            catch (error) {
+                throw new Error(`Error deleting undialable peer ${peerId.toString()} from peer store - ${error}`);
+            }
         }
     }
     async dropConnection(peerId) {
         try {
-            await this.libp2pComponents.hangUp(peerId);
-            log$6(`Dropped connection with peer ${peerId.toString()}`);
+            this.keepAliveManager.stop(peerId);
+            await this.libp2p.hangUp(peerId);
+            log$5(`Dropped connection with peer ${peerId.toString()}`);
         }
         catch (error) {
-            log$6(`Error dropping connection with peer ${peerId.toString()} - ${error}`);
+            log$5(`Error dropping connection with peer ${peerId.toString()} - ${error}`);
         }
     }
-    async processDialQueue() {
+    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);
+                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
@@ -3185,7 +3316,7 @@ 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) {
@@ -3199,27 +3330,52 @@ class ConnectionManager {
         });
     }
     onEventHandlers = {
-        "peer:discovery": async (evt) => {
-            const { id: peerId } = evt.detail;
-            this.attemptDial(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);
+                this.dispatchEvent(new CustomEvent(isBootstrap
+                    ? EPeersByDiscoveryEvents.PEER_DISCOVERY_BOOTSTRAP
+                    : EPeersByDiscoveryEvents.PEER_DISCOVERY_PEER_EXCHANGE, {
+                    detail: peerId,
+                }));
+                try {
+                    await this.attemptDial(peerId);
+                }
+                catch (error) {
+                    log$5(`Error dialing peer ${peerId.toString()} : ${error}`);
+                }
+            })();
         },
-        "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:connect": (evt) => {
+            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);
             };
         },
     };
@@ -3229,15 +3385,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;
@@ -3251,15 +3408,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;
@@ -3287,7 +3450,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}`);
     }
     /**
@@ -3311,7 +3474,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)) {
@@ -3319,7 +3482,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)) {
@@ -3327,7 +3490,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)) {
@@ -3335,10 +3498,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() {
@@ -3383,7 +3546,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
 });
@@ -4854,19 +5017,6 @@ const duplexPipelineFn = (duplex) => {
     };
 };
 
-const EmptyMessage = {
-    payload: new Uint8Array(),
-    contentTopic: "",
-    version: undefined,
-    timestamp: undefined,
-    meta: undefined,
-    rateLimitProof: undefined,
-    ephemeral: undefined,
-};
-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
 // generators (like Math.random()).
@@ -4932,198 +5082,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/
@@ -5232,7 +5190,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",
 };
@@ -5339,8 +5297,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) {
@@ -5351,12 +5308,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 ?? {};
@@ -5388,7 +5342,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);
@@ -5428,8 +5382,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;
@@ -5438,29 +5392,21 @@ async function pushMessage(subscriptionCallback, pubSubTopic, message) {
         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);
-    });
+    try {
+        const decodePromises = decoders.map((dec) => dec
+            .fromProtoObj(pubSubTopic, message)
+            .then((decoded) => decoded || Promise.reject("Decoding failed")));
+        const decodedMessage = await Promise.any(decodePromises);
+        await callback(decodedMessage);
+    }
+    catch (e) {
+        log$3("Error decoding message", e);
+    }
 }
 
 var index$2 = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    wakuFilterV2: wakuFilterV2
+    wakuFilter: wakuFilter
 });
 
 class PushRpc {
@@ -5499,11 +5445,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) {
@@ -5904,6 +5848,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) {
@@ -5984,11 +5941,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 ?? {};
     }
     /**
@@ -6472,13 +6427,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);
     });
 }
 /**
@@ -6513,4 +6468,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 };