@waku/core 0.0.28-b5e8b17.0 → 0.0.28-efe9b8d.0

package/bundle/{base_protocol-BCwLeb-A.js → base_protocol-D0Zdzb-v.js}

@@ -1,4 +1,4 @@
-import { b as bytesToUtf8, L as Logger, k as ensureShardingConfigured } from './index-vlQahmUj.js';
+import { b as bytesToUtf8, L as Logger, j as ensureShardingConfigured } from './index-BJwgMx4y.js';
 import { T as Tags } from './browser-DoQRY-an.js';
 
 const decodeRelayShard = (bytes) => {

package/bundle/{index-vlQahmUj.js → index-BJwgMx4y.js}

@@ -1,24 +1,10 @@
 import { i as identityBase, c as base2, d as base8, e as base10, f as base16, h as base32, j as base36, k as base58, l as base64, m as base256emoji, n as debug } from './browser-DoQRY-an.js';
 
-/**
- * To guarantee Uint8Array semantics, convert nodejs Buffers
- * into vanilla Uint8Arrays
- */
-function asUint8Array(buf) {
-    if (globalThis.Buffer != null) {
-        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
-    }
-    return buf;
-}
-
 /**
  * Returns a `Uint8Array` of the requested size. Referenced memory will
  * be initialized to 0.
  */
 function alloc(size = 0) {
-    if (globalThis.Buffer?.alloc != null) {
-        return asUint8Array(globalThis.Buffer.alloc(size));
-    }
     return new Uint8Array(size);
 }
 /**
@@ -27,9 +13,6 @@ function alloc(size = 0) {
  * overwrite every value in the returned `Uint8Array`.
  */
 function allocUnsafe(size = 0) {
-    if (globalThis.Buffer?.allocUnsafe != null) {
-        return asUint8Array(globalThis.Buffer.allocUnsafe(size));
-    }
     return new Uint8Array(size);
 }
 
@@ -92,23 +75,20 @@ function fromString(string, encoding = 'utf8') {
     if (base == null) {
         throw new Error(`Unsupported encoding "${encoding}"`);
     }
-    if ((encoding === 'utf8' || encoding === 'utf-8') && globalThis.Buffer != null && globalThis.Buffer.from != null) {
-        return asUint8Array(globalThis.Buffer.from(string, 'utf-8'));
-    }
     // add multibase prefix
     return base.decoder.decode(`${base.prefix}${string}`); // eslint-disable-line @typescript-eslint/restrict-template-expressions
 }
 
 // copied from utils
-function isBytes$1(a) {
+function isBytes(a) {
     return (a instanceof Uint8Array ||
         (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
 }
 function bytes(b, ...lengths) {
-    if (!isBytes$1(b))
-        throw new Error('Expected Uint8Array');
+    if (!isBytes(b))
+        throw new Error('Uint8Array expected');
     if (lengths.length > 0 && !lengths.includes(b.length))
-        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
+        throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
 }
 function exists(instance, checkFinished = true) {
     if (instance.destroyed)
@@ -131,21 +111,11 @@ function output(out, instance) {
 // from `crypto` to `cryptoNode`, which imports native module.
 // Makes the utils un-importable in browsers without a bundler.
 // Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
-function isBytes(a) {
-    return (a instanceof Uint8Array ||
-        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
-}
 // Cast array to view
 const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 // The rotate right (circular right shift) operation for uint32
 const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
-// big-endian hardware is rare. Just in case someone still decides to run hashes:
-// early-throw an error because we don't support BE yet.
-// Other libraries would silently corrupt the data instead of throwing an error,
-// when they don't support it.
-const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
-if (!isLE)
-    throw new Error('Non little-endian hardware is not supported');
+new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
 /**
  * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
  */
@@ -162,8 +132,7 @@ function utf8ToBytes$1(str) {
 function toBytes(data) {
     if (typeof data === 'string')
         data = utf8ToBytes$1(data);
-    if (!isBytes(data))
-        throw new Error(`expected Uint8Array, got ${typeof data}`);
+    bytes(data);
     return data;
 }
 // For runtime check if class implements interface
@@ -195,8 +164,15 @@ function setBigUint64(view, byteOffset, value, isLE) {
     view.setUint32(byteOffset + h, wh, isLE);
     view.setUint32(byteOffset + l, wl, isLE);
 }
-// Base SHA2 class (RFC 6234)
-class SHA2 extends Hash {
+// Choice: a ? b : c
+const Chi = (a, b, c) => (a & b) ^ (~a & c);
+// Majority function, true if any two inpust is true
+const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
+/**
+ * Merkle-Damgard hash construction base class.
+ * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+ */
+class HashMD extends Hash {
     constructor(blockLen, outputLen, padOffset, isLE) {
         super();
         this.blockLen = blockLen;
@@ -248,7 +224,8 @@ class SHA2 extends Hash {
         // append the bit '1' to the message
         buffer[pos++] = 0b10000000;
         this.buffer.subarray(pos).fill(0);
-        // we have less than padOffset left in buffer, so we cannot put length in current block, need process it and pad again
+        // we have less than padOffset left in buffer, so we cannot put length in
+        // current block, need process it and pad again
         if (this.padOffset > blockLen - pos) {
             this.process(view, 0);
             pos = 0;
@@ -296,10 +273,6 @@ class SHA2 extends Hash {
 
 // SHA2-256 need to try 2^128 hashes to execute birthday attack.
 // BTC network is doing 2^67 hashes/sec as per early 2023.
-// Choice: a ? b : c
-const Chi = (a, b, c) => (a & b) ^ (~a & c);
-// Majority function, true if any two inpust is true
-const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
 // Round constants:
 // first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
 // prettier-ignore
@@ -313,27 +286,28 @@ const SHA256_K = /* @__PURE__ */ new Uint32Array([
     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 ]);
-// Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
+// Initial state:
+// first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19
 // prettier-ignore
-const IV = /* @__PURE__ */ new Uint32Array([
+const SHA256_IV = /* @__PURE__ */ new Uint32Array([
     0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
 ]);
 // Temporary buffer, not used to store anything between runs
 // Named this way because it matches specification.
 const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
-class SHA256 extends SHA2 {
+class SHA256 extends HashMD {
     constructor() {
         super(64, 32, 8, false);
         // We cannot use array here since array allows indexing by variable
         // which means optimizer/compiler cannot use registers.
-        this.A = IV[0] | 0;
-        this.B = IV[1] | 0;
-        this.C = IV[2] | 0;
-        this.D = IV[3] | 0;
-        this.E = IV[4] | 0;
-        this.F = IV[5] | 0;
-        this.G = IV[6] | 0;
-        this.H = IV[7] | 0;
+        this.A = SHA256_IV[0] | 0;
+        this.B = SHA256_IV[1] | 0;
+        this.C = SHA256_IV[2] | 0;
+        this.D = SHA256_IV[3] | 0;
+        this.E = SHA256_IV[4] | 0;
+        this.F = SHA256_IV[5] | 0;
+        this.G = SHA256_IV[6] | 0;
+        this.H = SHA256_IV[7] | 0;
     }
     get() {
         const { A, B, C, D, E, F, G, H } = this;
@@ -423,9 +397,6 @@ function toString(array, encoding = 'utf8') {
     if (base == null) {
         throw new Error(`Unsupported encoding "${encoding}"`);
     }
-    if ((encoding === 'utf8' || encoding === 'utf-8') && globalThis.Buffer != null && globalThis.Buffer.from != null) {
-        return globalThis.Buffer.from(array.buffer, array.byteOffset, array.byteLength).toString('utf8');
-    }
     // strip multibase prefix
     return base.encoder.encode(array).substring(1);
 }
@@ -471,7 +442,7 @@ const shardInfoToPubsubTopics = (shardInfo) => {
     else if ("application" in shardInfo && "version" in shardInfo) {
         // Autosharding: single shard from application and version
         return [
-            contentTopicToPubsubTopic(`/${shardInfo.application}/${shardInfo.version}/default/default`)
+            contentTopicToPubsubTopic(`/${shardInfo.application}/${shardInfo.version}/default/default`, shardInfo.clusterId)
         ];
     }
     else {
@@ -608,7 +579,7 @@ const ensureShardingConfigured = (shardInfo) => {
         };
     }
     if (isApplicationVersionConfigured) {
-        const pubsubTopic = contentTopicToPubsubTopic(`/${application}/${version}/default/default`);
+        const pubsubTopic = contentTopicToPubsubTopic(`/${application}/${version}/default/default`, clusterId);
         return {
             shardingParams: { clusterId, application, version },
             shardInfo: {
@@ -649,4 +620,4 @@ class Logger {
     }
 }
 
-export { DefaultPubsubTopic as D, Logger as L, asUint8Array as a, bytesToUtf8 as b, concat as c, allocUnsafe as d, alloc as e, singleShardInfoToPubsubTopic as f, ensurePubsubTopicIsConfigured as g, shardInfoToPubsubTopics as h, fromString as i, determinePubsubTopic as j, ensureShardingConfigured as k, pubsubTopicToSingleShardInfo as p, sha256 as s, utf8ToBytes as u };
+export { DefaultPubsubTopic as D, Logger as L, allocUnsafe as a, bytesToUtf8 as b, concat as c, alloc as d, singleShardInfoToPubsubTopic as e, ensurePubsubTopicIsConfigured as f, shardInfoToPubsubTopics as g, fromString as h, determinePubsubTopic as i, ensureShardingConfigured as j, pubsubTopicToSingleShardInfo as p, sha256 as s, utf8ToBytes as u };

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-DiakMc1A.js';
-export { j as createDecoder } from './version_0-DiakMc1A.js';
+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 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-vlQahmUj.js';
-import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-BCwLeb-A.js';
-export { S as StreamManager } from './base_protocol-BCwLeb-A.js';
-
-function isDefined(value) {
-    return Boolean(value);
-}
+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;
 }
@@ -2128,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";
@@ -2201,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 {
@@ -2576,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');
@@ -2724,7 +2585,7 @@ 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)
@@ -3524,4 +3385,4 @@ function wakuMetadata(shardInfo) {
     return (components) => new Metadata(shardInfo, components);
 }
 
-export { ConnectionManager, FilterCodecs, KeepAliveManager, LightPushCodec, LightPushCore, MetadataCodec, PageDirection, createCursor, createEncoder, index$3 as message, waitForRemotePeer, wakuFilter, 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 };

package/bundle/lib/base_protocol.js

@@ -1,3 +1,3 @@
-import '../index-vlQahmUj.js';
+import '../index-BJwgMx4y.js';
 import '../browser-DoQRY-an.js';
-export { B as BaseProtocol } from '../base_protocol-BCwLeb-A.js';
+export { B as BaseProtocol } from '../base_protocol-D0Zdzb-v.js';

package/bundle/lib/message/version_0.js

@@ -1,3 +1,3 @@
-export { D as DecodedMessage, k as Decoder, E as Encoder, V as Version, j as createDecoder, h as createEncoder, m as proto } from '../../version_0-DiakMc1A.js';
-import '../../index-vlQahmUj.js';
+export { D as DecodedMessage, k as Decoder, E as Encoder, V as Version, j as createDecoder, h as createEncoder, m as proto } from '../../version_0-C6o0DvNW.js';
+import '../../index-BJwgMx4y.js';
 import '../../browser-DoQRY-an.js';