@waku/core 0.0.33-acef1ac.0 → 0.0.33-b7bdb60.0

package/bundle/index.js

@@ -1,8 +1,8 @@
-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, S as StoreQueryRequest$1, f as StoreQueryResponse$1, g as createEncoder, W as WakuMetadataRequest, h as WakuMetadataResponse } from './version_0-BrbNEwD-.js';
-export { i as createDecoder } from './version_0-BrbNEwD-.js';
-import { a as allocUnsafe, b as alloc, L as Logger, P as ProtocolError, c as Protocols, u as utf8ToBytes, p as pubsubTopicToSingleShardInfo, T as Tags, E as EPeersByDiscoveryEvents, s as shardInfoToPubsubTopics, d as EConnectionStateEvents, H as HealthStatus, e as pubsubTopicsToShardInfo } from './index-tdQNdKHx.js';
-import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-BS9mxaB7.js';
-export { S as StreamManager } from './base_protocol-BS9mxaB7.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, S as StoreQueryRequest$1, f as StoreQueryResponse$1, g as createEncoder, p as pubsubTopicToSingleShardInfo, s as shardInfoToPubsubTopics, W as WakuMetadataRequest, h as pubsubTopicsToShardInfo, i as WakuMetadataResponse } from './version_0-BYg0O3M-.js';
+export { j as createDecoder } from './version_0-BYg0O3M-.js';
+import { a as allocUnsafe, b as alloc, L as Logger, P as ProtocolError, u as utf8ToBytes, T as Tags, E as EPeersByDiscoveryEvents, c as EConnectionStateEvents, H as HealthStatus, d as Protocols } from './index-CeEH6b9b.js';
+import { B as BaseProtocol } from './base_protocol-BDjsZTsQ.js';
+export { S as StreamManager } from './base_protocol-BDjsZTsQ.js';
 
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
@@ -23,6 +23,60 @@ const isWireSizeUnderCap = (buf) => buf.length / MB <= SIZE_CAP_IN_MB;
 
 const DNS_DISCOVERY_TAG = "@waku/bootstrap";
 
+const decodeRelayShard = (bytes) => {
+    // explicitly converting to Uint8Array to avoid Buffer
+    // https://github.com/libp2p/js-libp2p/issues/2146
+    bytes = new Uint8Array(bytes);
+    if (bytes.length < 3)
+        throw new Error("Insufficient data");
+    const view = new DataView(bytes.buffer);
+    const clusterId = view.getUint16(0);
+    const shards = [];
+    if (bytes.length === 130) {
+        // rsv format (Bit Vector)
+        for (let i = 0; i < 1024; i++) {
+            const byteIndex = Math.floor(i / 8) + 2; // Adjusted for the 2-byte cluster field
+            const bitIndex = 7 - (i % 8);
+            if (view.getUint8(byteIndex) & (1 << bitIndex)) {
+                shards.push(i);
+            }
+        }
+    }
+    else {
+        // rs format (Index List)
+        const numIndices = view.getUint8(2);
+        for (let i = 0, offset = 3; i < numIndices; i++, offset += 2) {
+            if (offset + 1 >= bytes.length)
+                throw new Error("Unexpected end of data");
+            shards.push(view.getUint16(offset));
+        }
+    }
+    return { clusterId, shards };
+};
+const encodeRelayShard = (shardInfo) => {
+    const { clusterId, shards } = shardInfo;
+    const totalLength = shards.length >= 64 ? 130 : 3 + 2 * shards.length;
+    const buffer = new ArrayBuffer(totalLength);
+    const view = new DataView(buffer);
+    view.setUint16(0, clusterId);
+    if (shards.length >= 64) {
+        // rsv format (Bit Vector)
+        for (const index of shards) {
+            const byteIndex = Math.floor(index / 8) + 2; // Adjusted for the 2-byte cluster field
+            const bitIndex = 7 - (index % 8);
+            view.setUint8(byteIndex, view.getUint8(byteIndex) | (1 << bitIndex));
+        }
+    }
+    else {
+        // rs format (Index List)
+        view.setUint8(2, shards.length);
+        for (let i = 0, offset = 3; i < shards.length; i++, offset += 2) {
+            view.setUint16(offset, shards[i]);
+        }
+    }
+    return new Uint8Array(buffer);
+};
+
 var index$3 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     version_0: version_0
@@ -1040,7 +1094,7 @@ class FIFO {
  * // [ [1, 2, 3] ]
  * ```
  */
-let AbortError$1 = class AbortError extends Error {
+class AbortError extends Error {
     type;
     code;
     constructor(message, code) {
@@ -1048,7 +1102,7 @@ let AbortError$1 = class AbortError extends Error {
         this.type = 'aborted';
         this.code = code ?? 'ABORT_ERR';
     }
-};
+}
 function pushable(options = {}) {
     const getNext = (buffer) => {
         const next = buffer.shift();
@@ -1168,7 +1222,7 @@ function _pushable(getNext, options) {
             if (signal != null) {
                 cancel = new Promise((resolve, reject) => {
                     listener = () => {
-                        reject(new AbortError$1());
+                        reject(new AbortError());
                     };
                     signal.addEventListener('abort', listener);
                 });
@@ -1557,26 +1611,24 @@ class FilterSubscribeResponse {
     }
 }
 
-const log$6 = new Logger("filter:v2");
+const log$5 = new Logger("filter:v2");
 const FilterCodecs = {
     SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
     PUSH: "/vac/waku/filter-push/2.0.0-beta1"
 };
 class FilterCore extends BaseProtocol {
     handleIncomingMessage;
-    handleError;
     pubsubTopics;
-    constructor(handleIncomingMessage, handleError, pubsubTopics, libp2p) {
-        super(FilterCodecs.SUBSCRIBE, libp2p.components, log$6, pubsubTopics);
+    constructor(handleIncomingMessage, pubsubTopics, libp2p) {
+        super(FilterCodecs.SUBSCRIBE, libp2p.components, log$5, pubsubTopics);
         this.handleIncomingMessage = handleIncomingMessage;
-        this.handleError = handleError;
         this.pubsubTopics = pubsubTopics;
         libp2p
             .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
             maxInboundStreams: 100
         })
             .catch((e) => {
-            log$6.error("Failed to register ", FilterCodecs.PUSH, e);
+            log$5.error("Failed to register ", FilterCodecs.PUSH, e);
         });
     }
     async subscribe(pubsubTopic, peer, contentTopics) {
@@ -1587,7 +1639,7 @@ class FilterCore extends BaseProtocol {
             res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
         }
         catch (error) {
-            log$6.error("Failed to send subscribe request", error);
+            log$5.error("Failed to send subscribe request", error);
             return {
                 success: null,
                 failure: {
@@ -1598,7 +1650,7 @@ class FilterCore extends BaseProtocol {
         }
         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}`);
+            log$5.error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
@@ -1618,7 +1670,7 @@ class FilterCore extends BaseProtocol {
             stream = await this.getStream(peer);
         }
         catch (error) {
-            log$6.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
+            log$5.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
             return {
                 success: null,
                 failure: {
@@ -1632,7 +1684,7 @@ class FilterCore extends BaseProtocol {
             await pipe([unsubscribeRequest.encode()], encode, stream.sink);
         }
         catch (error) {
-            log$6.error("Failed to send unsubscribe request", error);
+            log$5.error("Failed to send unsubscribe request", error);
             return {
                 success: null,
                 failure: {
@@ -1661,7 +1713,7 @@ class FilterCore extends BaseProtocol {
         }
         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}`);
+            log$5.error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
@@ -1681,7 +1733,7 @@ class FilterCore extends BaseProtocol {
             stream = await this.getStream(peer);
         }
         catch (error) {
-            log$6.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
+            log$5.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
             return {
                 success: null,
                 failure: {
@@ -1696,7 +1748,7 @@ class FilterCore extends BaseProtocol {
             res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
         }
         catch (error) {
-            log$6.error("Failed to send ping request", error);
+            log$5.error("Failed to send ping request", error);
             return {
                 success: null,
                 failure: {
@@ -1716,7 +1768,7 @@ class FilterCore extends BaseProtocol {
         }
         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}`);
+            log$5.error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             return {
                 success: null,
                 failure: {
@@ -1733,31 +1785,30 @@ class FilterCore extends BaseProtocol {
     onRequest(streamData) {
         const { connection, stream } = streamData;
         const { remotePeer } = connection;
-        log$6.info(`Received message from ${remotePeer.toString()}`);
+        log$5.info(`Received message from ${remotePeer.toString()}`);
         try {
             pipe(stream, decode, async (source) => {
                 for await (const bytes of source) {
                     const response = FilterPushRpc.decode(bytes.slice());
                     const { pubsubTopic, wakuMessage } = response;
                     if (!wakuMessage) {
-                        log$6.error("Received empty message");
+                        log$5.error("Received empty message");
                         return;
                     }
                     if (!pubsubTopic) {
-                        log$6.error("Pubsub topic missing from push message");
+                        log$5.error("Pubsub topic missing from push message");
                         return;
                     }
                     await this.handleIncomingMessage(pubsubTopic, wakuMessage, connection.remotePeer.toString());
                 }
             }).then(() => {
-                log$6.info("Receiving pipe closed.");
+                log$5.info("Receiving pipe closed.");
             }, async (e) => {
-                log$6.error("Error with receiving pipe", e, " -- ", "on peer ", connection.remotePeer.toString(), " -- ", "stream ", stream);
-                await this.handleError(e);
+                log$5.error("Error with receiving pipe", e, " -- ", "on peer ", connection.remotePeer.toString(), " -- ", "stream ", stream);
             });
         }
         catch (e) {
-            log$6.error("Error decoding message", e);
+            log$5.error("Error decoding message", e);
         }
     }
 }
@@ -1823,7 +1874,7 @@ const matchRLNErrorMessage = (info) => {
     return ProtocolError.RLN_PROOF_GENERATION;
 };
 
-const log$5 = new Logger("light-push");
+const log$4 = new Logger("light-push");
 const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 /**
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
@@ -1831,22 +1882,22 @@ const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 class LightPushCore extends BaseProtocol {
     pubsubTopics;
     constructor(pubsubTopics, libp2p) {
-        super(LightPushCodec, libp2p.components, log$5, pubsubTopics);
+        super(LightPushCodec, libp2p.components, log$4, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
     }
     async preparePushMessage(encoder, message) {
         try {
             if (!message.payload || message.payload.length === 0) {
-                log$5.error("Failed to send waku light push: payload is empty");
+                log$4.error("Failed to send waku light push: payload is empty");
                 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");
+                log$4.error("Failed to send waku light push: message is bigger than 1MB");
                 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");
+                log$4.error("Failed to encode to protoMessage, aborting push");
                 return {
                     query: null,
                     error: ProtocolError.ENCODE_FAILED
@@ -1856,7 +1907,7 @@ class LightPushCore extends BaseProtocol {
             return { query, error: null };
         }
         catch (error) {
-            log$5.error("Failed to prepare push message", error);
+            log$4.error("Failed to prepare push message", error);
             return {
                 query: null,
                 error: ProtocolError.GENERIC_FAIL
@@ -1879,7 +1930,7 @@ class LightPushCore extends BaseProtocol {
             stream = await this.getStream(peer);
         }
         catch (error) {
-            log$5.error("Failed to get stream", error);
+            log$4.error("Failed to get stream", error);
             return {
                 success: null,
                 failure: {
@@ -1893,7 +1944,7 @@ class LightPushCore extends BaseProtocol {
             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);
+            log$4.error("Failed to send waku light push request", err);
             return {
                 success: null,
                 failure: {
@@ -1911,7 +1962,7 @@ class LightPushCore extends BaseProtocol {
             response = PushRpc.decode(bytes).response;
         }
         catch (err) {
-            log$5.error("Failed to decode push reply", err);
+            log$4.error("Failed to decode push reply", err);
             return {
                 success: null,
                 failure: {
@@ -1921,7 +1972,7 @@ class LightPushCore extends BaseProtocol {
             };
         }
         if (!response) {
-            log$5.error("Remote peer fault: No response in PushRPC");
+            log$4.error("Remote peer fault: No response in PushRPC");
             return {
                 success: null,
                 failure: {
@@ -1932,7 +1983,7 @@ class LightPushCore extends BaseProtocol {
         }
         if (isRLNResponseError(response.info)) {
             const rlnErrorCase = matchRLNErrorMessage(response.info);
-            log$5.error("Remote peer rejected the message: ", rlnErrorCase);
+            log$4.error("Remote peer rejected the message: ", rlnErrorCase);
             return {
                 success: null,
                 failure: {
@@ -1942,7 +1993,7 @@ class LightPushCore extends BaseProtocol {
             };
         }
         if (!response.isSuccess) {
-            log$5.error("Remote peer rejected the message: ", response.info);
+            log$4.error("Remote peer rejected the message: ", response.info);
             return {
                 success: null,
                 failure: {
@@ -2047,12 +2098,12 @@ class StoreQueryResponse {
     }
 }
 
-const log$4 = new Logger("store");
+const log$3 = new Logger("store");
 const StoreCodec = "/vac/waku/store-query/3.0.0";
 class StoreCore extends BaseProtocol {
     pubsubTopics;
     constructor(pubsubTopics, libp2p) {
-        super(StoreCodec, libp2p.components, log$4, pubsubTopics);
+        super(StoreCodec, libp2p.components, log$3, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
     }
     async *queryPerPage(queryOpts, decoders, peer) {
@@ -2071,7 +2122,7 @@ class StoreCore extends BaseProtocol {
                 stream = await this.getStream(peer);
             }
             catch (e) {
-                log$4.error("Failed to get stream", e);
+                log$3.error("Failed to get stream", e);
                 break;
             }
             const res = await pipe([storeQueryRequest.encode()], encode, stream, decode, async (source) => await all(source));
@@ -2083,14 +2134,14 @@ class StoreCore extends BaseProtocol {
             if (!storeQueryResponse.statusCode ||
                 storeQueryResponse.statusCode >= 300) {
                 const errorMessage = `Store query failed with status code: ${storeQueryResponse.statusCode}, description: ${storeQueryResponse.statusDesc}`;
-                log$4.error(errorMessage);
+                log$3.error(errorMessage);
                 throw new Error(errorMessage);
             }
             if (!storeQueryResponse.messages || !storeQueryResponse.messages.length) {
-                log$4.warn("Stopping pagination due to empty messages in response");
+                log$3.warn("Stopping pagination due to empty messages in response");
                 break;
             }
-            log$4.info(`${storeQueryResponse.messages.length} messages retrieved from store`);
+            log$3.info(`${storeQueryResponse.messages.length} messages retrieved from store`);
             const decodedMessages = storeQueryResponse.messages.map((protoMsg) => {
                 if (!protoMsg.message) {
                     return Promise.resolve(undefined);
@@ -2128,377 +2179,6 @@ var index = /*#__PURE__*/Object.freeze({
     StoreCore: StoreCore
 });
 
-class TimeoutError extends Error {
-	constructor(message) {
-		super(message);
-		this.name = 'TimeoutError';
-	}
-}
-
-/**
-An error to be thrown when the request is aborted by AbortController.
-DOMException is thrown instead of this Error when DOMException is available.
-*/
-class AbortError extends Error {
-	constructor(message) {
-		super();
-		this.name = 'AbortError';
-		this.message = message;
-	}
-}
-
-/**
-TODO: Remove AbortError and just throw DOMException when targeting Node 18.
-*/
-const getDOMException = errorMessage => globalThis.DOMException === undefined
-	? new AbortError(errorMessage)
-	: new DOMException(errorMessage);
-
-/**
-TODO: Remove below function and just 'reject(signal.reason)' when targeting Node 18.
-*/
-const getAbortedReason = signal => {
-	const reason = signal.reason === undefined
-		? getDOMException('This operation was aborted.')
-		: signal.reason;
-
-	return reason instanceof Error ? reason : getDOMException(reason);
-};
-
-function pTimeout(promise, options) {
-	const {
-		milliseconds,
-		fallback,
-		message,
-		customTimers = {setTimeout, clearTimeout},
-	} = options;
-
-	let timer;
-
-	const wrappedPromise = new Promise((resolve, reject) => {
-		if (typeof milliseconds !== 'number' || Math.sign(milliseconds) !== 1) {
-			throw new TypeError(`Expected \`milliseconds\` to be a positive number, got \`${milliseconds}\``);
-		}
-
-		if (options.signal) {
-			const {signal} = options;
-			if (signal.aborted) {
-				reject(getAbortedReason(signal));
-			}
-
-			signal.addEventListener('abort', () => {
-				reject(getAbortedReason(signal));
-			});
-		}
-
-		if (milliseconds === Number.POSITIVE_INFINITY) {
-			promise.then(resolve, reject);
-			return;
-		}
-
-		// We create the error outside of `setTimeout` to preserve the stack trace.
-		const timeoutError = new TimeoutError();
-
-		timer = customTimers.setTimeout.call(undefined, () => {
-			if (fallback) {
-				try {
-					resolve(fallback());
-				} catch (error) {
-					reject(error);
-				}
-
-				return;
-			}
-
-			if (typeof promise.cancel === 'function') {
-				promise.cancel();
-			}
-
-			if (message === false) {
-				resolve();
-			} else if (message instanceof Error) {
-				reject(message);
-			} else {
-				timeoutError.message = message ?? `Promise timed out after ${milliseconds} milliseconds`;
-				reject(timeoutError);
-			}
-		}, milliseconds);
-
-		(async () => {
-			try {
-				resolve(await promise);
-			} catch (error) {
-				reject(error);
-			}
-		})();
-	});
-
-	const cancelablePromise = wrappedPromise.finally(() => {
-		cancelablePromise.clear();
-	});
-
-	cancelablePromise.clear = () => {
-		customTimers.clearTimeout.call(undefined, timer);
-		timer = undefined;
-	};
-
-	return cancelablePromise;
-}
-
-const normalizeEmitter = emitter => {
-	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');
-	}
-
-	return {
-		addListener: addListener.bind(emitter),
-		removeListener: removeListener.bind(emitter),
-	};
-};
-
-function pEventMultiple(emitter, event, options) {
-	let cancel;
-	const returnValue = new Promise((resolve, reject) => {
-		options = {
-			rejectionEvents: ['error'],
-			multiArgs: false,
-			resolveImmediately: false,
-			...options,
-		};
-
-		if (!(options.count >= 0 && (options.count === Number.POSITIVE_INFINITY || Number.isInteger(options.count)))) {
-			throw new TypeError('The `count` option should be at least 0 or more');
-		}
-
-		options.signal?.throwIfAborted();
-
-		// Allow multiple events
-		const events = [event].flat();
-
-		const items = [];
-		const {addListener, removeListener} = normalizeEmitter(emitter);
-
-		const onItem = (...arguments_) => {
-			const value = options.multiArgs ? arguments_ : arguments_[0];
-
-			// eslint-disable-next-line unicorn/no-array-callback-reference
-			if (options.filter && !options.filter(value)) {
-				return;
-			}
-
-			items.push(value);
-
-			if (options.count === items.length) {
-				cancel();
-				resolve(items);
-			}
-		};
-
-		const rejectHandler = error => {
-			cancel();
-			reject(error);
-		};
-
-		cancel = () => {
-			for (const event of events) {
-				removeListener(event, onItem);
-			}
-
-			for (const rejectionEvent of options.rejectionEvents) {
-				removeListener(rejectionEvent, rejectHandler);
-			}
-		};
-
-		for (const event of events) {
-			addListener(event, onItem);
-		}
-
-		for (const rejectionEvent of options.rejectionEvents) {
-			addListener(rejectionEvent, rejectHandler);
-		}
-
-		if (options.signal) {
-			options.signal.addEventListener('abort', () => {
-				rejectHandler(options.signal.reason);
-			}, {once: true});
-		}
-
-		if (options.resolveImmediately) {
-			resolve(items);
-		}
-	});
-
-	returnValue.cancel = cancel;
-
-	if (typeof options.timeout === 'number') {
-		const timeout = pTimeout(returnValue, {milliseconds: options.timeout});
-		timeout.cancel = cancel;
-		return timeout;
-	}
-
-	return returnValue;
-}
-
-function pEvent(emitter, event, options) {
-	if (typeof options === 'function') {
-		options = {filter: options};
-	}
-
-	options = {
-		...options,
-		count: 1,
-		resolveImmediately: false,
-	};
-
-	const arrayPromise = pEventMultiple(emitter, event, options);
-	const promise = arrayPromise.then(array => array[0]);
-	promise.cancel = arrayPromise.cancel;
-
-	return promise;
-}
-
-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
- * {@link @waku/sdk!WakuNode.dial} or a bootstrap method with
- * {@link @waku/sdk!createLightNode}.
- *
- * If the passed protocols is a GossipSub protocol, then it resolves only once
- * a peer is in a mesh, to help ensure that other peers will send and receive
- * message to us.
- *
- * @param waku The Waku Node
- * @param protocols The protocols that need to be enabled by remote peers.
- * @param timeoutMs A timeout value in milliseconds..
- *
- * @returns A promise that **resolves** if all desired protocols are fulfilled by
- * remote nodes, **rejects** if the timeoutMs is reached.
- * @throws If passing a protocol that is not mounted
- * @default Wait for remote peers with protocols enabled locally and no time out is applied.
- */
-async function waitForRemotePeer(waku, protocols, timeoutMs) {
-    protocols = protocols ?? getEnabledProtocols(waku);
-    if (!waku.isStarted())
-        return Promise.reject("Waku node is not started");
-    const promises = [];
-    if (protocols.includes(Protocols.Relay)) {
-        if (!waku.relay)
-            throw new Error("Cannot wait for Relay peer: protocol not mounted");
-        promises.push(waitForGossipSubPeerInMesh(waku.relay));
-    }
-    if (protocols.includes(Protocols.Store)) {
-        if (!waku.store)
-            throw new Error("Cannot wait for Store peer: protocol not mounted");
-        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.protocol, waku.libp2p.services.metadata));
-    }
-    if (protocols.includes(Protocols.Filter)) {
-        if (!waku.filter)
-            throw new Error("Cannot wait for Filter peer: protocol not mounted");
-        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.");
-    }
-    else {
-        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.
- */
-async function waitForConnectedPeer(protocol, metadataService) {
-    const codec = protocol.multicodec;
-    const peers = await protocol.connectedPeers();
-    if (peers.length) {
-        if (!metadataService) {
-            log$3.info(`${codec} peer found: `, peers[0].id.toString());
-            return;
-        }
-        // once a peer is connected, we need to confirm the metadata handshake with at least one of those peers if sharding is enabled
-        try {
-            await Promise.any(peers.map((peer) => metadataService.confirmOrAttemptHandshake(peer.id)));
-            return;
-        }
-        catch (e) {
-            if (e.code === "ERR_CONNECTION_BEING_CLOSED")
-                log$3.error(`Connection with the peer was closed and possibly because it's on a different shard. Error: ${e}`);
-            log$3.error(`Error waiting for handshake confirmation: ${e}`);
-        }
-    }
-    log$3.info(`Waiting for ${codec} peer`);
-    // else we'll just wait for the next peer to connect
-    await new Promise((resolve) => {
-        const cb = (evt) => {
-            if (evt.detail?.protocols?.includes(codec)) {
-                if (metadataService) {
-                    metadataService
-                        .confirmOrAttemptHandshake(evt.detail.peerId)
-                        .then(() => {
-                        protocol.removeLibp2pEventListener("peer:identify", cb);
-                        resolve();
-                    })
-                        .catch((e) => {
-                        if (e.code === "ERR_CONNECTION_BEING_CLOSED")
-                            log$3.error(`Connection with the peer was closed and possibly because it's on a different shard. Error: ${e}`);
-                        log$3.error(`Error waiting for handshake confirmation: ${e}`);
-                    });
-                }
-                else {
-                    protocol.removeLibp2pEventListener("peer:identify", cb);
-                    resolve();
-                }
-            }
-        };
-        protocol.addLibp2pEventListener("peer:identify", cb);
-    });
-}
-/**
- * Wait for at least one peer with the given protocol to be connected and in the gossipsub
- * mesh for all pubsubTopics.
- */
-async function waitForGossipSubPeerInMesh(waku) {
-    let peers = waku.getMeshPeers();
-    const pubsubTopics = waku.pubsubTopics;
-    for (const topic of pubsubTopics) {
-        while (peers.length == 0) {
-            await pEvent(waku.gossipSub, "gossipsub:heartbeat");
-            peers = waku.getMeshPeers(topic);
-        }
-    }
-}
-const awaitTimeout = (ms, rejectReason) => new Promise((_resolve, reject) => setTimeout(() => reject(rejectReason), ms));
-async function rejectOnTimeout(promise, timeoutMs, rejectReason) {
-    await Promise.race([promise, awaitTimeout(timeoutMs, rejectReason)]);
-}
-function getEnabledProtocols(waku) {
-    const protocols = [];
-    if (waku.relay) {
-        protocols.push(Protocols.Relay);
-    }
-    if (waku.filter) {
-        protocols.push(Protocols.Filter);
-    }
-    if (waku.store) {
-        protocols.push(Protocols.Store);
-    }
-    if (waku.lightPush) {
-        protocols.push(Protocols.LightPush);
-    }
-    return protocols;
-}
-
 /** Noop for browser compatibility */
 function setMaxListeners$1() { }
 
@@ -3208,7 +2888,7 @@ class Metadata extends BaseProtocol {
      */
     async query(peerId) {
         const request = WakuMetadataRequest.encode(pubsubTopicsToShardInfo(this.pubsubTopics));
-        const peer = await this.peerStore.get(peerId);
+        const peer = await this.libp2pComponents.peerStore.get(peerId);
         if (!peer) {
             return {
                 shardInfo: null,
@@ -3300,4 +2980,4 @@ function wakuMetadata(pubsubTopics) {
     return (components) => new Metadata(pubsubTopics, components);
 }
 
-export { ConnectionManager, FilterCodecs, FilterCore, KeepAliveManager, LightPushCodec, LightPushCore, MetadataCodec, StoreCore, createEncoder, getHealthManager, index$3 as message, waitForRemotePeer, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };
+export { ConnectionManager, FilterCodecs, FilterCore, KeepAliveManager, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, createEncoder, getHealthManager, index$3 as message, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };