@waku/core 0.0.31-1887f4f.0 → 0.0.31-409642d.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, 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-CNRKFufI.js';
+export { i as createDecoder } from './version_0-CNRKFufI.js';
+import { a as allocUnsafe, b as alloc, 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, e as pubsubTopicsToShardInfo } from './index-Gts2Ddu_.js';
+import { B as BaseProtocol, d as decodeRelayShard, e as encodeRelayShard } from './base_protocol-Dge5_tvU.js';
+export { S as StreamManager } from './base_protocol-Dge5_tvU.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
@@ -1846,8 +1799,10 @@ 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 {
@@ -1979,97 +1934,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 +2033,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 +2083,6 @@ class StoreCore extends BaseProtocol {
 
 var index = /*#__PURE__*/Object.freeze({
     __proto__: null,
-    get PageDirection () { return PageDirection; },
     StoreCodec: StoreCodec,
     StoreCore: StoreCore
 });
@@ -3098,15 +3050,84 @@ 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 {
-    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);
@@ -3116,7 +3137,7 @@ class Metadata extends BaseProtocol {
      * 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 {
@@ -3165,7 +3186,7 @@ class Metadata extends BaseProtocol {
     async onRequest(streamData) {
         try {
             const { stream, connection } = streamData;
-            const encodedShardInfo = WakuMetadataResponse.encode(this.shardInfo);
+            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) {
@@ -3205,8 +3226,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 };

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-Gts2Ddu_.js';
+export { B as BaseProtocol } from '../base_protocol-Dge5_tvU.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-CNRKFufI.js';
+import '../../index-Gts2Ddu_.js';