@waku/core 0.0.29-fd60cc2.0 → 0.0.30-00c77c6.0

package/bundle/index.js

@@ -1,73 +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-B6lI5jri.js';
-export { j as createDecoder } from './version_0-B6lI5jri.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-DBP1NHED.js';
-import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-B8NGoK0E.js';
-export { S as StreamManager } from './base_protocol-B8NGoK0E.js';
-
-function groupByContentTopic(values) {
-    const groupedDecoders = new Map();
-    values.forEach((value) => {
-        let decs = groupedDecoders.get(value.contentTopic);
-        if (!decs) {
-            groupedDecoders.set(value.contentTopic, []);
-            decs = groupedDecoders.get(value.contentTopic);
-        }
-        decs.push(value);
-    });
-    return groupedDecoders;
-}
-
-const FRAME_RATE = 60;
-/**
- * Function that transforms IReceiver subscription to iterable stream of data.
- * @param receiver - object that allows to be subscribed to;
- * @param decoder - parameter to be passed to receiver for subscription;
- * @param options - options for receiver for subscription;
- * @param iteratorOptions - optional configuration for iterator;
- * @returns iterator and stop function to terminate it.
- */
-async function toAsyncIterator(receiver, decoder, iteratorOptions) {
-    const iteratorDelay = iteratorOptions?.iteratorDelay ?? FRAME_RATE;
-    const messages = [];
-    let unsubscribe;
-    unsubscribe = await receiver.subscribe(decoder, (message) => {
-        messages.push(message);
-    });
-    const isWithTimeout = Number.isInteger(iteratorOptions?.timeoutMs);
-    const timeoutMs = iteratorOptions?.timeoutMs ?? 0;
-    const startTime = Date.now();
-    async function* iterator() {
-        while (true) {
-            if (isWithTimeout && Date.now() - startTime >= timeoutMs) {
-                return;
-            }
-            await wait(iteratorDelay);
-            const message = messages.shift();
-            if (!unsubscribe && messages.length === 0) {
-                return message;
-            }
-            if (!message && unsubscribe) {
-                continue;
-            }
-            yield message;
-        }
-    }
-    return {
-        iterator: iterator(),
-        async stop() {
-            if (unsubscribe) {
-                await unsubscribe();
-                unsubscribe = undefined;
-            }
-        }
-    };
-}
-function wait(ms) {
-    return new Promise((resolve) => {
-        setTimeout(resolve, ms);
-    });
-}
+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-BoLZMvhu.js';
+export { j as createDecoder } from './version_0-BoLZMvhu.js';
+import { g as getDefaultExportFromCjs, P as ProtocolError, a as Protocols, E as EConnectionStateEvents, T as Tags, b as EPeersByDiscoveryEvents } from './browser-B9234RhB.js';
+import { a as allocUnsafe, b as alloc, L as Logger, u as utf8ToBytes, p as pubsubTopicToSingleShardInfo, s as shardInfoToPubsubTopics } from './index-egXdK_Fb.js';
+import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-kugTP2Op.js';
+export { S as StreamManager } from './base_protocol-kugTP2Op.js';
 
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
@@ -91,33 +27,6 @@ var index$3 = /*#__PURE__*/Object.freeze({
     version_0: version_0
 });
 
-/**
- * Deterministic Message Hashing as defined in
- * [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/#deterministic-message-hashing)
- */
-function messageHash(pubsubTopic, message) {
-    const pubsubTopicBytes = utf8ToBytes(pubsubTopic);
-    const contentTopicBytes = utf8ToBytes(message.contentTopic);
-    let bytes;
-    if (message.meta) {
-        bytes = concat$1([
-            pubsubTopicBytes,
-            message.payload,
-            contentTopicBytes,
-            message.meta
-        ]);
-    }
-    else {
-        bytes = concat$1([pubsubTopicBytes, message.payload, contentTopicBytes]);
-    }
-    return sha256(bytes);
-}
-function messageHashStr(pubsubTopic, message) {
-    const hash = messageHash(pubsubTopic, message);
-    const hashStr = bytesToUtf8(hash);
-    return hashStr;
-}
-
 /**
  * @packageDocumentation
  *
@@ -1701,249 +1610,14 @@ const FilterCodecs = {
     SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
     PUSH: "/vac/waku/filter-push/2.0.0-beta1"
 };
-/**
- * A subscription object refers to a subscription to a given pubsub topic.
- */
-class Subscription {
-    peers;
-    pubsubTopic;
-    newStream;
-    receivedMessagesHashStr = [];
-    subscriptionCallbacks;
-    constructor(pubsubTopic, remotePeers, newStream) {
-        this.peers = remotePeers;
-        this.pubsubTopic = pubsubTopic;
-        this.newStream = newStream;
-        this.subscriptionCallbacks = new Map();
-    }
-    async subscribe(decoders, callback) {
-        const decodersArray = Array.isArray(decoders) ? decoders : [decoders];
-        // check that all decoders are configured for the same pubsub topic as this subscription
-        decodersArray.forEach((decoder) => {
-            if (decoder.pubsubTopic !== this.pubsubTopic) {
-                throw new Error(`Pubsub topic not configured: decoder is configured for pubsub topic ${decoder.pubsubTopic} but this subscription is for pubsub topic ${this.pubsubTopic}. Please create a new Subscription for the different pubsub topic.`);
-            }
-        });
-        const decodersGroupedByCT = groupByContentTopic(decodersArray);
-        const contentTopics = Array.from(decodersGroupedByCT.keys());
-        const promises = this.peers.map(async (peer) => {
-            const stream = await this.newStream(peer);
-            const request = FilterSubscribeRpc.createSubscribeRequest(this.pubsubTopic, contentTopics);
-            try {
-                const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
-                if (!res || !res.length) {
-                    throw Error(`No response received for request ${request.requestId}: ${res}`);
-                }
-                const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
-                if (statusCode < 200 || statusCode >= 300) {
-                    throw new Error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
-                }
-                log$6.info("Subscribed to peer ", peer.id.toString(), "for content topics", contentTopics);
-            }
-            catch (e) {
-                throw new Error("Error subscribing to peer: " +
-                    peer.id.toString() +
-                    " for content topics: " +
-                    contentTopics +
-                    ": " +
-                    e);
-            }
-        });
-        const results = await Promise.allSettled(promises);
-        this.handleErrors(results, "subscribe");
-        // Save the callback functions by content topics so they
-        // can easily be removed (reciprocally replaced) if `unsubscribe` (reciprocally `subscribe`)
-        // is called for those content topics
-        decodersGroupedByCT.forEach((decoders, contentTopic) => {
-            // Cast the type because a given `subscriptionCallbacks` map may hold
-            // Decoder that decode to different implementations of `IDecodedMessage`
-            const subscriptionCallback = {
-                decoders,
-                callback
-            };
-            // The callback and decoder may override previous values, this is on
-            // purpose as the user may call `subscribe` to refresh the subscription
-            this.subscriptionCallbacks.set(contentTopic, subscriptionCallback);
-        });
-    }
-    async unsubscribe(contentTopics) {
-        const promises = this.peers.map(async (peer) => {
-            const stream = await this.newStream(peer);
-            const unsubscribeRequest = FilterSubscribeRpc.createUnsubscribeRequest(this.pubsubTopic, contentTopics);
-            try {
-                await pipe([unsubscribeRequest.encode()], encode, stream.sink);
-            }
-            catch (error) {
-                throw new Error("Error unsubscribing: " + error);
-            }
-            contentTopics.forEach((contentTopic) => {
-                this.subscriptionCallbacks.delete(contentTopic);
-            });
-        });
-        const results = await Promise.allSettled(promises);
-        this.handleErrors(results, "unsubscribe");
-    }
-    async ping() {
-        const promises = this.peers.map(async (peer) => {
-            const stream = await this.newStream(peer);
-            const request = FilterSubscribeRpc.createSubscriberPingRequest();
-            try {
-                const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
-                if (!res || !res.length) {
-                    throw Error(`No response received for request ${request.requestId}: ${res}`);
-                }
-                const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
-                if (statusCode < 200 || statusCode >= 300) {
-                    throw new Error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
-                }
-                log$6.info(`Ping successful for peer ${peer.id.toString()}`);
-            }
-            catch (error) {
-                log$6.error("Error pinging: ", error);
-                throw error; // Rethrow the actual error instead of wrapping it
-            }
-        });
-        const results = await Promise.allSettled(promises);
-        this.handleErrors(results, "ping");
-    }
-    async unsubscribeAll() {
-        const promises = this.peers.map(async (peer) => {
-            const stream = await this.newStream(peer);
-            const request = FilterSubscribeRpc.createUnsubscribeAllRequest(this.pubsubTopic);
-            try {
-                const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
-                if (!res || !res.length) {
-                    throw Error(`No response received for request ${request.requestId}: ${res}`);
-                }
-                const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
-                if (statusCode < 200 || statusCode >= 300) {
-                    throw new Error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
-                }
-                this.subscriptionCallbacks.clear();
-                log$6.info(`Unsubscribed from all content topics for pubsub topic ${this.pubsubTopic}`);
-            }
-            catch (error) {
-                throw new Error("Error unsubscribing from all content topics: " + error);
-            }
-        });
-        const results = await Promise.allSettled(promises);
-        this.handleErrors(results, "unsubscribeAll");
-    }
-    async processMessage(message) {
-        const hashedMessageStr = messageHashStr(this.pubsubTopic, message);
-        if (this.receivedMessagesHashStr.includes(hashedMessageStr)) {
-            log$6.info("Message already received, skipping");
-            return;
-        }
-        this.receivedMessagesHashStr.push(hashedMessageStr);
-        const { contentTopic } = message;
-        const subscriptionCallback = this.subscriptionCallbacks.get(contentTopic);
-        if (!subscriptionCallback) {
-            log$6.error("No subscription callback available for ", contentTopic);
-            return;
-        }
-        log$6.info("Processing message with content topic ", contentTopic, " on pubsub topic ", this.pubsubTopic);
-        await pushMessage(subscriptionCallback, this.pubsubTopic, message);
-    }
-    // Filter out only the rejected promises and extract & handle their reasons
-    handleErrors(results, type) {
-        const errors = results
-            .filter((result) => result.status === "rejected")
-            .map((rejectedResult) => rejectedResult.reason);
-        if (errors.length === this.peers.length) {
-            const errorCounts = new Map();
-            // TODO: streamline error logging with https://github.com/orgs/waku-org/projects/2/views/1?pane=issue&itemId=42849952
-            errors.forEach((error) => {
-                const message = error instanceof Error ? error.message : String(error);
-                errorCounts.set(message, (errorCounts.get(message) || 0) + 1);
-            });
-            const uniqueErrorMessages = Array.from(errorCounts, ([message, count]) => `${message} (occurred ${count} times)`).join(", ");
-            throw new Error(`Error ${type} all peers: ${uniqueErrorMessages}`);
-        }
-        else if (errors.length > 0) {
-            // TODO: handle renewing faulty peers with new peers (https://github.com/waku-org/js-waku/issues/1463)
-            log$6.warn(`Some ${type} failed. These will be refreshed with new peers`, errors);
-        }
-        else {
-            log$6.info(`${type} successful for all peers`);
-        }
-    }
-}
-const DEFAULT_NUM_PEERS = 3;
-class Filter extends BaseProtocol {
-    activeSubscriptions = new Map();
-    getActiveSubscription(pubsubTopic) {
-        return this.activeSubscriptions.get(pubsubTopic);
-    }
-    setActiveSubscription(pubsubTopic, subscription) {
-        this.activeSubscriptions.set(pubsubTopic, subscription);
-        return subscription;
-    }
-    //TODO: Remove when FilterCore and FilterSDK are introduced
-    numPeersToUse;
-    constructor(libp2p, options) {
+class FilterCore extends BaseProtocol {
+    handleIncomingMessage;
+    constructor(handleIncomingMessage, libp2p, options) {
         super(FilterCodecs.SUBSCRIBE, libp2p.components, log$6, options.pubsubTopics, options);
-        this.numPeersToUse = options?.numPeersToUse ?? DEFAULT_NUM_PEERS;
+        this.handleIncomingMessage = handleIncomingMessage;
         libp2p.handle(FilterCodecs.PUSH, this.onRequest.bind(this)).catch((e) => {
             log$6.error("Failed to register ", FilterCodecs.PUSH, e);
         });
-        this.activeSubscriptions = new Map();
-    }
-    /**
-     * Creates a new subscription to the given pubsub topic.
-     * The subscription is made to multiple peers for decentralization.
-     * @param pubsubTopicShardInfo The pubsub topic to subscribe to.
-     * @returns The subscription object.
-     */
-    async createSubscription(pubsubTopicShardInfo = DefaultPubsubTopic) {
-        const pubsubTopic = typeof pubsubTopicShardInfo == "string"
-            ? pubsubTopicShardInfo
-            : singleShardInfoToPubsubTopic(pubsubTopicShardInfo);
-        ensurePubsubTopicIsConfigured(pubsubTopic, this.pubsubTopics);
-        const peers = await this.getPeers({
-            maxBootstrapPeers: 1,
-            numPeers: this.numPeersToUse
-        });
-        if (peers.length === 0) {
-            throw new Error("No peer found to initiate subscription.");
-        }
-        log$6.info(`Creating filter subscription with ${peers.length} peers: `, peers.map((peer) => peer.id.toString()));
-        const subscription = this.getActiveSubscription(pubsubTopic) ??
-            this.setActiveSubscription(pubsubTopic, new Subscription(pubsubTopic, peers, this.getStream.bind(this)));
-        return subscription;
-    }
-    toSubscriptionIterator(decoders) {
-        return toAsyncIterator(this, decoders);
-    }
-    /**
-     * This method is used to satisfy the `IReceiver` interface.
-     *
-     * @hidden
-     *
-     * @param decoders The decoders to use for the subscription.
-     * @param callback The callback function to use for the subscription.
-     * @param opts Optional protocol options for the subscription.
-     *
-     * @returns A Promise that resolves to a function that unsubscribes from the subscription.
-     *
-     * @remarks
-     * This method should not be used directly.
-     * Instead, use `createSubscription` to create a new subscription.
-     */
-    async subscribe(decoders, callback) {
-        const pubsubTopics = this.getPubsubTopics(decoders);
-        if (pubsubTopics.length === 0) {
-            throw Error("Failed to subscribe: no pubsubTopic found on decoders provided.");
-        }
-        if (pubsubTopics.length > 1) {
-            throw Error("Failed to subscribe: all decoders should have the same pubsub topic. Use createSubscription to be more agile.");
-        }
-        const subscription = await this.createSubscription(pubsubTopics[0]);
-        await subscription.subscribe(decoders, callback);
-        const contentTopics = Array.from(groupByContentTopic(Array.isArray(decoders) ? decoders : [decoders]).keys());
-        return async () => {
-            await subscription.unsubscribe(contentTopics);
-        };
     }
     onRequest(streamData) {
         const { connection, stream } = streamData;
@@ -1962,12 +1636,7 @@ class Filter extends BaseProtocol {
                         log$6.error("Pubsub topic missing from push message");
                         return;
                     }
-                    const subscription = this.getActiveSubscription(pubsubTopic);
-                    if (!subscription) {
-                        log$6.error(`No subscription locally registered for topic ${pubsubTopic}`);
-                        return;
-                    }
-                    await subscription.processMessage(wakuMessage);
+                    await this.handleIncomingMessage(pubsubTopic, wakuMessage);
                 }
             }).then(() => {
                 log$6.info("Receiving pipe closed.");
@@ -1979,43 +1648,163 @@ class Filter extends BaseProtocol {
             log$6.error("Error decoding message", e);
         }
     }
-    getPubsubTopics(decoders) {
-        if (!Array.isArray(decoders)) {
-            return [decoders.pubsubTopic];
+    async subscribe(pubsubTopic, peer, contentTopics) {
+        const stream = await this.getStream(peer);
+        const request = FilterSubscribeRpc.createSubscribeRequest(pubsubTopic, contentTopics);
+        let res;
+        try {
+            res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
         }
-        if (decoders.length === 0) {
-            return [];
+        catch (error) {
+            log$6.error("Failed to send subscribe request", error);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.GENERIC_FAIL,
+                    peerId: peer.id
+                }
+            };
         }
-        const pubsubTopics = new Set(decoders.map((d) => d.pubsubTopic));
-        return [...pubsubTopics];
+        const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
+        if (statusCode < 200 || statusCode >= 300) {
+            log$6.error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            return {
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    peerId: peer.id
+                },
+                success: null
+            };
+        }
+        return {
+            failure: null,
+            success: peer.id
+        };
     }
-}
-function wakuFilter(init = { pubsubTopics: [] }) {
-    return (libp2p) => new Filter(libp2p, init);
-}
-async function pushMessage(subscriptionCallback, pubsubTopic, message) {
-    const { decoders, callback } = subscriptionCallback;
-    const { contentTopic } = message;
-    if (!contentTopic) {
-        log$6.warn("Message has no content topic, skipping");
-        return;
+    async unsubscribe(pubsubTopic, peer, contentTopics) {
+        let stream;
+        try {
+            stream = await this.getStream(peer);
+        }
+        catch (error) {
+            log$6.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    peerId: peer.id
+                }
+            };
+        }
+        const unsubscribeRequest = FilterSubscribeRpc.createUnsubscribeRequest(pubsubTopic, contentTopics);
+        try {
+            await pipe([unsubscribeRequest.encode()], encode, stream.sink);
+        }
+        catch (error) {
+            log$6.error("Failed to send unsubscribe request", error);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.GENERIC_FAIL,
+                    peerId: peer.id
+                }
+            };
+        }
+        return {
+            success: peer.id,
+            failure: null
+        };
     }
-    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);
+    async unsubscribeAll(pubsubTopic, peer) {
+        const stream = await this.getStream(peer);
+        const request = FilterSubscribeRpc.createUnsubscribeAllRequest(pubsubTopic);
+        const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
+        if (!res || !res.length) {
+            return {
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    peerId: peer.id
+                },
+                success: null
+            };
+        }
+        const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
+        if (statusCode < 200 || statusCode >= 300) {
+            log$6.error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            return {
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    peerId: peer.id
+                },
+                success: null
+            };
+        }
+        return {
+            failure: null,
+            success: peer.id
+        };
     }
-    catch (e) {
-        log$6.error("Error decoding message", e);
+    async ping(peer) {
+        let stream;
+        try {
+            stream = await this.getStream(peer);
+        }
+        catch (error) {
+            log$6.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    peerId: peer.id
+                }
+            };
+        }
+        const request = FilterSubscribeRpc.createSubscriberPingRequest();
+        let res;
+        try {
+            res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
+        }
+        catch (error) {
+            log$6.error("Failed to send ping request", error);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.GENERIC_FAIL,
+                    peerId: peer.id
+                }
+            };
+        }
+        if (!res || !res.length) {
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    peerId: peer.id
+                }
+            };
+        }
+        const { statusCode, requestId, statusDesc } = FilterSubscribeResponse.decode(res[0].slice());
+        if (statusCode < 200 || statusCode >= 300) {
+            log$6.error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
+            return {
+                success: null,
+                failure: {
+                    error: ProtocolError.REMOTE_PEER_REJECTED,
+                    peerId: peer.id
+                }
+            };
+        }
+        return {
+            success: peer.id,
+            failure: null
+        };
     }
 }
 
 var index$2 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     FilterCodecs: FilterCodecs,
-    wakuFilter: wakuFilter
+    FilterCore: FilterCore
 });
 
 class PushRpc {
@@ -2612,7 +2401,7 @@ async function waitForRemotePeer(waku, protocols, timeoutMs) {
     if (protocols.includes(Protocols.Filter)) {
         if (!waku.filter)
             throw new Error("Cannot wait for Filter peer: protocol not mounted");
-        promises.push(waitForConnectedPeer(waku.filter, waku.libp2p.services.metadata));
+        promises.push(waitForConnectedPeer(waku.filter.protocol, waku.libp2p.services.metadata));
     }
     if (timeoutMs) {
         await rejectOnTimeout(Promise.all(promises), timeoutMs, "Timed out waiting for a remote peer.");
@@ -2830,7 +2619,7 @@ class KeepAliveManager {
                             return;
                         }
                         try {
-                            await peerStore.patch(peerId, {
+                            await peerStore.merge(peerId, {
                                 metadata: {
                                     ping: utf8ToBytes(ping.toString())
                                 }
@@ -3402,4 +3191,4 @@ function wakuMetadata(shardInfo) {
     return (components) => new Metadata(shardInfo, components);
 }
 
-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 };
+export { ConnectionManager, FilterCodecs, FilterCore, KeepAliveManager, LightPushCodec, LightPushCore, MetadataCodec, PageDirection, StoreCore, createEncoder, index$3 as message, waitForRemotePeer, 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-DBP1NHED.js';
-import '../browser-DoQRY-an.js';
-export { B as BaseProtocol } from '../base_protocol-B8NGoK0E.js';
+import '../index-egXdK_Fb.js';
+import '../browser-B9234RhB.js';
+export { B as BaseProtocol } from '../base_protocol-kugTP2Op.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-B6lI5jri.js';
-import '../../index-DBP1NHED.js';
-import '../../browser-DoQRY-an.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-BoLZMvhu.js';
+import '../../index-egXdK_Fb.js';
+import '../../browser-B9234RhB.js';

package/bundle/lib/predefined_bootstrap_nodes.js

@@ -1,4 +1,4 @@
-import '../browser-DoQRY-an.js';
+import '../browser-B9234RhB.js';
 
 /**
  * Return pseudo random subset of the input.

package/bundle/{version_0-B6lI5jri.js → version_0-BoLZMvhu.js}

@@ -1,4 +1,4 @@
-import { a as allocUnsafe, h as fromString, d as alloc$1, L as Logger, i as determinePubsubTopic } from './index-DBP1NHED.js';
+import { a as allocUnsafe, f as fromString, b as alloc$1, L as Logger, d as determinePubsubTopic } from './index-egXdK_Fb.js';
 
 /* eslint-disable no-fallthrough */
 const N1 = Math.pow(2, 7);
@@ -3228,14 +3228,14 @@ var HistoryResponse;
     (function (HistoryError) {
         HistoryError["NONE"] = "NONE";
         HistoryError["INVALID_CURSOR"] = "INVALID_CURSOR";
-        HistoryError["TOO_MANY_RESULTS"] = "TOO_MANY_RESULTS";
+        HistoryError["TOO_MANY_REQUESTS"] = "TOO_MANY_REQUESTS";
         HistoryError["SERVICE_UNAVAILABLE"] = "SERVICE_UNAVAILABLE";
     })(HistoryError = HistoryResponse.HistoryError || (HistoryResponse.HistoryError = {}));
     let __HistoryErrorValues;
     (function (__HistoryErrorValues) {
         __HistoryErrorValues[__HistoryErrorValues["NONE"] = 0] = "NONE";
         __HistoryErrorValues[__HistoryErrorValues["INVALID_CURSOR"] = 1] = "INVALID_CURSOR";
-        __HistoryErrorValues[__HistoryErrorValues["TOO_MANY_RESULTS"] = 429] = "TOO_MANY_RESULTS";
+        __HistoryErrorValues[__HistoryErrorValues["TOO_MANY_REQUESTS"] = 429] = "TOO_MANY_REQUESTS";
         __HistoryErrorValues[__HistoryErrorValues["SERVICE_UNAVAILABLE"] = 503] = "SERVICE_UNAVAILABLE";
     })(__HistoryErrorValues || (__HistoryErrorValues = {}));
     (function (HistoryError) {