@waku/core 0.0.33-f599932.0 → 0.0.34-09108d9.0

package/bundle/lib/base_protocol.js

@@ -1,2 +1,2 @@
-export { B as BaseProtocol } from '../base_protocol-CS0EDeEY.js';
-import '../index-BVysxsMu.js';
+export { B as BaseProtocol } from '../base_protocol-Bp5a9PNG.js';
+import '../index-G1eRBjeI.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, g as createEncoder, m as proto } from '../../version_0-C5ObpJ_0.js';
-import '../../index-BVysxsMu.js';
+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-DJZG2fB2.js';
+import '../../index-G1eRBjeI.js';

package/bundle/{version_0-C5ObpJ_0.js → version_0-DJZG2fB2.js}

@@ -1,4 +1,20 @@
-import { a as allocUnsafe, f as fromString, b as alloc$1, e as concat, u as utf8ToBytes$1, L as Logger } from './index-BVysxsMu.js';
+import { i as identityBase, g as base2, h as base8, j as base10, k as base16, l as base32, m as base36, n as base58, o as base64, p as base256emoji, L as Logger } from './index-G1eRBjeI.js';
+
+/**
+ * Returns a `Uint8Array` of the requested size. Referenced memory will
+ * be initialized to 0.
+ */
+function alloc$1(size = 0) {
+    return new Uint8Array(size);
+}
+/**
+ * Where possible returns a Uint8Array of the requested size that references
+ * uninitialized memory. Only use if you are certain you will immediately
+ * overwrite every value in the returned `Uint8Array`.
+ */
+function allocUnsafe(size = 0) {
+    return new Uint8Array(size);
+}
 
 /* eslint-disable no-fallthrough */
 const N1 = Math.pow(2, 7);
@@ -916,6 +932,69 @@ function decodeMessage(buf, codec, opts) {
     return codec.decode(reader, undefined, opts);
 }
 
+const bases = { ...identityBase, ...base2, ...base8, ...base10, ...base16, ...base32, ...base36, ...base58, ...base64, ...base256emoji };
+
+function createCodec$1(name, prefix, encode, decode) {
+    return {
+        name,
+        prefix,
+        encoder: {
+            name,
+            prefix,
+            encode
+        },
+        decoder: {
+            decode
+        }
+    };
+}
+const string = createCodec$1('utf8', 'u', (buf) => {
+    const decoder = new TextDecoder('utf8');
+    return 'u' + decoder.decode(buf);
+}, (str) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(str.substring(1));
+});
+const ascii = createCodec$1('ascii', 'a', (buf) => {
+    let string = 'a';
+    for (let i = 0; i < buf.length; i++) {
+        string += String.fromCharCode(buf[i]);
+    }
+    return string;
+}, (str) => {
+    str = str.substring(1);
+    const buf = allocUnsafe(str.length);
+    for (let i = 0; i < str.length; i++) {
+        buf[i] = str.charCodeAt(i);
+    }
+    return buf;
+});
+const BASES = {
+    utf8: string,
+    'utf-8': string,
+    hex: bases.base16,
+    latin1: ascii,
+    ascii,
+    binary: ascii,
+    ...bases
+};
+
+/**
+ * Create a `Uint8Array` from the passed string
+ *
+ * Supports `utf8`, `utf-8`, `hex`, and any encoding supported by the multiformats module.
+ *
+ * Also `ascii` which is similar to node's 'binary' encoding.
+ */
+function fromString(string, encoding = 'utf8') {
+    const base = BASES[encoding];
+    if (base == null) {
+        throw new Error(`Unsupported encoding "${encoding}"`);
+    }
+    // add multibase prefix
+    return base.decoder.decode(`${base.prefix}${string}`); // eslint-disable-line @typescript-eslint/restrict-template-expressions
+}
+
 /**
  * A general purpose buffer pool
  */
@@ -3750,31 +3829,141 @@ var WakuMetadataResponse;
     };
 })(WakuMetadataResponse || (WakuMetadataResponse = {}));
 
-// copied from utils
+/* eslint-disable import/export */
+/* eslint-disable complexity */
+/* eslint-disable @typescript-eslint/no-namespace */
+/* eslint-disable @typescript-eslint/no-unnecessary-boolean-literal-compare */
+/* eslint-disable @typescript-eslint/no-empty-interface */
+var SdsMessage;
+(function (SdsMessage) {
+    let _codec;
+    SdsMessage.codec = () => {
+        if (_codec == null) {
+            _codec = message$1((obj, w, opts = {}) => {
+                if (opts.lengthDelimited !== false) {
+                    w.fork();
+                }
+                if ((obj.messageId != null && obj.messageId !== '')) {
+                    w.uint32(18);
+                    w.string(obj.messageId);
+                }
+                if ((obj.channelId != null && obj.channelId !== '')) {
+                    w.uint32(26);
+                    w.string(obj.channelId);
+                }
+                if (obj.lamportTimestamp != null) {
+                    w.uint32(80);
+                    w.int32(obj.lamportTimestamp);
+                }
+                if (obj.causalHistory != null) {
+                    for (const value of obj.causalHistory) {
+                        w.uint32(90);
+                        w.string(value);
+                    }
+                }
+                if (obj.bloomFilter != null) {
+                    w.uint32(98);
+                    w.bytes(obj.bloomFilter);
+                }
+                if (obj.content != null) {
+                    w.uint32(162);
+                    w.bytes(obj.content);
+                }
+                if (opts.lengthDelimited !== false) {
+                    w.ldelim();
+                }
+            }, (reader, length, opts = {}) => {
+                const obj = {
+                    messageId: '',
+                    channelId: '',
+                    causalHistory: []
+                };
+                const end = length == null ? reader.len : reader.pos + length;
+                while (reader.pos < end) {
+                    const tag = reader.uint32();
+                    switch (tag >>> 3) {
+                        case 2: {
+                            obj.messageId = reader.string();
+                            break;
+                        }
+                        case 3: {
+                            obj.channelId = reader.string();
+                            break;
+                        }
+                        case 10: {
+                            obj.lamportTimestamp = reader.int32();
+                            break;
+                        }
+                        case 11: {
+                            if (opts.limits?.causalHistory != null && obj.causalHistory.length === opts.limits.causalHistory) {
+                                throw new MaxLengthError('Decode error - map field "causalHistory" had too many elements');
+                            }
+                            obj.causalHistory.push(reader.string());
+                            break;
+                        }
+                        case 12: {
+                            obj.bloomFilter = reader.bytes();
+                            break;
+                        }
+                        case 20: {
+                            obj.content = reader.bytes();
+                            break;
+                        }
+                        default: {
+                            reader.skipType(tag & 7);
+                            break;
+                        }
+                    }
+                }
+                return obj;
+            });
+        }
+        return _codec;
+    };
+    SdsMessage.encode = (obj) => {
+        return encodeMessage(obj, SdsMessage.codec());
+    };
+    SdsMessage.decode = (buf, opts) => {
+        return decodeMessage(buf, SdsMessage.codec(), opts);
+    };
+})(SdsMessage || (SdsMessage = {}));
+
+/**
+ * Internal assertion helpers.
+ * @module
+ */
+/** Asserts something is positive integer. */
+/** Is number an Uint8Array? Copied from utils for perf. */
 function isBytes(a) {
-    return (a instanceof Uint8Array ||
-        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+    return a instanceof Uint8Array || (ArrayBuffer.isView(a) && a.constructor.name === 'Uint8Array');
 }
-function bytes(b, ...lengths) {
+/** Asserts something is Uint8Array. */
+function abytes(b, ...lengths) {
     if (!isBytes(b))
         throw new Error('Uint8Array expected');
     if (lengths.length > 0 && !lengths.includes(b.length))
-        throw new Error(`Uint8Array expected of length ${lengths}, not of length=${b.length}`);
+        throw new Error('Uint8Array expected of length ' + lengths + ', got length=' + b.length);
 }
-function exists(instance, checkFinished = true) {
+/** Asserts a hash instance has not been destroyed / finished */
+function aexists(instance, checkFinished = true) {
     if (instance.destroyed)
         throw new Error('Hash instance has been destroyed');
     if (checkFinished && instance.finished)
         throw new Error('Hash#digest() has already been called');
 }
-function output(out, instance) {
-    bytes(out);
+/** Asserts output is properly-sized byte array */
+function aoutput(out, instance) {
+    abytes(out);
     const min = instance.outputLen;
     if (out.length < min) {
-        throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+        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.
@@ -3783,16 +3972,20 @@ function output(out, instance) {
 // 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
-const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
-// The rotate right (circular right shift) operation for uint32
-const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
-new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
+function createView(arr) {
+    return new DataView(arr.buffer, arr.byteOffset, arr.byteLength);
+}
+/** The rotate right (circular right shift) operation for uint32 */
+function rotr(word, shift) {
+    return (word << (32 - shift)) | (word >>> shift);
+}
 /**
+ * Convert JS string to byte array.
  * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
  */
-function utf8ToBytes(str) {
+function utf8ToBytes$1(str) {
     if (typeof str !== 'string')
-        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+        throw new Error('utf8ToBytes expected string, got ' + typeof str);
     return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
 }
 /**
@@ -3802,17 +3995,18 @@ function utf8ToBytes(str) {
  */
 function toBytes(data) {
     if (typeof data === 'string')
-        data = utf8ToBytes(data);
-    bytes(data);
+        data = utf8ToBytes$1(data);
+    abytes(data);
     return data;
 }
-// For runtime check if class implements interface
+/** 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) {
     const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
     const tmp = hashCons();
@@ -3822,7 +4016,11 @@ function wrapConstructor(hashCons) {
     return hashC;
 }
 
-// Polyfill for Safari 14
+/**
+ * Internal Merkle-Damgard hash utils.
+ * @module
+ */
+/** Polyfill for Safari 14. https://caniuse.com/mdn-javascript_builtins_dataview_setbiguint64 */
 function setBigUint64(view, byteOffset, value, isLE) {
     if (typeof view.setBigUint64 === 'function')
         return view.setBigUint64(byteOffset, value, isLE);
@@ -3835,10 +4033,14 @@ function setBigUint64(view, byteOffset, value, isLE) {
     view.setUint32(byteOffset + h, wh, isLE);
     view.setUint32(byteOffset + l, wl, isLE);
 }
-// Choice: a ? b : c
-const Chi = (a, b, c) => (a & b) ^ (~a & c);
-// Majority function, true if any two inpust is true
-const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
+/** Choice: a ? b : c */
+function Chi(a, b, c) {
+    return (a & b) ^ (~a & c);
+}
+/** Majority function, true if any two inputs is true. */
+function Maj(a, b, c) {
+    return (a & b) ^ (a & c) ^ (b & c);
+}
 /**
  * Merkle-Damgard hash construction base class.
  * Could be used to create MD5, RIPEMD, SHA1, SHA2.
@@ -3858,7 +4060,7 @@ class HashMD extends Hash {
         this.view = createView(this.buffer);
     }
     update(data) {
-        exists(this);
+        aexists(this);
         const { view, buffer, blockLen } = this;
         data = toBytes(data);
         const len = data.length;
@@ -3884,8 +4086,8 @@ class HashMD extends Hash {
         return this;
     }
     digestInto(out) {
-        exists(this);
-        output(out, this);
+        aexists(this);
+        aoutput(out, this);
         this.finished = true;
         // Padding
         // We can avoid allocation of buffer for padding completely if it
@@ -3942,10 +4144,16 @@ class HashMD extends Hash {
     }
 }
 
-// SHA2-256 need to try 2^128 hashes to execute birthday attack.
-// BTC network is doing 2^67 hashes/sec as per early 2023.
-// Round constants:
-// first 32 bits of the fractional parts of the cube roots of the first 64 primes 2..311)
+/**
+ * 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
+ */
+/** 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([
     0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
@@ -3957,14 +4165,15 @@ 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 the fractional parts of the square roots of the first 8 primes 2..19
+/** 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.
+/**
+ * Temporary buffer, not used to store anything between runs.
+ * Named this way because it matches specification.
+ */
 const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
 class SHA256 extends HashMD {
     constructor() {
@@ -4041,10 +4250,7 @@ class SHA256 extends HashMD {
         this.buffer.fill(0);
     }
 }
-/**
- * SHA2-256 hash function
- * @param message - data that would be hashed
- */
+/** SHA2-256 hash function */
 const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
 /**
@@ -4052,6 +4258,44 @@ const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
  */
 const DEFAULT_CLUSTER_ID = 1;
 
+/**
+ * Turns a `Uint8Array` into a string.
+ *
+ * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.
+ *
+ * Also `ascii` which is similar to node's 'binary' encoding.
+ */
+function toString(array, encoding = 'utf8') {
+    const base = BASES[encoding];
+    if (base == null) {
+        throw new Error(`Unsupported encoding "${encoding}"`);
+    }
+    // strip multibase prefix
+    return base.encoder.encode(array).substring(1);
+}
+
+/**
+ * Decode byte array to utf-8 string.
+ */
+const bytesToUtf8 = (b) => toString(b, "utf8");
+/**
+ * Encode utf-8 string to byte array.
+ */
+const utf8ToBytes = (s) => fromString(s, "utf8");
+/**
+ * Concatenate using Uint8Arrays as `Buffer` has a different behavior with `DataView`
+ */
+function concat(byteArrays, totalLength) {
+    const len = byteArrays.reduce((acc, curr) => acc + curr.length, 0);
+    const res = new Uint8Array(len);
+    let offset = 0;
+    for (const bytes of byteArrays) {
+        res.set(bytes, offset);
+        offset += bytes.length;
+    }
+    return res;
+}
+
 const singleShardInfoToPubsubTopic = (shardInfo) => {
     if (shardInfo.shard === undefined)
         throw new Error("Invalid shard");
@@ -4168,7 +4412,7 @@ function ensureValidContentTopic(contentTopic) {
  */
 function contentTopicToShardIndex(contentTopic, networkShards = 8) {
     const { application, version } = ensureValidContentTopic(contentTopic);
-    const digest = sha256(concat([utf8ToBytes$1(application), utf8ToBytes$1(version)]));
+    const digest = sha256(concat([utf8ToBytes(application), utf8ToBytes(version)]));
     const dataview = new DataView(digest.buffer.slice(-8));
     return Number(dataview.getBigUint64(0, false) % BigInt(networkShards));
 }
@@ -4345,4 +4589,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, encode as a, FilterSubscribeResponse$1 as b, PushResponse as c, decode as d, encodingLength as e, StoreQueryResponse$1 as f, createEncoder as g, pubsubTopicsToShardInfo as h, WakuMetadataResponse as i, createDecoder as j, Decoder as k, message as m, pubsubTopicToSingleShardInfo as p, shardInfoToPubsubTopics as s, 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, 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 };