@waku/core 0.0.31-08fc2d1.0 → 0.0.31-15400a5.0

package/bundle/{base_protocol-WTp5jKZK.js → base_protocol-0VPHaGce.js}

@@ -1,4 +1,4 @@
-import { h as bytesToUtf8, T as Tags, L as Logger, i as ensureShardingConfigured } from './index-COT0phC8.js';
+import { h as bytesToUtf8, T as Tags, L as Logger, i as ensureShardingConfigured } from './index-D-yd4hdM.js';
 
 const decodeRelayShard = (bytes) => {
     // explicitly converting to Uint8Array to avoid Buffer

package/bundle/{index-COT0phC8.js → index-D-yd4hdM.js}

@@ -1037,6 +1037,11 @@ var ProtocolError;
      * Ensure that the pubsub topic used for decoder creation is the same as the one used for protocol.
      */
     ProtocolError["TOPIC_DECODER_MISMATCH"] = "Topic decoder mismatch";
+    /**
+     * The topics passed in the decoders do not match each other, or don't exist at all.
+     * Ensure that all the pubsub topics used in the decoders are valid and match each other.
+     */
+    ProtocolError["INVALID_DECODER_TOPICS"] = "Invalid decoder topics";
     /**
      * 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
@@ -1067,12 +1072,6 @@ var ProtocolError;
     ProtocolError["REQUEST_TIMEOUT"] = "Request timeout";
 })(ProtocolError || (ProtocolError = {}));
 
-var PageDirection;
-(function (PageDirection) {
-    PageDirection["BACKWARD"] = "backward";
-    PageDirection["FORWARD"] = "forward";
-})(PageDirection || (PageDirection = {}));
-
 var Tags;
 (function (Tags) {
     Tags["BOOTSTRAP"] = "bootstrap";
@@ -1096,6 +1095,13 @@ var EConnectionStateEvents;
  */
 const DEFAULT_CLUSTER_ID = 1;
 
+var HealthStatus;
+(function (HealthStatus) {
+    HealthStatus["Unhealthy"] = "Unhealthy";
+    HealthStatus["MinimallyHealthy"] = "MinimallyHealthy";
+    HealthStatus["SufficientlyHealthy"] = "SufficientlyHealthy";
+})(HealthStatus || (HealthStatus = {}));
+
 /**
  * Turns a `Uint8Array` into a string.
  *
@@ -2051,4 +2057,4 @@ class Logger {
     }
 }
 
-export { EConnectionStateEvents as E, Logger as L, ProtocolError as P, Tags as T, allocUnsafe as a, alloc as b, Protocols as c, EPeersByDiscoveryEvents as d, determinePubsubTopic as e, fromString as f, getDefaultExportFromCjs as g, bytesToUtf8 as h, ensureShardingConfigured as i, pubsubTopicToSingleShardInfo as p, shardInfoToPubsubTopics as s, utf8ToBytes as u };
+export { EConnectionStateEvents as E, HealthStatus as H, Logger as L, ProtocolError as P, Tags as T, allocUnsafe as a, alloc as b, Protocols as c, EPeersByDiscoveryEvents as d, determinePubsubTopic as e, fromString as f, getDefaultExportFromCjs as g, bytesToUtf8 as h, ensureShardingConfigured as i, pubsubTopicToSingleShardInfo as p, shardInfoToPubsubTopics as s, utf8ToBytes as u };

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 WakuMetadataRequest, i as WakuMetadataResponse } from './version_0-SMRUXDNR.js';
-export { j as createDecoder } from './version_0-SMRUXDNR.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-COT0phC8.js';
-import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-WTp5jKZK.js';
-export { S as StreamManager } from './base_protocol-WTp5jKZK.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-Du1FfEvY.js';
+export { i as createDecoder } from './version_0-Du1FfEvY.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, H as HealthStatus } from './index-D-yd4hdM.js';
+import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-0VPHaGce.js';
+export { S as StreamManager } from './base_protocol-0VPHaGce.js';
 
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
@@ -1979,97 +1979,95 @@ 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);
+        super(StoreCodec, libp2p.components, log$4, options?.pubsubTopics || [], options);
     }
     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 +2076,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;
+            }
+            else {
+                currentCursor = storeQueryResponse.messages[0].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) {
+            if (storeQueryResponse.messages.length > MAX_PAGE_SIZE &&
+                storeQueryResponse.messages.length <
+                    (queryOpts.paginationLimit || DEFAULT_PAGE_SIZE)) {
                 break;
             }
         }
@@ -2130,7 +2126,6 @@ class StoreCore extends BaseProtocol {
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    get PageDirection () { return PageDirection; },
     StoreCodec: StoreCodec,
     StoreCore: StoreCore
 });
@@ -3098,6 +3093,75 @@ class ConnectionManager extends TypedEventEmitter {
     }
 }
 
+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 {
@@ -3209,4 +3273,4 @@ function wakuMetadata(shardInfo) {
     return (components) => new Metadata(shardInfo, 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 };

package/bundle/lib/base_protocol.js

@@ -1,2 +1,2 @@
-import '../index-COT0phC8.js';
-export { B as BaseProtocol } from '../base_protocol-WTp5jKZK.js';
+import '../index-D-yd4hdM.js';
+export { B as BaseProtocol } from '../base_protocol-0VPHaGce.js';

package/bundle/lib/message/version_0.js

@@ -1,2 +1,2 @@
-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-SMRUXDNR.js';
-import '../../index-COT0phC8.js';
+export { D as DecodedMessage, j as Decoder, E as Encoder, V as Version, i as createDecoder, g as createEncoder, m as proto } from '../../version_0-Du1FfEvY.js';
+import '../../index-D-yd4hdM.js';