@waku/core 0.0.27 → 0.0.28-17a8640.0

package/bundle/index.js

@@ -1,13 +1,9 @@
-import { v as version_0, e as encodingLength, a as encode$1, d as decode$1, M as MessagePush, F as FilterSubscribeRequest, b as FilterSubscribeResponse$1, P as PushRpc$1, c as PushResponse, H as HistoryRpc$1, f as PagingInfo, g as HistoryResponse, h as createEncoder, W as WakuMetadataResponse, i as WakuMetadataRequest } from './version_0-FXfzO8Km.js';
-export { j as createDecoder } from './version_0-FXfzO8Km.js';
-import { g as getDefaultExportFromCjs, S as SendError, P as Protocols, E as EConnectionStateEvents, T as Tags, a as EPeersByDiscoveryEvents } from './browser-BQyFvtq6.js';
-import { b as bytesToUtf8, u as utf8ToBytes, c as concat$1, s as sha256, a as asUint8Array, d as allocUnsafe, e as alloc, L as Logger, f as singleShardInfoToPubsubTopic, g as ensurePubsubTopicIsConfigured, D as DefaultPubsubTopic, p as pubsubTopicToSingleShardInfo, h as shardInfoToPubsubTopics } from './index-8YyfzF9R.js';
-import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-LhsIWF3-.js';
-export { S as StreamManager } from './base_protocol-LhsIWF3-.js';
-
-function isDefined(value) {
-    return Boolean(value);
-}
+import { v as version_0, e as encodingLength, a as encode$1, d as decode$1, M as MessagePush, F as FilterSubscribeRequest, b as FilterSubscribeResponse$1, P as PushRpc$1, c as PushResponse, H as HistoryRpc$1, f as PagingInfo, g as HistoryResponse, h as createEncoder, W as WakuMetadataResponse, i as WakuMetadataRequest } from './version_0-C6o0DvNW.js';
+export { j as createDecoder } from './version_0-C6o0DvNW.js';
+import { g as getDefaultExportFromCjs, P as ProtocolError, a as Protocols, E as EConnectionStateEvents, T as Tags, b as EPeersByDiscoveryEvents } from './browser-DoQRY-an.js';
+import { b as bytesToUtf8, u as utf8ToBytes, c as concat$1, s as sha256, a as allocUnsafe, d as alloc, L as Logger, e as singleShardInfoToPubsubTopic, f as ensurePubsubTopicIsConfigured, D as DefaultPubsubTopic, p as pubsubTopicToSingleShardInfo, g as shardInfoToPubsubTopics } from './index-BJwgMx4y.js';
+import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-D0Zdzb-v.js';
+export { S as StreamManager } from './base_protocol-D0Zdzb-v.js';
 
 function groupByContentTopic(values) {
     const groupedDecoders = new Map();
@@ -174,13 +170,18 @@ function all(source) {
     return arr;
 }
 
+/**
+ * To guarantee Uint8Array semantics, convert nodejs Buffers
+ * into vanilla Uint8Arrays
+ */
+function asUint8Array(buf) {
+    return buf;
+}
+
 /**
  * Returns a new Uint8Array created by concatenating the passed Uint8Arrays
  */
 function concat(arrays, length) {
-    if (globalThis.Buffer != null) {
-        return asUint8Array(globalThis.Buffer.concat(arrays, length));
-    }
     if (length == null) {
         length = arrays.reduce((acc, curr) => acc + curr.length, 0);
     }
@@ -1358,6 +1359,47 @@ function _pushable(getNext, options) {
     return pushable;
 }
 
+/**
+ * @packageDocumentation
+ *
+ * Merge several (async)iterables into one, yield values as they arrive.
+ *
+ * Nb. sources are iterated over in parallel so the order of emitted items is not guaranteed.
+ *
+ * @example
+ *
+ * ```javascript
+ * import merge from 'it-merge'
+ * import all from 'it-all'
+ *
+ * // This can also be an iterator, generator, etc
+ * const values1 = [0, 1, 2, 3, 4]
+ * const values2 = [5, 6, 7, 8, 9]
+ *
+ * const arr = all(merge(values1, values2))
+ *
+ * console.info(arr) // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
+ * ```
+ *
+ * Async sources must be awaited:
+ *
+ * ```javascript
+ * import merge from 'it-merge'
+ * import all from 'it-all'
+ *
+ * // This can also be an iterator, async iterator, generator, etc
+ * const values1 = async function * () {
+ *   yield * [0, 1, 2, 3, 4]
+ * }
+ * const values2 = async function * () {
+ *   yield * [5, 6, 7, 8, 9]
+ * }
+ *
+ * const arr = await all(merge(values1(), values2()))
+ *
+ * console.info(arr) // 0, 1, 5, 6, 2, 3, 4, 7, 8, 9  <- nb. order is not guaranteed
+ * ```
+ */
 function isAsyncIterable$1(thing) {
     return thing[Symbol.asyncIterator] != null;
 }
@@ -1827,6 +1869,7 @@ class Subscription {
         }
     }
 }
+const DEFAULT_NUM_PEERS = 3;
 class Filter extends BaseProtocol {
     activeSubscriptions = new Map();
     getActiveSubscription(pubsubTopic) {
@@ -1836,8 +1879,11 @@ class Filter extends BaseProtocol {
         this.activeSubscriptions.set(pubsubTopic, subscription);
         return subscription;
     }
+    //TODO: Remove when FilterCore and FilterSDK are introduced
+    numPeersToUse;
     constructor(libp2p, options) {
         super(FilterCodecs.SUBSCRIBE, libp2p.components, log$6, options.pubsubTopics, options);
+        this.numPeersToUse = options?.numPeersToUse ?? DEFAULT_NUM_PEERS;
         libp2p.handle(FilterCodecs.PUSH, this.onRequest.bind(this)).catch((e) => {
             log$6.error("Failed to register ", FilterCodecs.PUSH, e);
         });
@@ -1990,122 +2036,125 @@ 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 {
+class LightPushCore extends BaseProtocol {
     constructor(libp2p, options) {
         super(LightPushCodec, libp2p.components, log$5, options.pubsubTopics, options);
     }
-    async preparePushMessage(encoder, message, pubsubTopic) {
+    async preparePushMessage(encoder, message) {
         try {
             if (!message.payload || message.payload.length === 0) {
                 log$5.error("Failed to send waku light push: payload is empty");
-                return { query: null, error: SendError.EMPTY_PAYLOAD };
+                return { query: null, error: ProtocolError.EMPTY_PAYLOAD };
             }
             if (!(await isMessageSizeUnderCap(encoder, message))) {
                 log$5.error("Failed to send waku light push: message is bigger than 1MB");
-                return { query: null, error: SendError.SIZE_TOO_BIG };
+                return { query: null, error: ProtocolError.SIZE_TOO_BIG };
             }
             const protoMessage = await encoder.toProtoObj(message);
             if (!protoMessage) {
                 log$5.error("Failed to encode to protoMessage, aborting push");
                 return {
                     query: null,
-                    error: SendError.ENCODE_FAILED
+                    error: ProtocolError.ENCODE_FAILED
                 };
             }
-            const query = PushRpc.createRequest(protoMessage, pubsubTopic);
+            const query = PushRpc.createRequest(protoMessage, encoder.pubsubTopic);
             return { query, error: null };
         }
         catch (error) {
             log$5.error("Failed to prepare push message", error);
             return {
                 query: null,
-                error: SendError.GENERIC_FAIL
+                error: ProtocolError.GENERIC_FAIL
             };
         }
     }
-    async send(encoder, message) {
-        const { pubsubTopic } = encoder;
-        ensurePubsubTopicIsConfigured(pubsubTopic, this.pubsubTopics);
-        const recipients = [];
-        const { query, error: preparationError } = await this.preparePushMessage(encoder, message, pubsubTopic);
+    async send(encoder, message, peer) {
+        const { query, error: preparationError } = await this.preparePushMessage(encoder, message);
         if (preparationError || !query) {
             return {
-                recipients,
-                errors: [preparationError]
+                success: null,
+                failure: {
+                    error: preparationError,
+                    peerId: peer.id
+                }
             };
         }
-        const peers = await this.getPeers({
-            maxBootstrapPeers: 1,
-            numPeers: this.numPeersToUse
-        });
-        if (!peers.length) {
+        let stream;
+        try {
+            stream = await this.getStream(peer);
+        }
+        catch (err) {
+            log$5.error(`Failed to get a stream for remote peer${peer.id.toString()}`, err);
             return {
-                recipients,
-                errors: [SendError.NO_PEER_AVAILABLE]
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    peerId: peer.id
+                }
             };
         }
-        const promises = peers.map(async (peer) => {
-            let stream;
-            try {
-                stream = await this.getStream(peer);
-            }
-            catch (err) {
-                log$5.error(`Failed to get a stream for remote peer${peer.id.toString()}`, err);
-                return { recipients, error: SendError.REMOTE_PEER_FAULT };
-            }
-            let res;
-            try {
-                res = await pipe([query.encode()], encode, stream, decode, async (source) => await all(source));
-            }
-            catch (err) {
-                log$5.error("Failed to send waku light push request", err);
-                return { recipients, error: SendError.GENERIC_FAIL };
-            }
-            const bytes = new Uint8ArrayList();
-            res.forEach((chunk) => {
-                bytes.append(chunk);
-            });
-            let response;
-            try {
-                response = PushRpc.decode(bytes).response;
-            }
-            catch (err) {
-                log$5.error("Failed to decode push reply", err);
-                return { recipients, error: SendError.DECODE_FAILED };
-            }
-            if (!response) {
-                log$5.error("Remote peer fault: No response in PushRPC");
-                return { recipients, error: SendError.REMOTE_PEER_FAULT };
-            }
-            if (!response.isSuccess) {
-                log$5.error("Remote peer rejected the message: ", response.info);
-                return { recipients, error: SendError.REMOTE_PEER_REJECTED };
-            }
-            recipients.some((recipient) => recipient.equals(peer.id)) ||
-                recipients.push(peer.id);
-            return { recipients };
+        let res;
+        try {
+            res = await pipe([query.encode()], encode, stream, decode, async (source) => await all(source));
+        }
+        catch (err) {
+            log$5.error("Failed to send waku light push request", err);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.GENERIC_FAIL,
+                    peerId: peer.id
+                }
+            };
+        }
+        const bytes = new Uint8ArrayList();
+        res.forEach((chunk) => {
+            bytes.append(chunk);
         });
-        const results = await Promise.allSettled(promises);
-        // TODO: handle renewing faulty peers with new peers (https://github.com/waku-org/js-waku/issues/1463)
-        const errors = results
-            .filter((result) => result.status === "fulfilled")
-            .map((result) => result.value.error)
-            .filter((error) => error !== undefined);
-        return {
-            recipients,
-            errors
-        };
+        let response;
+        try {
+            response = PushRpc.decode(bytes).response;
+        }
+        catch (err) {
+            log$5.error("Failed to decode push reply", err);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.DECODE_FAILED,
+                    peerId: peer.id
+                }
+            };
+        }
+        if (!response) {
+            log$5.error("Remote peer fault: No response in PushRPC");
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    peerId: peer.id
+                }
+            };
+        }
+        if (!response.isSuccess) {
+            log$5.error("Remote peer rejected the message: ", response.info);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    peerId: peer.id
+                }
+            };
+        }
+        return { success: peer.id, failure: null };
     }
 }
-function wakuLightPush(init = {}) {
-    return (libp2p) => new LightPush(libp2p, init);
-}
 
 var index$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     LightPushCodec: LightPushCodec,
-    get PushResponse () { return PushResponse; },
-    wakuLightPush: wakuLightPush
+    LightPushCore: LightPushCore,
+    get PushResponse () { return PushResponse; }
 });
 
 const EmptyMessage = {
@@ -2121,7 +2170,7 @@ function toProtoMessage(wire) {
     return { ...EmptyMessage, ...wire };
 }
 
-const OneMillion = BigInt(1000000);
+const OneMillion = BigInt(1_000_000);
 var PageDirection;
 (function (PageDirection) {
     PageDirection["BACKWARD"] = "backward";
@@ -2194,261 +2243,80 @@ function directionToProto(pageDirection) {
 var HistoryError = HistoryResponse.HistoryError;
 const log$4 = new Logger("store");
 const StoreCodec = "/vac/waku/store/2.0.0-beta4";
-const DefaultPageSize = 10;
 /**
  * Implements the [Waku v2 Store protocol](https://rfc.vac.dev/spec/13/).
  *
  * The Waku Store protocol can be used to retrieved historical messages.
  */
-class Store extends BaseProtocol {
-    NUM_PEERS_PROTOCOL = 1;
+class StoreCore extends BaseProtocol {
     constructor(libp2p, options) {
         super(StoreCodec, libp2p.components, log$4, options.pubsubTopics, options);
     }
-    /**
-     * Processes messages based on the provided callback and options.
-     * @private
-     */
-    async processMessages(messages, callback, options) {
-        let abort = false;
-        const messagesOrUndef = await Promise.all(messages);
-        let processedMessages = messagesOrUndef.filter(isDefined);
-        if (this.shouldReverseOrder(options)) {
-            processedMessages = processedMessages.reverse();
+    async *queryPerPage(queryOpts, decoders, peer) {
+        if (queryOpts.contentTopics.toString() !==
+            Array.from(decoders.keys()).toString()) {
+            throw new Error("Internal error, the decoders should match the query's content topics");
         }
-        await Promise.all(processedMessages.map(async (msg) => {
-            if (msg && !abort) {
-                abort = Boolean(await callback(msg));
+        let currentCursor = queryOpts.cursor;
+        while (true) {
+            queryOpts.cursor = currentCursor;
+            const historyRpcQuery = HistoryRpc.createQuery(queryOpts);
+            const stream = await this.getStream(peer);
+            const res = await pipe([historyRpcQuery.encode()], encode, stream, decode, async (source) => await all(source));
+            const bytes = new Uint8ArrayList();
+            res.forEach((chunk) => {
+                bytes.append(chunk);
+            });
+            const reply = historyRpcQuery.decode(bytes);
+            if (!reply.response) {
+                log$4.warn("Stopping pagination due to store `response` field missing");
+                break;
             }
-        }));
-        return abort;
-    }
-    /**
-     * Determines whether to reverse the order of messages based on the provided options.
-     *
-     * Messages in pages are ordered from oldest (first) to most recent (last).
-     * https://github.com/vacp2p/rfc/issues/533
-     *
-     * @private
-     */
-    shouldReverseOrder(options) {
-        return (typeof options?.pageDirection === "undefined" ||
-            options?.pageDirection === PageDirection.BACKWARD);
-    }
-    /**
-     * @deprecated Use `queryWithOrderedCallback` instead
-     **/
-    queryOrderedCallback = this.queryWithOrderedCallback;
-    /**
-     * Do a query to a Waku Store to retrieve historical/missed messages.
-     *
-     * The callback function takes a `WakuMessage` in input,
-     * messages are processed in order:
-     * - oldest to latest if `options.pageDirection` == { @link PageDirection.FORWARD }
-     * - latest to oldest if `options.pageDirection` == { @link PageDirection.BACKWARD }
-     *
-     * The ordering may affect performance.
-     * The ordering depends on the behavior of the remote store node.
-     * If strong ordering is needed, you may need to handle this at application level
-     * and set your own timestamps too (the WakuMessage timestamps are not certified).
-     *
-     * @throws If not able to reach a Waku Store peer to query,
-     * or if an error is encountered when processing the reply,
-     * or if two decoders with the same content topic are passed.
-     */
-    async queryWithOrderedCallback(decoders, callback, options) {
-        for await (const promises of this.queryGenerator(decoders, options)) {
-            if (await this.processMessages(promises, callback, options))
+            const response = reply.response;
+            if (response.error && response.error !== HistoryError.NONE) {
+                throw "History response contains an Error: " + response.error;
+            }
+            if (!response.messages || !response.messages.length) {
+                log$4.warn("Stopping pagination due to store `response.messages` field missing or empty");
                 break;
-        }
-    }
-    /**
-     * Do a query to a Waku Store to retrieve historical/missed messages.
-     * The callback function takes a `Promise<WakuMessage>` in input,
-     * useful if messages need to be decrypted and performance matters.
-     *
-     * The order of the messages passed to the callback is as follows:
-     * - within a page, messages are expected to be ordered from oldest to most recent
-     * - pages direction depends on { @link QueryOptions.pageDirection }
-     *
-     * Do note that the resolution of the `Promise<WakuMessage | undefined` may
-     * break the order as it may rely on the browser decryption API, which in turn,
-     * may have a different speed depending on the type of decryption.
-     *
-     * @throws If not able to reach a Waku Store peer to query,
-     * or if an error is encountered when processing the reply,
-     * or if two decoders with the same content topic are passed.
-     */
-    async queryWithPromiseCallback(decoders, callback, options) {
-        let abort = false;
-        for await (const page of this.queryGenerator(decoders, options)) {
-            const _promises = page.map(async (msgPromise) => {
-                if (abort)
-                    return;
-                abort = Boolean(await callback(msgPromise));
+            }
+            log$4.error(`${response.messages.length} messages retrieved from store`);
+            yield response.messages.map((protoMsg) => {
+                const contentTopic = protoMsg.contentTopic;
+                if (typeof contentTopic !== "undefined") {
+                    const decoder = decoders.get(contentTopic);
+                    if (decoder) {
+                        return decoder.fromProtoObj(queryOpts.pubsubTopic, toProtoMessage(protoMsg));
+                    }
+                }
+                return Promise.resolve(undefined);
             });
-            await Promise.all(_promises);
-            if (abort)
+            const nextCursor = response.pagingInfo?.cursor;
+            if (typeof nextCursor === "undefined") {
+                // If the server does not return cursor then there is an issue,
+                // Need to abort, or we end up in an infinite loop
+                log$4.warn("Stopping pagination due to `response.pagingInfo.cursor` missing from store response");
+                break;
+            }
+            currentCursor = nextCursor;
+            const responsePageSize = response.pagingInfo?.pageSize;
+            const queryPageSize = historyRpcQuery.query?.pagingInfo?.pageSize;
+            if (
+            // Response page size smaller than query, meaning this is the last page
+            responsePageSize &&
+                queryPageSize &&
+                responsePageSize < queryPageSize) {
                 break;
-        }
-    }
-    /**
-     * Do a query to a Waku Store to retrieve historical/missed messages.
-     *
-     * This is a generator, useful if you want most control on how messages
-     * are processed.
-     *
-     * The order of the messages returned by the remote Waku node SHOULD BE
-     * as follows:
-     * - within a page, messages SHOULD be ordered from oldest to most recent
-     * - pages direction depends on { @link QueryOptions.pageDirection }
-     * @throws If not able to reach a Waku Store peer to query,
-     * or if an error is encountered when processing the reply,
-     * or if two decoders with the same content topic are passed.
-     *
-     * This API only supports querying a single pubsub topic at a time.
-     * If multiple decoders are provided, they must all have the same pubsub topic.
-     * @throws If multiple decoders with different pubsub topics are provided.
-     * @throws If no decoders are provided.
-     * @throws If no decoders are found for the provided pubsub topic.
-     */
-    async *queryGenerator(decoders, options) {
-        if (decoders.length === 0) {
-            throw new Error("No decoders provided");
-        }
-        let startTime, endTime;
-        if (options?.timeFilter) {
-            startTime = options.timeFilter.startTime;
-            endTime = options.timeFilter.endTime;
-        }
-        // convert array to set to remove duplicates
-        const uniquePubsubTopicsInQuery = Array.from(new Set(decoders.map((decoder) => decoder.pubsubTopic)));
-        // If multiple pubsub topics are provided, throw an error
-        if (uniquePubsubTopicsInQuery.length > 1) {
-            throw new Error("API does not support querying multiple pubsub topics at once");
-        }
-        // we can be certain that there is only one pubsub topic in the query
-        const pubsubTopicForQuery = uniquePubsubTopicsInQuery[0];
-        ensurePubsubTopicIsConfigured(pubsubTopicForQuery, this.pubsubTopics);
-        // check that the pubsubTopic from the Cursor and Decoder match
-        if (options?.cursor?.pubsubTopic &&
-            options.cursor.pubsubTopic !== pubsubTopicForQuery) {
-            throw new Error(`Cursor pubsub topic (${options?.cursor?.pubsubTopic}) does not match decoder pubsub topic (${pubsubTopicForQuery})`);
-        }
-        const decodersAsMap = new Map();
-        decoders.forEach((dec) => {
-            if (decodersAsMap.has(dec.contentTopic)) {
-                throw new Error("API does not support different decoder per content topic");
-            }
-            decodersAsMap.set(dec.contentTopic, dec);
-        });
-        const contentTopics = decoders
-            .filter((decoder) => decoder.pubsubTopic === pubsubTopicForQuery)
-            .map((dec) => dec.contentTopic);
-        if (contentTopics.length === 0) {
-            throw new Error("No decoders found for topic " + pubsubTopicForQuery);
-        }
-        const queryOpts = Object.assign({
-            pubsubTopic: pubsubTopicForQuery,
-            pageDirection: PageDirection.BACKWARD,
-            pageSize: DefaultPageSize
-        }, options, { contentTopics, startTime, endTime });
-        const peer = (await this.getPeers({
-            numPeers: this.NUM_PEERS_PROTOCOL,
-            maxBootstrapPeers: 1
-        }))[0];
-        for await (const messages of paginate(this.getStream.bind(this, peer), queryOpts, decodersAsMap, options?.cursor)) {
-            yield messages;
-        }
-    }
-}
-async function* paginate(streamFactory, queryOpts, decoders, cursor) {
-    if (queryOpts.contentTopics.toString() !==
-        Array.from(decoders.keys()).toString()) {
-        throw new Error("Internal error, the decoders should match the query's content topics");
-    }
-    let currentCursor = cursor;
-    while (true) {
-        queryOpts.cursor = currentCursor;
-        const historyRpcQuery = HistoryRpc.createQuery(queryOpts);
-        log$4.info("Querying store peer", `for (${queryOpts.pubsubTopic})`, queryOpts.contentTopics);
-        const stream = await streamFactory();
-        const res = await pipe([historyRpcQuery.encode()], encode, stream, decode, async (source) => await all(source));
-        const bytes = new Uint8ArrayList();
-        res.forEach((chunk) => {
-            bytes.append(chunk);
-        });
-        const reply = historyRpcQuery.decode(bytes);
-        if (!reply.response) {
-            log$4.warn("Stopping pagination due to store `response` field missing");
-            break;
-        }
-        const response = reply.response;
-        if (response.error && response.error !== HistoryError.NONE) {
-            throw "History response contains an Error: " + response.error;
-        }
-        if (!response.messages || !response.messages.length) {
-            log$4.warn("Stopping pagination due to store `response.messages` field missing or empty");
-            break;
-        }
-        log$4.error(`${response.messages.length} messages retrieved from store`);
-        yield response.messages.map((protoMsg) => {
-            const contentTopic = protoMsg.contentTopic;
-            if (typeof contentTopic !== "undefined") {
-                const decoder = decoders.get(contentTopic);
-                if (decoder) {
-                    return decoder.fromProtoObj(queryOpts.pubsubTopic, toProtoMessage(protoMsg));
-                }
             }
-            return Promise.resolve(undefined);
-        });
-        const nextCursor = response.pagingInfo?.cursor;
-        if (typeof nextCursor === "undefined") {
-            // If the server does not return cursor then there is an issue,
-            // Need to abort, or we end up in an infinite loop
-            log$4.warn("Stopping pagination due to `response.pagingInfo.cursor` missing from store response");
-            break;
-        }
-        currentCursor = nextCursor;
-        const responsePageSize = response.pagingInfo?.pageSize;
-        const queryPageSize = historyRpcQuery.query?.pagingInfo?.pageSize;
-        if (
-        // Response page size smaller than query, meaning this is the last page
-        responsePageSize &&
-            queryPageSize &&
-            responsePageSize < queryPageSize) {
-            break;
         }
     }
 }
-async function createCursor(message) {
-    if (!message ||
-        !message.timestamp ||
-        !message.payload ||
-        !message.contentTopic) {
-        throw new Error("Message is missing required fields");
-    }
-    const contentTopicBytes = utf8ToBytes(message.contentTopic);
-    const digest = sha256(concat$1([contentTopicBytes, message.payload]));
-    const messageTime = BigInt(message.timestamp.getTime()) * BigInt(1000000);
-    return {
-        digest,
-        pubsubTopic: message.pubsubTopic,
-        senderTime: messageTime,
-        receiverTime: messageTime
-    };
-}
-function wakuStore(init = {}) {
-    return (libp2p) => new Store(libp2p, init);
-}
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    DefaultPageSize: DefaultPageSize,
     get PageDirection () { return PageDirection; },
     StoreCodec: StoreCodec,
-    createCursor: createCursor,
-    wakuStore: wakuStore
+    StoreCore: StoreCore
 });
 
 class TimeoutError extends Error {
@@ -2569,8 +2437,8 @@ function pTimeout(promise, options) {
 }
 
 const normalizeEmitter = emitter => {
-	const addListener = emitter.on || emitter.addListener || emitter.addEventListener;
-	const removeListener = emitter.off || emitter.removeListener || emitter.removeEventListener;
+	const addListener = emitter.addEventListener || emitter.on || emitter.addListener;
+	const removeListener = emitter.removeEventListener || emitter.off || emitter.removeListener;
 
 	if (!addListener || !removeListener) {
 		throw new TypeError('Emitter is not compatible');
@@ -2684,6 +2552,7 @@ function pEvent(emitter, event, options) {
 }
 
 const log$3 = new Logger("wait-for-remote-peer");
+//TODO: move this function within the Waku class: https://github.com/waku-org/js-waku/issues/1761
 /**
  * Wait for a remote peer to be ready given the passed protocols.
  * Must be used after attempting to connect to nodes, using
@@ -2716,12 +2585,12 @@ async function waitForRemotePeer(waku, protocols, timeoutMs) {
     if (protocols.includes(Protocols.Store)) {
         if (!waku.store)
             throw new Error("Cannot wait for Store peer: protocol not mounted");
-        promises.push(waitForConnectedPeer(waku.store, waku.libp2p.services.metadata));
+        promises.push(waitForConnectedPeer(waku.store.protocol, waku.libp2p.services.metadata));
     }
     if (protocols.includes(Protocols.LightPush)) {
         if (!waku.lightPush)
             throw new Error("Cannot wait for LightPush peer: protocol not mounted");
-        promises.push(waitForConnectedPeer(waku.lightPush, waku.libp2p.services.metadata));
+        promises.push(waitForConnectedPeer(waku.lightPush.protocol, waku.libp2p.services.metadata));
     }
     if (protocols.includes(Protocols.Filter)) {
         if (!waku.filter)
@@ -2735,6 +2604,7 @@ async function waitForRemotePeer(waku, protocols, timeoutMs) {
         await Promise.all(promises);
     }
 }
+//TODO: move this function within protocol SDK class: https://github.com/waku-org/js-waku/issues/1761
 /**
  * Wait for a peer with the given protocol to be connected.
  * If sharding is enabled on the node, it will also wait for the peer to be confirmed by the metadata service.
@@ -2820,12 +2690,31 @@ function getEnabledProtocols(waku) {
     return protocols;
 }
 
+/** Noop for browser compatibility */
+function setMaxListeners$1() { }
+
+// create a setMaxListeners that doesn't break browser usage
+const setMaxListeners = (n, ...eventTargets) => {
+    try {
+        setMaxListeners$1(n, ...eventTargets);
+    }
+    catch {
+        // swallow error, gulp
+    }
+};
+
 /**
  * An implementation of a typed event target
  * etc
  */
 class TypedEventEmitter extends EventTarget {
     #listeners = new Map();
+    constructor() {
+        super();
+        // silence MaxListenersExceededWarning warning on Node.js, this is a red
+        // herring almost all of the time
+        setMaxListeners(Infinity, this);
+    }
     listenerCount(type) {
         const listeners = this.#listeners.get(type);
         if (listeners == null) {
@@ -3400,7 +3289,7 @@ const MetadataCodec = "/vac/waku/metadata/1.0.0";
 class Metadata extends BaseProtocol {
     shardInfo;
     libp2pComponents;
-    handshakesConfirmed = new Set();
+    handshakesConfirmed = new Map();
     constructor(shardInfo, libp2p) {
         super(MetadataCodec, libp2p.components, log, shardInfoToPubsubTopics(shardInfo));
         this.shardInfo = shardInfo;
@@ -3417,8 +3306,11 @@ class Metadata extends BaseProtocol {
             const { stream, connection } = streamData;
             const encodedShardInfo = WakuMetadataResponse.encode(this.shardInfo);
             const encodedResponse = await pipe([encodedShardInfo], encode, stream, decode, async (source) => await all(source));
-            const remoteShardInfoResponse = this.decodeMetadataResponse(encodedResponse);
-            await this.savePeerShardInfo(connection.remotePeer, remoteShardInfoResponse);
+            const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
+            if (error) {
+                return;
+            }
+            await this.savePeerShardInfo(connection.remotePeer, shardInfo);
         }
         catch (error) {
             log.error("Error handling metadata request", error);
@@ -3431,19 +3323,35 @@ class Metadata extends BaseProtocol {
         const request = WakuMetadataRequest.encode(this.shardInfo);
         const peer = await this.peerStore.get(peerId);
         if (!peer) {
-            throw new Error(`Peer ${peerId.toString()} not found`);
+            return {
+                shardInfo: null,
+                error: ProtocolError.NO_PEER_AVAILABLE
+            };
         }
         const stream = await this.getStream(peer);
         const encodedResponse = await pipe([request], encode, stream, decode, async (source) => await all(source));
-        const decodedResponse = this.decodeMetadataResponse(encodedResponse);
-        await this.savePeerShardInfo(peerId, decodedResponse);
-        return decodedResponse;
+        const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
+        if (error) {
+            return {
+                shardInfo: null,
+                error
+            };
+        }
+        await this.savePeerShardInfo(peerId, shardInfo);
+        return {
+            shardInfo,
+            error: null
+        };
     }
     async confirmOrAttemptHandshake(peerId) {
-        if (this.handshakesConfirmed.has(peerId.toString()))
-            return;
-        await this.query(peerId);
-        return;
+        const shardInfo = this.handshakesConfirmed.get(peerId.toString());
+        if (shardInfo) {
+            return {
+                shardInfo,
+                error: null
+            };
+        }
+        return await this.query(peerId);
     }
     decodeMetadataResponse(encodedResponse) {
         const bytes = new Uint8ArrayList();
@@ -3451,9 +3359,17 @@ class Metadata extends BaseProtocol {
             bytes.append(chunk);
         });
         const response = WakuMetadataResponse.decode(bytes);
-        if (!response)
+        if (!response) {
             log.error("Error decoding metadata response");
-        return response;
+            return {
+                shardInfo: null,
+                error: ProtocolError.DECODE_FAILED
+            };
+        }
+        return {
+            shardInfo: response,
+            error: null
+        };
     }
     async savePeerShardInfo(peerId, shardInfo) {
         // add or update the shardInfo to peer store
@@ -3462,11 +3378,11 @@ class Metadata extends BaseProtocol {
                 shardInfo: encodeRelayShard(shardInfo)
             }
         });
-        this.handshakesConfirmed.add(peerId.toString());
+        this.handshakesConfirmed.set(peerId.toString(), shardInfo);
     }
 }
 function wakuMetadata(shardInfo) {
     return (components) => new Metadata(shardInfo, components);
 }
 
-export { ConnectionManager, FilterCodecs, KeepAliveManager, LightPushCodec, MetadataCodec, PageDirection, createCursor, createEncoder, index$3 as message, waitForRemotePeer, wakuFilter, wakuLightPush, wakuMetadata, wakuStore, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };
+export { ConnectionManager, FilterCodecs, KeepAliveManager, LightPushCodec, LightPushCore, MetadataCodec, PageDirection, StoreCore, createEncoder, index$3 as message, waitForRemotePeer, wakuFilter, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };