@waku/core 0.0.36-383e0b2.0 → 0.0.36-4997440.0

package/bundle/index.js

@@ -1,5 +1,5 @@
-import { v as version_0, a as allocUnsafe, b as alloc, e as encodingLength$1, c as encode$2, d as decode$4, F as FilterSubscribeRequest, f as FilterSubscribeResponse$1, M as MessagePush, P as PushRpc$1, g as PushResponse, S as StoreQueryRequest$1, h as StoreQueryResponse$1, t as toString$1, i as bases, j as fromString, u as utf8ToBytes, k as createEncoder, p as pubsubTopicToSingleShardInfo, l as bytesToUtf8, s as shardInfoToPubsubTopics, W as WakuMetadataRequest, m as pubsubTopicsToShardInfo, n as WakuMetadataResponse } from './version_0-4TwtF5aQ.js';
-export { o as createDecoder } from './version_0-4TwtF5aQ.js';
+import { v as version_0, a as allocUnsafe, b as alloc, e as encodingLength$1, c as encode$2, d as decode$4, F as FilterSubscribeRequest, f as FilterSubscribeResponse$1, M as MessagePush, P as PushRpc$1, g as PushResponse, S as StoreQueryRequest$1, h as StoreQueryResponse$1, t as toString$1, i as bases, j as fromString, u as utf8ToBytes, k as createEncoder, p as pubsubTopicToSingleShardInfo, l as bytesToUtf8, s as shardInfoToPubsubTopics, W as WakuMetadataRequest, m as pubsubTopicsToShardInfo, n as WakuMetadataResponse, o as concat$1, q as sha256, r as bytesToHex, w as numberToBytes } from './version_0-CyeTW0Vr.js';
+export { x as createDecoder } from './version_0-CyeTW0Vr.js';
 import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, L as Logger, P as ProtocolError, T as Tags, E as EPeersByDiscoveryEvents, f as EConnectionStateEvents } from './index-CTo1my9M.js';
 import { B as BaseProtocol } from './base_protocol-DvQrudwy.js';
 export { S as StreamManager } from './base_protocol-DvQrudwy.js';
@@ -514,6 +514,10 @@ function encodeCID(version, code, multihash) {
 }
 const cidSymbol = Symbol.for('@ipld/js-cid/CID');
 
+function isDefined(value) {
+    return Boolean(value);
+}
+
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
 /**
@@ -2300,12 +2304,30 @@ const FilterCodecs = {
     PUSH: "/vac/waku/filter-push/2.0.0-beta1"
 };
 class FilterCore extends BaseProtocol {
-    handleIncomingMessage;
     pubsubTopics;
+    static handleIncomingMessage;
     constructor(handleIncomingMessage, pubsubTopics, libp2p) {
         super(FilterCodecs.SUBSCRIBE, libp2p.components, pubsubTopics);
-        this.handleIncomingMessage = handleIncomingMessage;
         this.pubsubTopics = pubsubTopics;
+        // TODO(weboko): remove when @waku/sdk 0.0.33 is released
+        const prevHandler = FilterCore.handleIncomingMessage;
+        FilterCore.handleIncomingMessage = !prevHandler
+            ? handleIncomingMessage
+            : async (pubsubTopic, message, peerIdStr) => {
+                try {
+                    await prevHandler(pubsubTopic, message, peerIdStr);
+                }
+                catch (e) {
+                    log$5.error("Previous FilterCore incoming message handler failed ", e);
+                }
+                try {
+                    await handleIncomingMessage(pubsubTopic, message, peerIdStr);
+                }
+                catch (e) {
+                    log$5.error("Present FilterCore incoming message handler failed ", e);
+                }
+                return;
+            };
         libp2p
             .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
             maxInboundStreams: 100
@@ -2482,7 +2504,7 @@ class FilterCore extends BaseProtocol {
                         log$5.error("Pubsub topic missing from push message");
                         return;
                     }
-                    await this.handleIncomingMessage(pubsubTopic, wakuMessage, connection.remotePeer.toString());
+                    await FilterCore.handleIncomingMessage?.(pubsubTopic, wakuMessage, connection.remotePeer.toString());
                 }
             }).then(() => {
                 log$5.info("Receiving pipe closed.");
@@ -2727,19 +2749,15 @@ class StoreQueryRequest {
                 ? BigInt(params.paginationLimit)
                 : undefined
         });
-        // Validate request parameters based on RFC
         const isHashQuery = params.messageHashes && params.messageHashes.length > 0;
         const hasContentTopics = params.contentTopics && params.contentTopics.length > 0;
         const hasTimeFilter = params.timeStart || params.timeEnd;
         if (isHashQuery) {
-            // Message hash lookup queries cannot include content topics or time filters
-            // but pubsubTopic is allowed/required
             if (hasContentTopics || hasTimeFilter) {
                 throw new Error("Message hash lookup queries cannot include content filter criteria (contentTopics, timeStart, or timeEnd)");
             }
         }
         else {
-            // Content-filtered queries require both pubsubTopic and contentTopics to be set together
             if ((params.pubsubTopic &&
                 (!params.contentTopics || params.contentTopics.length === 0)) ||
                 (!params.pubsubTopic &&
@@ -4874,4 +4892,85 @@ function wakuMetadata(pubsubTopics) {
     return (components) => new Metadata(pubsubTopics, components);
 }
 
-export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, createEncoder, index$3 as message, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };
+/**
+ * Deterministic Message Hashing as defined in
+ * [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/#deterministic-message-hashing)
+ *
+ * Computes a SHA-256 hash of the concatenation of pubsub topic, payload, content topic, meta, and timestamp.
+ *
+ * @param pubsubTopic - The pubsub topic string
+ * @param message - The message to be hashed
+ * @returns A Uint8Array containing the SHA-256 hash
+ *
+ * @example
+ * ```typescript
+ * import { messageHash } from "@waku/core";
+ *
+ * const pubsubTopic = "/waku/2/default-waku/proto";
+ * const message = {
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   contentTopic: "/waku/2/default-content/proto",
+ *   meta: new Uint8Array([5, 6, 7, 8]),
+ *   timestamp: new Date()
+ * };
+ *
+ * const hash = messageHash(pubsubTopic, message);
+ * ```
+ */
+function messageHash(pubsubTopic, message) {
+    const pubsubTopicBytes = utf8ToBytes(pubsubTopic);
+    const contentTopicBytes = utf8ToBytes(message.contentTopic);
+    const timestampBytes = tryConvertTimestampToBytes(message.timestamp);
+    const bytes = concat$1([
+        pubsubTopicBytes,
+        message.payload,
+        contentTopicBytes,
+        message.meta,
+        timestampBytes
+    ].filter(isDefined));
+    return sha256(bytes);
+}
+function tryConvertTimestampToBytes(timestamp) {
+    if (!timestamp) {
+        return;
+    }
+    let bigIntTimestamp;
+    if (typeof timestamp === "bigint") {
+        bigIntTimestamp = timestamp;
+    }
+    else {
+        bigIntTimestamp = BigInt(timestamp.valueOf()) * 1000000n;
+    }
+    return numberToBytes(bigIntTimestamp);
+}
+/**
+ * Computes a deterministic message hash and returns it as a hexadecimal string.
+ * This is a convenience wrapper around messageHash that converts the result to a hex string.
+ *
+ * @param pubsubTopic - The pubsub topic string
+ * @param message - The message to be hashed
+ * @returns A string containing the hex representation of the SHA-256 hash
+ *
+ * @example
+ * ```typescript
+ * import { messageHashStr } from "@waku/core";
+ *
+ * const pubsubTopic = "/waku/2/default-waku/proto";
+ * const message = {
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   contentTopic: "/waku/2/default-content/proto",
+ *   meta: new Uint8Array([5, 6, 7, 8]),
+ *   timestamp: new Date()
+ * };
+ *
+ * const hashString = messageHashStr(pubsubTopic, message);
+ * console.log(hashString); // e.g. "a1b2c3d4..."
+ * ```
+ */
+function messageHashStr(pubsubTopic, message) {
+    const hash = messageHash(pubsubTopic, message);
+    const hashStr = bytesToHex(hash);
+    return hashStr;
+}
+
+export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, createEncoder, index$3 as message, messageHash, messageHashStr, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };

package/bundle/lib/message/version_0.js

@@ -1,2 +1,2 @@
-export { D as DecodedMessage, r as Decoder, E as Encoder, V as Version, o as createDecoder, k as createEncoder, q as proto } from '../../version_0-4TwtF5aQ.js';
+export { D as DecodedMessage, z as Decoder, E as Encoder, V as Version, x as createDecoder, k as createEncoder, y as proto } from '../../version_0-CyeTW0Vr.js';
 import '../../index-CTo1my9M.js';

package/bundle/{version_0-4TwtF5aQ.js → version_0-CyeTW0Vr.js}

@@ -3985,11 +3985,17 @@ var SdsMessage;
 })(SdsMessage || (SdsMessage = {}));
 
 /**
- * Internal assertion helpers.
+ * Utilities for hex, bytes, CSPRNG.
  * @module
  */
-/** Asserts something is positive integer. */
-/** Is number an Uint8Array? Copied from utils for perf. */
+/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
+// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
+// node.js versions earlier than v19 don't declare it in global scope.
+// For node.js, package.json#exports field mapping rewrites import
+// from `crypto` to `cryptoNode`, which imports native module.
+// Makes the utils un-importable in browsers without a bundler.
+// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
+/** Checks if something is Uint8Array. Be careful: nodejs Buffer will return true. */
 function isBytes(a) {
     return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
 }
@@ -4015,19 +4021,13 @@ function aoutput(out, instance) {
         throw new Error('digestInto() expects output buffer of length at least ' + min);
     }
 }
-
-/**
- * Utilities for hex, bytes, CSPRNG.
- * @module
- */
-/*! noble-hashes - MIT License (c) 2022 Paul Miller (paulmillr.com) */
-// We use WebCrypto aka globalThis.crypto, which exists in browsers and node.js 16+.
-// node.js versions earlier than v19 don't declare it in global scope.
-// For node.js, package.json#exports field mapping rewrites import
-// from `crypto` to `cryptoNode`, which imports native module.
-// Makes the utils un-importable in browsers without a bundler.
-// Once node.js 18 is deprecated (2025-04-30), we can just drop the import.
-// Cast array to view
+/** Zeroize a byte array. Warning: JS provides no guarantees. */
+function clean(...arrays) {
+    for (let i = 0; i < arrays.length; i++) {
+        arrays[i].fill(0);
+    }
+}
+/** Create DataView of an array for easy byte-level manipulation. */
 function createView(arr) {
     return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
 }
@@ -4036,12 +4036,12 @@ function rotr(word, shift) {
     return (word << (32 - shift)) | (word >>> shift);
 }
 /**
- * Convert JS string to byte array.
- * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+ * Converts string to bytes using UTF8 encoding.
+ * @example utf8ToBytes('abc') // Uint8Array.from([97, 98, 99])
  */
 function utf8ToBytes$1(str) {
     if (typeof str !== 'string')
-        throw new Error('utf8ToBytes expected string, got ' + typeof str);
+        throw new Error('string expected');
     return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
 }
 /**
@@ -4057,13 +4057,9 @@ function toBytes(data) {
 }
 /** For runtime check if class implements interface */
 class Hash {
-    // Safe version that clones internal state
-    clone() {
-        return this._cloneInto();
-    }
 }
 /** Wraps hash function, creating an interface on top of it */
-function wrapConstructor(hashCons) {
+function createHasher(hashCons) {
     const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
     const tmp = hashCons();
     hashC.outputLen = tmp.outputLen;
@@ -4104,21 +4100,22 @@ function Maj(a, b, c) {
 class HashMD extends Hash {
     constructor(blockLen, outputLen, padOffset, isLE) {
         super();
-        this.blockLen = blockLen;
-        this.outputLen = outputLen;
-        this.padOffset = padOffset;
-        this.isLE = isLE;
         this.finished = false;
         this.length = 0;
         this.pos = 0;
         this.destroyed = false;
+        this.blockLen = blockLen;
+        this.outputLen = outputLen;
+        this.padOffset = padOffset;
+        this.isLE = isLE;
         this.buffer = new Uint8Array(blockLen);
         this.view = createView(this.buffer);
     }
     update(data) {
         aexists(this);
-        const { view, buffer, blockLen } = this;
         data = toBytes(data);
+        abytes(data);
+        const { view, buffer, blockLen } = this;
         const len = data.length;
         for (let pos = 0; pos < len;) {
             const take = Math.min(blockLen - this.pos, len - pos);
@@ -4152,7 +4149,7 @@ class HashMD extends Hash {
         let { pos } = this;
         // append the bit '1' to the message
         buffer[pos++] = 0b10000000;
-        this.buffer.subarray(pos).fill(0);
+        clean(this.buffer.subarray(pos));
         // we have less than padOffset left in buffer, so we cannot put length in
         // current block, need process it and pad again
         if (this.padOffset > blockLen - pos) {
@@ -4190,28 +4187,40 @@ class HashMD extends Hash {
         to || (to = new this.constructor());
         to.set(...this.get());
         const { blockLen, buffer, length, finished, destroyed, pos } = this;
+        to.destroyed = destroyed;
+        to.finished = finished;
         to.length = length;
         to.pos = pos;
-        to.finished = finished;
-        to.destroyed = destroyed;
         if (length % blockLen)
             to.buffer.set(buffer);
         return to;
     }
+    clone() {
+        return this._cloneInto();
+    }
 }
+/**
+ * Initial SHA-2 state: fractional parts of square roots of first 16 primes 2..53.
+ * Check out `test/misc/sha2-gen-iv.js` for recomputation guide.
+ */
+/** Initial SHA256 state. Bits 0..32 of frac part of sqrt of primes 2..19 */
+const SHA256_IV = /* @__PURE__ */ Uint32Array.from([
+    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19,
+]);
 
 /**
- * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
- *
- * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
- * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
- *
- * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+ * SHA2 hash function. A.k.a. sha256, sha384, sha512, sha512_224, sha512_256.
+ * SHA256 is the fastest hash implementable in JS, even faster than Blake3.
+ * Check out [RFC 4634](https://datatracker.ietf.org/doc/html/rfc4634) and
+ * [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
  * @module
  */
-/** Round constants: first 32 bits of fractional parts of the cube roots of the first 64 primes 2..311). */
+/**
+ * Round constants:
+ * First 32 bits of fractional parts of the cube roots of the first 64 primes 2..311)
+ */
 // prettier-ignore
-const SHA256_K = /* @__PURE__ */ new Uint32Array([
+const SHA256_K = /* @__PURE__ */ Uint32Array.from([
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
     0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
     0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
@@ -4221,19 +4230,11 @@ const SHA256_K = /* @__PURE__ */ new Uint32Array([
     0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,
     0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2
 ]);
-/** Initial state: first 32 bits of fractional parts of the square roots of the first 8 primes 2..19. */
-// prettier-ignore
-const SHA256_IV = /* @__PURE__ */ new Uint32Array([
-    0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19
-]);
-/**
- * Temporary buffer, not used to store anything between runs.
- * Named this way because it matches specification.
- */
+/** Reusable temporary buffer. "W" comes straight from spec. */
 const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
 class SHA256 extends HashMD {
-    constructor() {
-        super(64, 32, 8, false);
+    constructor(outputLen = 32) {
+        super(64, outputLen, 8, false);
         // We cannot use array here since array allows indexing by variable
         // which means optimizer/compiler cannot use registers.
         this.A = SHA256_IV[0] | 0;
@@ -4299,15 +4300,34 @@ class SHA256 extends HashMD {
         this.set(A, B, C, D, E, F, G, H);
     }
     roundClean() {
-        SHA256_W.fill(0);
+        clean(SHA256_W);
     }
     destroy() {
         this.set(0, 0, 0, 0, 0, 0, 0, 0);
-        this.buffer.fill(0);
+        clean(this.buffer);
     }
 }
-/** SHA2-256 hash function */
-const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
+/**
+ * SHA2-256 hash function from RFC 4634.
+ *
+ * It is the fastest JS hash, even faster than Blake3.
+ * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+ * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+ */
+const sha256$1 = /* @__PURE__ */ createHasher(() => new SHA256());
+
+/**
+ * SHA2-256 a.k.a. sha256. In JS, it is the fastest hash, even faster than Blake3.
+ *
+ * To break sha256 using birthday attack, attackers need to try 2^128 hashes.
+ * BTC network is doing 2^70 hashes/sec (2^95 hashes/year) as per 2025.
+ *
+ * Check out [FIPS 180-4](https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf).
+ * @module
+ * @deprecated
+ */
+/** @deprecated Use import from `noble/hashes/sha2` module */
+const sha256 = sha256$1;
 
 /**
  * The default cluster ID for The Waku Network
@@ -4330,6 +4350,21 @@ function toString(array, encoding = 'utf8') {
     return base.encoder.encode(array).substring(1);
 }
 
+function numberToBytes(value) {
+    const buffer = new ArrayBuffer(8);
+    const view = new DataView(buffer);
+    if (typeof value === "number") {
+        view.setFloat64(0, value, false);
+    }
+    else {
+        view.setBigInt64(0, value, false);
+    }
+    return new Uint8Array(buffer);
+}
+/**
+ * Convert byte array to hex string (no `0x` prefix).
+ */
+const bytesToHex = (bytes) => toString(bytes, "base16");
 /**
  * Decode byte array to utf-8 string.
  */
@@ -4512,9 +4547,6 @@ class DecodedMessage {
     get contentTopic() {
         return this.proto.contentTopic;
     }
-    get _rawTimestamp() {
-        return this.proto.timestamp;
-    }
     get timestamp() {
         // In the case we receive a value that is bigger than JS's max number,
         // we catch the error and return undefined.
@@ -4536,7 +4568,7 @@ class DecodedMessage {
     get version() {
         // https://rfc.vac.dev/spec/14/
         // > If omitted, the value SHOULD be interpreted as version 0.
-        return this.proto.version ?? 0;
+        return this.proto.version ?? Version;
     }
     get rateLimitProof() {
         return this.proto.rateLimitProof;
@@ -4645,4 +4677,4 @@ var version_0 = /*#__PURE__*/Object.freeze({
     proto: message
 });
 
-export { DecodedMessage as D, Encoder as E, FilterSubscribeRequest as F, MessagePush as M, PushRpc$1 as P, StoreQueryRequest$1 as S, Version as V, WakuMetadataRequest as W, allocUnsafe as a, alloc$1 as b, encode as c, decode as d, encodingLength as e, FilterSubscribeResponse$1 as f, PushResponse as g, StoreQueryResponse$1 as h, bases as i, fromString as j, createEncoder as k, bytesToUtf8 as l, pubsubTopicsToShardInfo as m, WakuMetadataResponse as n, createDecoder as o, pubsubTopicToSingleShardInfo as p, message as q, Decoder as r, shardInfoToPubsubTopics as s, toString as t, utf8ToBytes as u, version_0 as v };
+export { DecodedMessage as D, Encoder as E, FilterSubscribeRequest as F, MessagePush as M, PushRpc$1 as P, StoreQueryRequest$1 as S, Version as V, WakuMetadataRequest as W, allocUnsafe as a, alloc$1 as b, encode as c, decode as d, encodingLength as e, FilterSubscribeResponse$1 as f, PushResponse as g, StoreQueryResponse$1 as h, bases as i, fromString as j, createEncoder as k, bytesToUtf8 as l, pubsubTopicsToShardInfo as m, WakuMetadataResponse as n, concat as o, pubsubTopicToSingleShardInfo as p, sha256 as q, bytesToHex as r, shardInfoToPubsubTopics as s, toString as t, utf8ToBytes as u, version_0 as v, numberToBytes as w, createDecoder as x, message as y, Decoder as z };