@waku/core 0.0.31-ce62600.0 → 0.0.31

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, H as HistoryRpc$1, f as PagingInfo, g as HistoryResponse, h as createEncoder, W as WakuMetadataResponse, i as WakuMetadataRequest } from './version_0-DQ9xsSLk.js';
-export { j as createDecoder } from './version_0-DQ9xsSLk.js';
-import { a as allocUnsafe, b as alloc, g as getDefaultExportFromCjs, L as Logger, P as ProtocolError, c as Protocols, u as utf8ToBytes, p as pubsubTopicToSingleShardInfo, E as EConnectionStateEvents, T as Tags, d as EPeersByDiscoveryEvents, s as shardInfoToPubsubTopics } from './index-DnW8ifxc.js';
-import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-C6HnrRx8.js';
-export { S as StreamManager } from './base_protocol-C6HnrRx8.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, 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-C47QkJ2o.js';
+export { S as StreamManager } from './base_protocol-C47QkJ2o.js';
 
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
@@ -743,74 +743,35 @@ encode.single = (chunk, options) => {
 };
 
 /**
- * @typedef {{ [key: string]: any }} Extensions
- * @typedef {Error} Err
- * @property {string} message
+ * The reported length of the next data message was not a positive integer
  */
-
+class InvalidMessageLengthError extends Error {
+    name = 'InvalidMessageLengthError';
+    code = 'ERR_INVALID_MSG_LENGTH';
+}
 /**
- *
- * @param {Error} obj
- * @param {Extensions} props
- * @returns {Error & Extensions}
+ * The reported length of the next data message was larger than the configured
+ * max allowable value
  */
-function assign(obj, props) {
-    for (const key in props) {
-        Object.defineProperty(obj, key, {
-            value: props[key],
-            enumerable: true,
-            configurable: true,
-        });
-    }
-
-    return obj;
+class InvalidDataLengthError extends Error {
+    name = 'InvalidDataLengthError';
+    code = 'ERR_MSG_DATA_TOO_LONG';
 }
-
 /**
- *
- * @param {any} err - An Error
- * @param {string|Extensions} code - A string code or props to set on the error
- * @param {Extensions} [props] - Props to set on the error
- * @returns {Error & Extensions}
+ * The varint used to specify the length of the next data message contained more
+ * bytes than the configured max allowable value
  */
-function createError(err, code, props) {
-    if (!err || typeof err === 'string') {
-        throw new TypeError('Please pass an Error to err-code');
-    }
-
-    if (!props) {
-        props = {};
-    }
-
-    if (typeof code === 'object') {
-        props = code;
-        code = '';
-    }
-
-    if (code) {
-        props.code = code;
-    }
-
-    try {
-        return assign(err, props);
-    } catch (_) {
-        props.message = err.message;
-        props.stack = err.stack;
-
-        const ErrClass = function () {};
-
-        ErrClass.prototype = Object.create(Object.getPrototypeOf(err));
-
-        // @ts-ignore
-        const output = assign(new ErrClass(), props);
-
-        return output;
-    }
+class InvalidDataLengthLengthError extends Error {
+    name = 'InvalidDataLengthLengthError';
+    code = 'ERR_MSG_LENGTH_TOO_LONG';
+}
+/**
+ * The incoming stream ended before the expected number of bytes were read
+ */
+class UnexpectedEOFError extends Error {
+    name = 'UnexpectedEOFError';
+    code = 'ERR_UNEXPECTED_EOF';
 }
-
-var errCode = createError;
-
-var errCode$1 = /*@__PURE__*/getDefaultExportFromCjs(errCode);
 
 /* eslint max-depth: ["error", 6] */
 // Maximum length of the length section of the message
@@ -842,10 +803,10 @@ function decode(source, options) {
                 try {
                     dataLength = lengthDecoder(buffer);
                     if (dataLength < 0) {
-                        throw errCode$1(new Error('invalid message length'), 'ERR_INVALID_MSG_LENGTH');
+                        throw new InvalidMessageLengthError('Invalid message length');
                     }
                     if (dataLength > maxDataLength) {
-                        throw errCode$1(new Error('message length too long'), 'ERR_MSG_DATA_TOO_LONG');
+                        throw new InvalidDataLengthError('Message length too long');
                     }
                     const dataLengthLength = lengthDecoder.bytes;
                     buffer.consume(dataLengthLength);
@@ -857,7 +818,7 @@ function decode(source, options) {
                 catch (err) {
                     if (err instanceof RangeError) {
                         if (buffer.byteLength > maxLengthLength) {
-                            throw errCode$1(new Error('message length length too long'), 'ERR_MSG_LENGTH_TOO_LONG');
+                            throw new InvalidDataLengthLengthError('Message length length too long');
                         }
                         break;
                     }
@@ -886,7 +847,7 @@ function decode(source, options) {
                 yield* maybeYield();
             }
             if (buffer.byteLength > 0) {
-                throw errCode$1(new Error('unexpected end of input'), 'ERR_UNEXPECTED_EOF');
+                throw new UnexpectedEOFError('Unexpected end of input');
             }
         })();
     }
@@ -896,7 +857,7 @@ function decode(source, options) {
             yield* maybeYield();
         }
         if (buffer.byteLength > 0) {
-            throw errCode$1(new Error('unexpected end of input'), 'ERR_UNEXPECTED_EOF');
+            throw new UnexpectedEOFError('Unexpected end of input');
         }
     })();
 }
@@ -1484,16 +1445,6 @@ function v4(options, buf, offset) {
   rnds[6] = rnds[6] & 0x0f | 0x40;
   rnds[8] = rnds[8] & 0x3f | 0x80; // Copy bytes to buffer, if provided
 
-  if (buf) {
-    offset = offset || 0;
-
-    for (let i = 0; i < 16; ++i) {
-      buf[offset + i] = rnds[i];
-    }
-
-    return buf;
-  }
-
   return unsafeStringify(rnds);
 }
 
@@ -1611,9 +1562,11 @@ const FilterCodecs = {
 };
 class FilterCore extends BaseProtocol {
     handleIncomingMessage;
-    constructor(handleIncomingMessage, libp2p, options) {
-        super(FilterCodecs.SUBSCRIBE, libp2p.components, log$6, options.pubsubTopics, options);
+    pubsubTopics;
+    constructor(handleIncomingMessage, pubsubTopics, libp2p) {
+        super(FilterCodecs.SUBSCRIBE, libp2p.components, log$6, pubsubTopics);
         this.handleIncomingMessage = handleIncomingMessage;
+        this.pubsubTopics = pubsubTopics;
         libp2p
             .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
             maxInboundStreams: 100
@@ -1622,35 +1575,6 @@ class FilterCore extends BaseProtocol {
             log$6.error("Failed to register ", FilterCodecs.PUSH, e);
         });
     }
-    onRequest(streamData) {
-        const { connection, stream } = streamData;
-        const { remotePeer } = connection;
-        log$6.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");
-                        return;
-                    }
-                    if (!pubsubTopic) {
-                        log$6.error("Pubsub topic missing from push message");
-                        return;
-                    }
-                    await this.handleIncomingMessage(pubsubTopic, wakuMessage);
-                }
-            }).then(() => {
-                log$6.info("Receiving pipe closed.");
-            }, (e) => {
-                log$6.error("Error with receiving pipe", e);
-            });
-        }
-        catch (e) {
-            log$6.error("Error decoding message", e);
-        }
-    }
     async subscribe(pubsubTopic, peer, contentTopics) {
         const stream = await this.getStream(peer);
         const request = FilterSubscribeRpc.createSubscribeRequest(pubsubTopic, contentTopics);
@@ -1694,7 +1618,7 @@ class FilterCore extends BaseProtocol {
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    error: ProtocolError.NO_STREAM_AVAILABLE,
                     peerId: peer.id
                 }
             };
@@ -1725,7 +1649,7 @@ class FilterCore extends BaseProtocol {
         if (!res || !res.length) {
             return {
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    error: ProtocolError.NO_RESPONSE,
                     peerId: peer.id
                 },
                 success: null
@@ -1757,7 +1681,7 @@ class FilterCore extends BaseProtocol {
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    error: ProtocolError.NO_STREAM_AVAILABLE,
                     peerId: peer.id
                 }
             };
@@ -1781,7 +1705,7 @@ class FilterCore extends BaseProtocol {
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    error: ProtocolError.NO_RESPONSE,
                     peerId: peer.id
                 }
             };
@@ -1802,6 +1726,35 @@ class FilterCore extends BaseProtocol {
             failure: null
         };
     }
+    onRequest(streamData) {
+        const { connection, stream } = streamData;
+        const { remotePeer } = connection;
+        log$6.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");
+                        return;
+                    }
+                    if (!pubsubTopic) {
+                        log$6.error("Pubsub topic missing from push message");
+                        return;
+                    }
+                    await this.handleIncomingMessage(pubsubTopic, wakuMessage, connection.remotePeer.toString());
+                }
+            }).then(() => {
+                log$6.info("Receiving pipe closed.");
+            }, (e) => {
+                log$6.error("Error with receiving pipe", e);
+            });
+        }
+        catch (e) {
+            log$6.error("Error decoding message", e);
+        }
+    }
 }
 
 var index$2 = /*#__PURE__*/Object.freeze({
@@ -1840,14 +1793,41 @@ class PushRpc {
     }
 }
 
+// should match nwaku
+// https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/waku/waku_rln_relay/rln_relay.nim#L309
+// https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/tests/waku_rln_relay/rln/waku_rln_relay_utils.nim#L20
+const RLN_GENERATION_PREFIX_ERROR = "could not generate rln-v2 proof";
+const isRLNResponseError = (info) => {
+    if (!info) {
+        return false;
+    }
+    return info.includes(RLN_GENERATION_PREFIX_ERROR);
+};
+const matchRLNErrorMessage = (info) => {
+    const rlnErrorMap = {
+        [ProtocolError.RLN_IDENTITY_MISSING]: ProtocolError.RLN_IDENTITY_MISSING,
+        [ProtocolError.RLN_MEMBERSHIP_INDEX]: ProtocolError.RLN_MEMBERSHIP_INDEX,
+        [ProtocolError.RLN_LIMIT_MISSING]: ProtocolError.RLN_LIMIT_MISSING
+    };
+    const infoLowerCase = info.toLowerCase();
+    for (const errorKey in rlnErrorMap) {
+        if (infoLowerCase.includes(errorKey.toLowerCase())) {
+            return rlnErrorMap[errorKey];
+        }
+    }
+    return ProtocolError.RLN_PROOF_GENERATION;
+};
+
 const log$5 = 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/).
  */
 class LightPushCore extends BaseProtocol {
-    constructor(libp2p, options) {
-        super(LightPushCodec, libp2p.components, log$5, options.pubsubTopics, options);
+    pubsubTopics;
+    constructor(pubsubTopics, libp2p) {
+        super(LightPushCodec, libp2p.components, log$5, pubsubTopics);
+        this.pubsubTopics = pubsubTopics;
     }
     async preparePushMessage(encoder, message) {
         try {
@@ -1940,7 +1920,18 @@ class LightPushCore extends BaseProtocol {
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.REMOTE_PEER_FAULT,
+                    error: ProtocolError.NO_RESPONSE,
+                    peerId: peer.id
+                }
+            };
+        }
+        if (isRLNResponseError(response.info)) {
+            const rlnErrorCase = matchRLNErrorMessage(response.info);
+            log$5.error("Remote peer rejected the message: ", rlnErrorCase);
+            return {
+                success: null,
+                failure: {
+                    error: rlnErrorCase,
                     peerId: peer.id
                 }
             };
@@ -1979,97 +1970,97 @@ function toProtoMessage(wire) {
     return { ...EmptyMessage, ...wire };
 }
 
-const OneMillion = BigInt(1_000_000);
-var PageDirection;
-(function (PageDirection) {
-    PageDirection["BACKWARD"] = "backward";
-    PageDirection["FORWARD"] = "forward";
-})(PageDirection || (PageDirection = {}));
-class HistoryRpc {
+// https://github.com/waku-org/nwaku/blob/7205f95cff9f49ca0bb762e8fd0bf56a6a7f3b3b/waku/waku_store/common.nim#L12
+const DEFAULT_PAGE_SIZE = 20;
+const MAX_PAGE_SIZE = 100;
+const ONE_MILLION = 1_000000;
+class StoreQueryRequest {
     proto;
     constructor(proto) {
         this.proto = proto;
     }
-    get query() {
-        return this.proto.query;
-    }
-    get response() {
-        return this.proto.response;
-    }
-    /**
-     * Create History Query.
-     */
-    static createQuery(params) {
-        const contentFilters = params.contentTopics.map((contentTopic) => {
-            return { contentTopic };
+    static create(params) {
+        const request = new StoreQueryRequest({
+            ...params,
+            requestId: v4(),
+            timeStart: params.timeStart
+                ? BigInt(params.timeStart.getTime() * ONE_MILLION)
+                : undefined,
+            timeEnd: params.timeEnd
+                ? BigInt(params.timeEnd.getTime() * ONE_MILLION)
+                : undefined,
+            messageHashes: params.messageHashes || [],
+            paginationLimit: params.paginationLimit
+                ? BigInt(params.paginationLimit)
+                : undefined
         });
-        const direction = directionToProto(params.pageDirection);
-        const pagingInfo = {
-            pageSize: BigInt(params.pageSize),
-            cursor: params.cursor,
-            direction
-        };
-        let startTime, endTime;
-        if (params.startTime) {
-            // milliseconds 10^-3 to nanoseconds 10^-9
-            startTime = BigInt(params.startTime.valueOf()) * OneMillion;
+        // Validate request parameters based on RFC
+        if ((params.pubsubTopic && !params.contentTopics) ||
+            (!params.pubsubTopic && params.contentTopics)) {
+            throw new Error("Both pubsubTopic and contentTopics must be set or unset");
         }
-        if (params.endTime) {
-            // milliseconds 10^-3 to nanoseconds 10^-9
-            endTime = BigInt(params.endTime.valueOf()) * OneMillion;
+        if (params.messageHashes &&
+            (params.pubsubTopic ||
+                params.contentTopics ||
+                params.timeStart ||
+                params.timeEnd)) {
+            throw new Error("Message hash lookup queries cannot include content filter criteria");
         }
-        return new HistoryRpc({
-            requestId: v4(),
-            query: {
-                pubsubTopic: params.pubsubTopic,
-                contentFilters,
-                pagingInfo,
-                startTime,
-                endTime
-            },
-            response: undefined
-        });
+        return request;
     }
-    decode(bytes) {
-        const res = HistoryRpc$1.decode(bytes);
-        return new HistoryRpc(res);
+    static decode(bytes) {
+        const res = StoreQueryRequest$1.decode(bytes);
+        return new StoreQueryRequest(res);
     }
     encode() {
-        return HistoryRpc$1.encode(this.proto);
+        return StoreQueryRequest$1.encode(this.proto);
     }
 }
-function directionToProto(pageDirection) {
-    switch (pageDirection) {
-        case PageDirection.BACKWARD:
-            return PagingInfo.Direction.BACKWARD;
-        case PageDirection.FORWARD:
-            return PagingInfo.Direction.FORWARD;
-        default:
-            return PagingInfo.Direction.BACKWARD;
+class StoreQueryResponse {
+    proto;
+    constructor(proto) {
+        this.proto = proto;
+    }
+    static decode(bytes) {
+        const res = StoreQueryResponse$1.decode(bytes);
+        return new StoreQueryResponse(res);
+    }
+    encode() {
+        return StoreQueryResponse$1.encode(this.proto);
+    }
+    get statusCode() {
+        return this.proto.statusCode;
+    }
+    get statusDesc() {
+        return this.proto.statusDesc;
+    }
+    get messages() {
+        return this.proto.messages;
+    }
+    get paginationCursor() {
+        return this.proto.paginationCursor;
     }
 }
 
-var HistoryError = HistoryResponse.HistoryError;
 const log$4 = new Logger("store");
-const StoreCodec = "/vac/waku/store/2.0.0-beta4";
-/**
- * Implements the [Waku v2 Store protocol](https://rfc.vac.dev/spec/13/).
- *
- * The Waku Store protocol can be used to retrieved historical messages.
- */
+const StoreCodec = "/vac/waku/store-query/3.0.0";
 class StoreCore extends BaseProtocol {
-    constructor(libp2p, options) {
-        super(StoreCodec, libp2p.components, log$4, options.pubsubTopics, options);
+    pubsubTopics;
+    constructor(pubsubTopics, libp2p) {
+        super(StoreCodec, libp2p.components, log$4, pubsubTopics);
+        this.pubsubTopics = pubsubTopics;
     }
     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");
         }
-        let currentCursor = queryOpts.cursor;
+        let currentCursor = queryOpts.paginationCursor;
         while (true) {
-            queryOpts.cursor = currentCursor;
-            const historyRpcQuery = HistoryRpc.createQuery(queryOpts);
+            const storeQueryRequest = StoreQueryRequest.create({
+                ...queryOpts,
+                paginationCursor: currentCursor
+            });
             let stream;
             try {
                 stream = await this.getStream(peer);
@@ -2078,50 +2069,48 @@ class StoreCore extends BaseProtocol {
                 log$4.error("Failed to get stream", e);
                 break;
             }
-            const res = await pipe([historyRpcQuery.encode()], encode, stream, decode, async (source) => await all(source));
+            const res = await pipe([storeQueryRequest.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");
+            const storeQueryResponse = StoreQueryResponse.decode(bytes);
+            if (!storeQueryResponse.statusCode ||
+                storeQueryResponse.statusCode >= 300) {
+                const errorMessage = `Store query failed with status code: ${storeQueryResponse.statusCode}, description: ${storeQueryResponse.statusDesc}`;
+                log$4.error(errorMessage);
+                throw new Error(errorMessage);
+            }
+            if (!storeQueryResponse.messages || !storeQueryResponse.messages.length) {
+                log$4.warn("Stopping pagination due to empty messages in response");
                 break;
             }
-            log$4.error(`${response.messages.length} messages retrieved from store`);
-            yield response.messages.map((protoMsg) => {
-                const contentTopic = protoMsg.contentTopic;
-                if (typeof contentTopic !== "undefined") {
+            log$4.info(`${storeQueryResponse.messages.length} messages retrieved from store`);
+            const decodedMessages = storeQueryResponse.messages.map((protoMsg) => {
+                if (!protoMsg.message) {
+                    return Promise.resolve(undefined);
+                }
+                const contentTopic = protoMsg.message.contentTopic;
+                if (contentTopic) {
                     const decoder = decoders.get(contentTopic);
                     if (decoder) {
-                        return decoder.fromProtoObj(queryOpts.pubsubTopic, toProtoMessage(protoMsg));
+                        return decoder.fromProtoObj(protoMsg.pubsubTopic || "", toProtoMessage(protoMsg.message));
                     }
                 }
                 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;
+            yield decodedMessages;
+            if (queryOpts.paginationForward) {
+                currentCursor =
+                    storeQueryResponse.messages[storeQueryResponse.messages.length - 1]
+                        .messageHash;
             }
-            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) {
+            else {
+                currentCursor = storeQueryResponse.messages[0].messageHash;
+            }
+            if (storeQueryResponse.messages.length > MAX_PAGE_SIZE &&
+                storeQueryResponse.messages.length <
+                    (queryOpts.paginationLimit || DEFAULT_PAGE_SIZE)) {
                 break;
             }
         }
@@ -2130,7 +2119,6 @@ class StoreCore extends BaseProtocol {
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    get PageDirection () { return PageDirection; },
     StoreCodec: StoreCodec,
     StoreCore: StoreCore
 });
@@ -2573,38 +2561,22 @@ class TypedEventEmitter extends EventTarget {
         return this.dispatchEvent(new CustomEvent(type, detail));
     }
 }
-/**
- * CustomEvent is a standard event but it's not supported by node.
- *
- * Remove this when https://github.com/nodejs/node/issues/40678 is closed.
- *
- * Ref: https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent
- */
-class CustomEventPolyfill extends Event {
-    /** Returns any custom data event was created with. Typically used for synthetic events. */
-    detail;
-    constructor(message, data) {
-        super(message, data);
-        // @ts-expect-error could be undefined
-        this.detail = data?.detail;
-    }
-}
-const CustomEvent = globalThis.CustomEvent ?? CustomEventPolyfill;
+const CustomEvent = globalThis.CustomEvent;
 
 const RelayPingContentTopic = "/relay-ping/1/ping/null";
 const log$2 = new Logger("keep-alive");
 class KeepAliveManager {
-    pingKeepAliveTimers;
-    relayKeepAliveTimers;
-    options;
     relay;
-    constructor(options, relay) {
-        this.pingKeepAliveTimers = new Map();
-        this.relayKeepAliveTimers = new Map();
+    libp2p;
+    options;
+    pingKeepAliveTimers = new Map();
+    relayKeepAliveTimers = new Map();
+    constructor({ options, relay, libp2p }) {
         this.options = options;
         this.relay = relay;
+        this.libp2p = libp2p;
     }
-    start(peerId, libp2pPing, peerStore) {
+    start(peerId) {
         // Just in case a timer already exists for this peer
         this.stop(peerId);
         const { pingKeepAlive: pingPeriodSecs, relayKeepAlive: relayPeriodSecs } = this.options;
@@ -2619,7 +2591,7 @@ class KeepAliveManager {
                         // ping the peer for keep alive
                         // also update the peer store with the latency
                         try {
-                            ping = await libp2pPing.ping(peerId);
+                            ping = await this.libp2p.services.ping.ping(peerId);
                             log$2.info(`Ping succeeded (${peerIdStr})`, ping);
                         }
                         catch (error) {
@@ -2629,7 +2601,7 @@ class KeepAliveManager {
                             return;
                         }
                         try {
-                            await peerStore.merge(peerId, {
+                            await this.libp2p.peerStore.merge(peerId, {
                                 metadata: {
                                     ping: utf8ToBytes(ping.toString())
                                 }
@@ -2714,25 +2686,12 @@ class ConnectionManager extends TypedEventEmitter {
     dialErrorsForPeer = new Map();
     currentActiveParallelDialCount = 0;
     pendingPeerDialQueue = [];
-    online = false;
+    isP2PNetworkConnected = false;
     isConnected() {
-        return this.online;
-    }
-    toggleOnline() {
-        if (!this.online) {
-            this.online = true;
-            this.dispatchEvent(new CustomEvent(EConnectionStateEvents.CONNECTION_STATUS, {
-                detail: this.online
-            }));
-        }
-    }
-    toggleOffline() {
-        if (this.online && this.libp2p.getConnections().length == 0) {
-            this.online = false;
-            this.dispatchEvent(new CustomEvent(EConnectionStateEvents.CONNECTION_STATUS, {
-                detail: this.online
-            }));
+        if (globalThis?.navigator && !globalThis?.navigator?.onLine) {
+            return false;
         }
+        return this.isP2PNetworkConnected;
     }
     static create(peerId, libp2p, keepAliveOptions, pubsubTopics, relay, options) {
         let instance = ConnectionManager.instances.get(peerId);
@@ -2747,6 +2706,7 @@ class ConnectionManager extends TypedEventEmitter {
         this.libp2p.removeEventListener("peer:connect", this.onEventHandlers["peer:connect"]);
         this.libp2p.removeEventListener("peer:disconnect", this.onEventHandlers["peer:disconnect"]);
         this.libp2p.removeEventListener("peer:discovery", this.onEventHandlers["peer:discovery"]);
+        this.stopNetworkStatusListener();
     }
     async dropConnection(peerId) {
         try {
@@ -2818,8 +2778,12 @@ class ConnectionManager extends TypedEventEmitter {
             maxParallelDials: DEFAULT_MAX_PARALLEL_DIALS,
             ...options
         };
-        this.keepAliveManager = new KeepAliveManager(keepAliveOptions, relay);
-        this.run()
+        this.keepAliveManager = new KeepAliveManager({
+            relay,
+            libp2p,
+            options: keepAliveOptions
+        });
+        this.startEventListeners()
             .then(() => log$1.info(`Connection Manager is now running`))
             .catch((error) => log$1.error(`Unexpected error while running service`, error));
         // libp2p emits `peer:discovery` events during its initialization
@@ -2842,11 +2806,11 @@ class ConnectionManager extends TypedEventEmitter {
             log$1.error(`Unexpected error while dialing peer store peers`, error);
         }
     }
-    async run() {
-        // start event listeners
+    async startEventListeners() {
         this.startPeerDiscoveryListener();
         this.startPeerConnectionListener();
         this.startPeerDisconnectionListener();
+        this.startNetworkStatusListener();
     }
     async dialPeer(peerId) {
         this.currentActiveParallelDialCount += 1;
@@ -2865,6 +2829,7 @@ class ConnectionManager extends TypedEventEmitter {
                 // this helps us keep track of peers that have been dialed before
                 this.dialAttemptsForPeer.set(peerId.toString(), -1);
                 // Dialing succeeded, break the loop
+                this.keepAliveManager.start(peerId);
                 break;
             }
             catch (error) {
@@ -2953,9 +2918,7 @@ class ConnectionManager extends TypedEventEmitter {
             this.pendingPeerDialQueue.push(peerId);
             return;
         }
-        this.dialPeer(peerId).catch((err) => {
-            log$1.error(`Error dialing peer ${peerId.toString()} : ${err}`);
-        });
+        await this.dialPeer(peerId);
     }
     onEventHandlers = {
         "peer:discovery": (evt) => {
@@ -2974,7 +2937,7 @@ class ConnectionManager extends TypedEventEmitter {
             void (async () => {
                 log$1.info(`Connected to peer ${evt.detail.toString()}`);
                 const peerId = evt.detail;
-                this.keepAliveManager.start(peerId, this.libp2p.services.ping, this.libp2p.peerStore);
+                this.keepAliveManager.start(peerId);
                 const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(Tags.BOOTSTRAP);
                 if (isBootstrap) {
                     const bootstrapConnections = this.libp2p
@@ -2995,14 +2958,17 @@ class ConnectionManager extends TypedEventEmitter {
                         detail: peerId
                     }));
                 }
-                this.toggleOnline();
+                this.setP2PNetworkConnected();
             })();
         },
         "peer:disconnect": (evt) => {
             void (async () => {
                 this.keepAliveManager.stop(evt.detail);
-                this.toggleOffline();
+                this.setP2PNetworkDisconnected();
             })();
+        },
+        "browser:network": () => {
+            this.dispatchWakuConnectionEvent();
         }
     };
     /**
@@ -3014,26 +2980,25 @@ class ConnectionManager extends TypedEventEmitter {
      * @returns true if the peer should be dialed, false otherwise
      */
     async shouldDialPeer(peerId) {
-        // if we're already connected to the peer, don't dial
         const isConnected = this.libp2p.getConnections(peerId).length > 0;
         if (isConnected) {
             log$1.warn(`Already connected to peer ${peerId.toString()}. Not dialing.`);
             return false;
         }
-        // if the peer is not part of any of the configured pubsub topics, don't dial
-        if (!(await this.isPeerTopicConfigured(peerId))) {
+        const isSameShard = await this.isPeerTopicConfigured(peerId);
+        if (!isSameShard) {
             const shardInfo = await this.getPeerShardInfo(peerId, this.libp2p.peerStore);
             log$1.warn(`Discovered peer ${peerId.toString()} with ShardInfo ${shardInfo} is not part of any of the configured pubsub topics (${this.configuredPubsubTopics}).
             Not dialing.`);
             return false;
         }
-        // if the peer is not dialable based on bootstrap status, don't dial
-        if (!(await this.isPeerDialableBasedOnBootstrapStatus(peerId))) {
+        const isPreferredBasedOnBootstrap = await this.isPeerDialableBasedOnBootstrapStatus(peerId);
+        if (!isPreferredBasedOnBootstrap) {
             log$1.warn(`Peer ${peerId.toString()} is not dialable based on bootstrap status. Not dialing.`);
             return false;
         }
-        // If the peer is already already has an active dial attempt, or has been dialed before, don't dial it
-        if (this.dialAttemptsForPeer.has(peerId.toString())) {
+        const hasBeenDialed = this.dialAttemptsForPeer.has(peerId.toString());
+        if (hasBeenDialed) {
             log$1.warn(`Peer ${peerId.toString()} has already been attempted dial before, or already has a dial attempt in progress, skipping dial`);
             return false;
         }
@@ -3047,19 +3012,15 @@ class ConnectionManager extends TypedEventEmitter {
     async isPeerDialableBasedOnBootstrapStatus(peerId) {
         const tagNames = await this.getTagNamesForPeer(peerId);
         const isBootstrap = tagNames.some((tagName) => tagName === Tags.BOOTSTRAP);
-        if (isBootstrap) {
-            const currentBootstrapConnections = this.libp2p
-                .getConnections()
-                .filter((conn) => {
-                return conn.tags.find((name) => name === Tags.BOOTSTRAP);
-            }).length;
-            if (currentBootstrapConnections < this.options.maxBootstrapPeersAllowed)
-                return true;
-        }
-        else {
+        if (!isBootstrap) {
             return true;
         }
-        return false;
+        const currentBootstrapConnections = this.libp2p
+            .getConnections()
+            .filter((conn) => {
+            return conn.tags.find((name) => name === Tags.BOOTSTRAP);
+        }).length;
+        return currentBootstrapConnections < this.options.maxBootstrapPeersAllowed;
     }
     async dispatchDiscoveryEvent(peerId) {
         const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(Tags.BOOTSTRAP);
@@ -3098,45 +3059,132 @@ class ConnectionManager extends TypedEventEmitter {
             return undefined;
         return decodeRelayShard(shardInfoBytes);
     }
+    startNetworkStatusListener() {
+        try {
+            globalThis.addEventListener("online", this.onEventHandlers["browser:network"]);
+            globalThis.addEventListener("offline", this.onEventHandlers["browser:network"]);
+        }
+        catch (err) {
+            log$1.error(`Failed to start network listener: ${err}`);
+        }
+    }
+    stopNetworkStatusListener() {
+        try {
+            globalThis.removeEventListener("online", this.onEventHandlers["browser:network"]);
+            globalThis.removeEventListener("offline", this.onEventHandlers["browser:network"]);
+        }
+        catch (err) {
+            log$1.error(`Failed to stop network listener: ${err}`);
+        }
+    }
+    setP2PNetworkConnected() {
+        if (!this.isP2PNetworkConnected) {
+            this.isP2PNetworkConnected = true;
+            this.dispatchWakuConnectionEvent();
+        }
+    }
+    setP2PNetworkDisconnected() {
+        if (this.isP2PNetworkConnected &&
+            this.libp2p.getConnections().length === 0) {
+            this.isP2PNetworkConnected = false;
+            this.dispatchWakuConnectionEvent();
+        }
+    }
+    dispatchWakuConnectionEvent() {
+        this.dispatchEvent(new CustomEvent(EConnectionStateEvents.CONNECTION_STATUS, {
+            detail: this.isConnected()
+        }));
+    }
+}
+
+class HealthManager {
+    static instance;
+    health;
+    constructor() {
+        this.health = {
+            overallStatus: HealthStatus.Unhealthy,
+            protocolStatuses: new Map()
+        };
+    }
+    static getInstance() {
+        if (!HealthManager.instance) {
+            HealthManager.instance = new HealthManager();
+        }
+        return HealthManager.instance;
+    }
+    getHealthStatus() {
+        return this.health.overallStatus;
+    }
+    getProtocolStatus(protocol) {
+        return this.health.protocolStatuses.get(protocol);
+    }
+    updateProtocolHealth(multicodec, connectedPeers) {
+        const protocol = this.getNameFromMulticodec(multicodec);
+        let status = HealthStatus.Unhealthy;
+        if (connectedPeers == 1) {
+            status = HealthStatus.MinimallyHealthy;
+        }
+        else if (connectedPeers >= 2) {
+            status = HealthStatus.SufficientlyHealthy;
+        }
+        this.health.protocolStatuses.set(protocol, {
+            name: protocol,
+            status: status,
+            lastUpdate: new Date()
+        });
+        this.updateOverallHealth();
+    }
+    getNameFromMulticodec(multicodec) {
+        let name;
+        if (multicodec.includes("filter")) {
+            name = Protocols.Filter;
+        }
+        else if (multicodec.includes("lightpush")) {
+            name = Protocols.LightPush;
+        }
+        else if (multicodec.includes("store")) {
+            name = Protocols.Store;
+        }
+        else {
+            throw new Error(`Unknown protocol: ${multicodec}`);
+        }
+        return name;
+    }
+    updateOverallHealth() {
+        const relevantProtocols = [Protocols.LightPush, Protocols.Filter];
+        const statuses = relevantProtocols.map((p) => this.getProtocolStatus(p)?.status);
+        if (statuses.some((status) => status === HealthStatus.Unhealthy)) {
+            this.health.overallStatus = HealthStatus.Unhealthy;
+        }
+        else if (statuses.some((status) => status === HealthStatus.MinimallyHealthy)) {
+            this.health.overallStatus = HealthStatus.MinimallyHealthy;
+        }
+        else {
+            this.health.overallStatus = HealthStatus.SufficientlyHealthy;
+        }
+    }
 }
+const getHealthManager = () => HealthManager.getInstance();
 
 const log = new Logger("metadata");
 const MetadataCodec = "/vac/waku/metadata/1.0.0";
 class Metadata extends BaseProtocol {
-    shardInfo;
+    pubsubTopics;
     libp2pComponents;
     handshakesConfirmed = new Map();
-    constructor(shardInfo, libp2p) {
-        super(MetadataCodec, libp2p.components, log, shardInfoToPubsubTopics(shardInfo));
-        this.shardInfo = shardInfo;
+    constructor(pubsubTopics, libp2p) {
+        super(MetadataCodec, libp2p.components, log, pubsubTopics);
+        this.pubsubTopics = pubsubTopics;
         this.libp2pComponents = libp2p;
         void libp2p.registrar.handle(MetadataCodec, (streamData) => {
             void this.onRequest(streamData);
         });
     }
-    /**
-     * Handle an incoming metadata request
-     */
-    async onRequest(streamData) {
-        try {
-            const { stream, connection } = streamData;
-            const encodedShardInfo = WakuMetadataResponse.encode(this.shardInfo);
-            const encodedResponse = await pipe([encodedShardInfo], encode, stream, decode, async (source) => await all(source));
-            const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
-            if (error) {
-                return;
-            }
-            await this.savePeerShardInfo(connection.remotePeer, shardInfo);
-        }
-        catch (error) {
-            log.error("Error handling metadata request", error);
-        }
-    }
     /**
      * Make a metadata query to a peer
      */
     async query(peerId) {
-        const request = WakuMetadataRequest.encode(this.shardInfo);
+        const request = WakuMetadataRequest.encode(pubsubTopicsToShardInfo(this.pubsubTopics));
         const peer = await this.peerStore.get(peerId);
         if (!peer) {
             return {
@@ -3179,6 +3227,24 @@ class Metadata extends BaseProtocol {
         }
         return await this.query(peerId);
     }
+    /**
+     * Handle an incoming metadata request
+     */
+    async onRequest(streamData) {
+        try {
+            const { stream, connection } = streamData;
+            const encodedShardInfo = WakuMetadataResponse.encode(pubsubTopicsToShardInfo(this.pubsubTopics));
+            const encodedResponse = await pipe([encodedShardInfo], encode, stream, decode, async (source) => await all(source));
+            const { error, shardInfo } = this.decodeMetadataResponse(encodedResponse);
+            if (error) {
+                return;
+            }
+            await this.savePeerShardInfo(connection.remotePeer, shardInfo);
+        }
+        catch (error) {
+            log.error("Error handling metadata request", error);
+        }
+    }
     decodeMetadataResponse(encodedResponse) {
         const bytes = new Uint8ArrayList();
         encodedResponse.forEach((chunk) => {
@@ -3207,8 +3273,8 @@ class Metadata extends BaseProtocol {
         this.handshakesConfirmed.set(peerId.toString(), shardInfo);
     }
 }
-function wakuMetadata(shardInfo) {
-    return (components) => new Metadata(shardInfo, components);
+function wakuMetadata(pubsubTopics) {
+    return (components) => new Metadata(pubsubTopics, components);
 }
 
-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 };
+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 };