@waku/core 0.0.27 → 0.0.28-b5e8b17.0

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

@@ -1,5 +1,5 @@
-import { b as bytesToUtf8, L as Logger, k as ensureShardingConfigured } from './index-8YyfzF9R.js';
-import { T as Tags } from './browser-BQyFvtq6.js';
+import { b as bytesToUtf8, L as Logger, k as ensureShardingConfigured } from './index-vlQahmUj.js';
+import { T as Tags } from './browser-DoQRY-an.js';
 
 const decodeRelayShard = (bytes) => {
     // explicitly converting to Uint8Array to avoid Buffer
@@ -229,7 +229,6 @@ class StreamManager {
     };
 }
 
-const DEFAULT_NUM_PEERS_TO_USE = 3;
 /**
  * A class with predefined helpers, to be used as a base to implement Waku
  * Protocols.
@@ -242,7 +241,6 @@ class BaseProtocol {
     options;
     addLibp2pEventListener;
     removeLibp2pEventListener;
-    numPeersToUse;
     streamManager;
     constructor(multicodec, components, log, pubsubTopics, options) {
         this.multicodec = multicodec;
@@ -250,7 +248,6 @@ class BaseProtocol {
         this.log = log;
         this.pubsubTopics = pubsubTopics;
         this.options = options;
-        this.numPeersToUse = options?.numPeersToUse ?? DEFAULT_NUM_PEERS_TO_USE;
         this.addLibp2pEventListener = components.events.addEventListener.bind(components.events);
         this.removeLibp2pEventListener = components.events.removeEventListener.bind(components.events);
         this.streamManager = new StreamManager(multicodec, components.connectionManager.getConnections.bind(components.connectionManager), this.addLibp2pEventListener);

package/bundle/{browser-BQyFvtq6.js → browser-DoQRY-an.js}

@@ -627,54 +627,59 @@ var Protocols;
     Protocols["LightPush"] = "lightpush";
     Protocols["Filter"] = "filter";
 })(Protocols || (Protocols = {}));
-var SendError;
-(function (SendError) {
+var ProtocolError;
+(function (ProtocolError) {
     /** Could not determine the origin of the fault. Best to check connectivity and try again */
-    SendError["GENERIC_FAIL"] = "Generic error";
+    ProtocolError["GENERIC_FAIL"] = "Generic error";
     /**
      * Failure to protobuf encode the message. This is not recoverable and needs
      * further investigation.
      */
-    SendError["ENCODE_FAILED"] = "Failed to encode";
+    ProtocolError["ENCODE_FAILED"] = "Failed to encode";
     /**
      * Failure to protobuf decode the message. May be due to a remote peer issue,
      * ensuring that messages are sent via several peer enable mitigation of this error.
      */
-    SendError["DECODE_FAILED"] = "Failed to decode";
+    ProtocolError["DECODE_FAILED"] = "Failed to decode";
     /**
      * The message payload is empty, making the message invalid. Ensure that a non-empty
      * payload is set on the outgoing message.
      */
-    SendError["EMPTY_PAYLOAD"] = "Payload is empty";
+    ProtocolError["EMPTY_PAYLOAD"] = "Payload is empty";
     /**
      * The message size is above the maximum message size allowed on the Waku Network.
      * Compressing the message or using an alternative strategy for large messages is recommended.
      */
-    SendError["SIZE_TOO_BIG"] = "Size is too big";
+    ProtocolError["SIZE_TOO_BIG"] = "Size is too big";
     /**
      * The PubsubTopic passed to the send function is not configured on the Waku node.
      * Please ensure that the PubsubTopic is used when initializing the Waku node.
      */
-    SendError["TOPIC_NOT_CONFIGURED"] = "Topic not configured";
+    ProtocolError["TOPIC_NOT_CONFIGURED"] = "Topic not configured";
     /**
      * Failure to find a peer with suitable protocols. This may due to a connection issue.
      * Mitigation can be: retrying after a given time period, display connectivity issue
      * to user or listening for `peer:connected:bootstrap` or `peer:connected:peer-exchange`
      * on the connection manager before retrying.
      */
-    SendError["NO_PEER_AVAILABLE"] = "No peer available";
+    ProtocolError["NO_PEER_AVAILABLE"] = "No peer available";
     /**
      * The remote peer did not behave as expected. Mitigation for `NO_PEER_AVAILABLE`
      * or `DECODE_FAILED` can be used.
      */
-    SendError["REMOTE_PEER_FAULT"] = "Remote peer fault";
+    ProtocolError["REMOTE_PEER_FAULT"] = "Remote peer fault";
     /**
      * The remote peer rejected the message. Information provided by the remote peer
      * is logged. Review message validity, or mitigation for `NO_PEER_AVAILABLE`
      * or `DECODE_FAILED` can be used.
      */
-    SendError["REMOTE_PEER_REJECTED"] = "Remote peer rejected";
-})(SendError || (SendError = {}));
+    ProtocolError["REMOTE_PEER_REJECTED"] = "Remote peer rejected";
+    /**
+     * The protocol request timed out without a response. This may be due to a connection issue.
+     * Mitigation can be: retrying after a given time period
+     */
+    ProtocolError["REQUEST_TIMEOUT"] = "Request timeout";
+})(ProtocolError || (ProtocolError = {}));
 
 var PageDirection;
 (function (PageDirection) {
@@ -1426,4 +1431,4 @@ var common = setup;
 var browserExports = browser.exports;
 var debug = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
-export { EConnectionStateEvents as E, Protocols as P, SendError as S, Tags as T, EPeersByDiscoveryEvents as a, base2$1 as b, base8$1 as c, base10$1 as d, base16$1 as e, base32$1 as f, getDefaultExportFromCjs as g, base36$1 as h, identityBase as i, base58 as j, base64$1 as k, base256emoji$1 as l, debug as m };
+export { EConnectionStateEvents as E, ProtocolError as P, Tags as T, Protocols as a, EPeersByDiscoveryEvents as b, base2$1 as c, base8$1 as d, base10$1 as e, base16$1 as f, getDefaultExportFromCjs as g, base32$1 as h, identityBase as i, base36$1 as j, base58 as k, base64$1 as l, base256emoji$1 as m, debug as n };

package/bundle/{index-8YyfzF9R.js → index-vlQahmUj.js}

@@ -1,4 +1,4 @@
-import { i as identityBase, b as base2, c as base8, d as base10, e as base16, f as base32, h as base36, j as base58, k as base64, l as base256emoji, m as debug } from './browser-BQyFvtq6.js';
+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
@@ -494,6 +494,8 @@ const pubsubTopicToSingleShardInfo = (pubsubTopics) => {
         shard
     };
 };
+//TODO: move part of BaseProtocol instead of utils
+// return `ProtocolError.TOPIC_NOT_CONFIGURED` instead of throwing
 function ensurePubsubTopicIsConfigured(pubsubTopic, configuredTopics) {
     if (!configuredTopics.includes(pubsubTopic)) {
         throw new Error(`Pubsub topic ${pubsubTopic} has not been configured on this instance. Configured topics are: ${configuredTopics}. Please update your configuration by passing in the topic during Waku node instantiation.`);

package/bundle/index.js

@@ -1,9 +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';
+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 { 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);
@@ -1827,6 +1827,7 @@ class Subscription {
         }
     }
 }
+const DEFAULT_NUM_PEERS = 3;
 class Filter extends BaseProtocol {
     activeSubscriptions = new Map();
     getActiveSubscription(pubsubTopic) {
@@ -1836,8 +1837,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 +1994,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 = {
@@ -2684,6 +2691,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
@@ -2721,7 +2729,7 @@ async function waitForRemotePeer(waku, protocols, timeoutMs) {
     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 +2743,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 +2829,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 +3428,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 +3445,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 +3462,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 +3498,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 +3517,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, 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 };

package/bundle/lib/base_protocol.js

@@ -1,3 +1,3 @@
-import '../index-8YyfzF9R.js';
-import '../browser-BQyFvtq6.js';
-export { B as BaseProtocol } from '../base_protocol-LhsIWF3-.js';
+import '../index-vlQahmUj.js';
+import '../browser-DoQRY-an.js';
+export { B as BaseProtocol } from '../base_protocol-BCwLeb-A.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-FXfzO8Km.js';
-import '../../index-8YyfzF9R.js';
-import '../../browser-BQyFvtq6.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-DiakMc1A.js';
+import '../../index-vlQahmUj.js';
+import '../../browser-DoQRY-an.js';

package/bundle/lib/predefined_bootstrap_nodes.js

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

package/bundle/{version_0-FXfzO8Km.js → version_0-DiakMc1A.js}

@@ -1,4 +1,4 @@
-import { d as allocUnsafe, i as fromString, L as Logger, j as determinePubsubTopic } from './index-8YyfzF9R.js';
+import { d as allocUnsafe, i as fromString, L as Logger, j as determinePubsubTopic } from './index-vlQahmUj.js';
 
 /* eslint-disable no-fallthrough */
 const N1 = Math.pow(2, 7);