@waku/core 0.0.30-e49e728.0 → 0.0.31-ce62600.0

package/CHANGELOG.md

@@ -5,6 +5,33 @@ All notable changes to this project will be documented in this file.
 The file is maintained by [Release Please](https://github.com/googleapis/release-please) based on [Conventional Commits](https://www.conventionalcommits.org) specification,
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.0.30](https://github.com/waku-org/js-waku/compare/core-v0.0.29...core-v0.0.30) (2024-07-10)
+
+
+### ⚠ BREAKING CHANGES
+
+* **filter:** return error codes instead of throwing errors ([#1971](https://github.com/waku-org/js-waku/issues/1971))
+
+### Features
+
+* **filter:** Return error codes instead of throwing errors ([#1971](https://github.com/waku-org/js-waku/issues/1971)) ([4eb06c6](https://github.com/waku-org/js-waku/commit/4eb06c64eb05c015e2f51e3f45a9d7143a934385))
+* **lightpush:** Peer management for protocols ([#2003](https://github.com/waku-org/js-waku/issues/2003)) ([93e78c3](https://github.com/waku-org/js-waku/commit/93e78c3b876e084ab70e07c64c9b721693b659f8))
+
+
+### Bug Fixes
+
+* Failing `node_optional` check ([#2025](https://github.com/waku-org/js-waku/issues/2025)) ([984fb94](https://github.com/waku-org/js-waku/commit/984fb94b5b23a0d2f7edebad36170911ce7a2e84))
+* Increasing maxInboundStreams for lightpush from 32 to 100 ([#2021](https://github.com/waku-org/js-waku/issues/2021)) ([2311a59](https://github.com/waku-org/js-waku/commit/2311a595b28b9e7c99fcd96044cf098ad975c70c))
+
+
+### Dependencies
+
+* The following workspace dependencies were updated
+  * dependencies
+    * @waku/enr bumped from ^0.0.23 to ^0.0.24
+    * @waku/interfaces bumped from 0.0.24 to 0.0.25
+    * @waku/utils bumped from 0.0.17 to 0.0.18
+
 ## [0.0.29](https://github.com/waku-org/js-waku/compare/core-v0.0.28...core-v0.0.29) (2024-04-30)
 
 

package/bundle/{base_protocol-DCOj0QWD.js → base_protocol-C6HnrRx8.js}

@@ -1,5 +1,4 @@
-import { c as bytesToUtf8, L as Logger, e as ensureShardingConfigured } from './index-BcSodzY4.js';
-import { T as Tags } from './browser-zSUobdfj.js';
+import { h as bytesToUtf8, T as Tags, L as Logger, i as ensureShardingConfigured } from './index-DnW8ifxc.js';
 
 const decodeRelayShard = (bytes) => {
     // explicitly converting to Uint8Array to avoid Buffer

package/bundle/{browser-zSUobdfj.js → index-DnW8ifxc.js}

@@ -1,3 +1,19 @@
+/**
+ * Returns a `Uint8Array` of the requested size. Referenced memory will
+ * be initialized to 0.
+ */
+function alloc(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);
+}
+
 function coerce(o) {
     if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array')
         return o;
@@ -8,10 +24,10 @@ function coerce(o) {
     }
     throw new Error('Unknown type, must be binary type');
 }
-function fromString(str) {
+function fromString$1(str) {
     return new TextEncoder().encode(str);
 }
-function toString(b) {
+function toString$1(b) {
     return new TextDecoder().decode(b);
 }
 
@@ -608,8 +624,8 @@ var base8$1 = /*#__PURE__*/Object.freeze({
 const identity = from({
     prefix: '\x00',
     name: 'identity',
-    encode: (buf) => toString(buf),
-    decode: (str) => fromString(str)
+    encode: (buf) => toString$1(buf),
+    decode: (str) => fromString$1(str)
 });
 
 var identityBase = /*#__PURE__*/Object.freeze({
@@ -620,6 +636,366 @@ var identityBase = /*#__PURE__*/Object.freeze({
 new TextEncoder();
 new TextDecoder();
 
+const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$1, ...base32$1, ...base36$1, ...base58, ...base64$1, ...base256emoji$1 };
+
+function createCodec(name, prefix, encode, decode) {
+    return {
+        name,
+        prefix,
+        encoder: {
+            name,
+            prefix,
+            encode
+        },
+        decoder: {
+            decode
+        }
+    };
+}
+const string = createCodec('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('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
+}
+
+// copied from utils
+function isBytes(a) {
+    return (a instanceof Uint8Array ||
+        (a != null && typeof a === 'object' && a.constructor.name === 'Uint8Array'));
+}
+function bytes(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}`);
+}
+function exists(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);
+    const min = instance.outputLen;
+    if (out.length < min) {
+        throw new Error(`digestInto() expects output buffer of length at least ${min}`);
+    }
+}
+
+/*! 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
+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;
+/**
+ * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
+ */
+function utf8ToBytes$1(str) {
+    if (typeof str !== 'string')
+        throw new Error(`utf8ToBytes expected string, got ${typeof str}`);
+    return new Uint8Array(new TextEncoder().encode(str)); // https://bugzil.la/1681809
+}
+/**
+ * Normalizes (non-hex) string or Uint8Array to Uint8Array.
+ * Warning: when Uint8Array is passed, it would NOT get copied.
+ * Keep in mind for future mutable operations.
+ */
+function toBytes(data) {
+    if (typeof data === 'string')
+        data = utf8ToBytes$1(data);
+    bytes(data);
+    return data;
+}
+// For runtime check if class implements interface
+class Hash {
+    // Safe version that clones internal state
+    clone() {
+        return this._cloneInto();
+    }
+}
+function wrapConstructor(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+    const tmp = hashCons();
+    hashC.outputLen = tmp.outputLen;
+    hashC.blockLen = tmp.blockLen;
+    hashC.create = () => hashCons();
+    return hashC;
+}
+
+// Polyfill for Safari 14
+function setBigUint64(view, byteOffset, value, isLE) {
+    if (typeof view.setBigUint64 === 'function')
+        return view.setBigUint64(byteOffset, value, isLE);
+    const _32n = BigInt(32);
+    const _u32_max = BigInt(0xffffffff);
+    const wh = Number((value >> _32n) & _u32_max);
+    const wl = Number(value & _u32_max);
+    const h = isLE ? 4 : 0;
+    const l = isLE ? 0 : 4;
+    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);
+/**
+ * Merkle-Damgard hash construction base class.
+ * Could be used to create MD5, RIPEMD, SHA1, SHA2.
+ */
+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.buffer = new Uint8Array(blockLen);
+        this.view = createView(this.buffer);
+    }
+    update(data) {
+        exists(this);
+        const { view, buffer, blockLen } = this;
+        data = toBytes(data);
+        const len = data.length;
+        for (let pos = 0; pos < len;) {
+            const take = Math.min(blockLen - this.pos, len - pos);
+            // Fast path: we have at least one block in input, cast it to view and process
+            if (take === blockLen) {
+                const dataView = createView(data);
+                for (; blockLen <= len - pos; pos += blockLen)
+                    this.process(dataView, pos);
+                continue;
+            }
+            buffer.set(data.subarray(pos, pos + take), this.pos);
+            this.pos += take;
+            pos += take;
+            if (this.pos === blockLen) {
+                this.process(view, 0);
+                this.pos = 0;
+            }
+        }
+        this.length += data.length;
+        this.roundClean();
+        return this;
+    }
+    digestInto(out) {
+        exists(this);
+        output(out, this);
+        this.finished = true;
+        // Padding
+        // We can avoid allocation of buffer for padding completely if it
+        // was previously not allocated here. But it won't change performance.
+        const { buffer, view, blockLen, isLE } = this;
+        let { pos } = this;
+        // append the bit '1' to the message
+        buffer[pos++] = 0b10000000;
+        this.buffer.subarray(pos).fill(0);
+        // 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) {
+            this.process(view, 0);
+            pos = 0;
+        }
+        // Pad until full block byte with zeros
+        for (let i = pos; i < blockLen; i++)
+            buffer[i] = 0;
+        // Note: sha512 requires length to be 128bit integer, but length in JS will overflow before that
+        // You need to write around 2 exabytes (u64_max / 8 / (1024**6)) for this to happen.
+        // So we just write lowest 64 bits of that value.
+        setBigUint64(view, blockLen - 8, BigInt(this.length * 8), isLE);
+        this.process(view, 0);
+        const oview = createView(out);
+        const len = this.outputLen;
+        // NOTE: we do division by 4 later, which should be fused in single op with modulo by JIT
+        if (len % 4)
+            throw new Error('_sha2: outputLen should be aligned to 32bit');
+        const outLen = len / 4;
+        const state = this.get();
+        if (outLen > state.length)
+            throw new Error('_sha2: outputLen bigger than state');
+        for (let i = 0; i < outLen; i++)
+            oview.setUint32(4 * i, state[i], isLE);
+    }
+    digest() {
+        const { buffer, outputLen } = this;
+        this.digestInto(buffer);
+        const res = buffer.slice(0, outputLen);
+        this.destroy();
+        return res;
+    }
+    _cloneInto(to) {
+        to || (to = new this.constructor());
+        to.set(...this.get());
+        const { blockLen, buffer, length, finished, destroyed, pos } = this;
+        to.length = length;
+        to.pos = pos;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        if (length % blockLen)
+            to.buffer.set(buffer);
+        return to;
+    }
+}
+
+// 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)
+// prettier-ignore
+const SHA256_K = /* @__PURE__ */ new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,
+    0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,
+    0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,
+    0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,
+    0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,
+    0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,
+    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
+// 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.
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
+class SHA256 extends HashMD {
+    constructor() {
+        super(64, 32, 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;
+        this.B = SHA256_IV[1] | 0;
+        this.C = SHA256_IV[2] | 0;
+        this.D = SHA256_IV[3] | 0;
+        this.E = SHA256_IV[4] | 0;
+        this.F = SHA256_IV[5] | 0;
+        this.G = SHA256_IV[6] | 0;
+        this.H = SHA256_IV[7] | 0;
+    }
+    get() {
+        const { A, B, C, D, E, F, G, H } = this;
+        return [A, B, C, D, E, F, G, H];
+    }
+    // prettier-ignore
+    set(A, B, C, D, E, F, G, H) {
+        this.A = A | 0;
+        this.B = B | 0;
+        this.C = C | 0;
+        this.D = D | 0;
+        this.E = E | 0;
+        this.F = F | 0;
+        this.G = G | 0;
+        this.H = H | 0;
+    }
+    process(view, offset) {
+        // Extend the first 16 words into the remaining 48 words w[16..63] of the message schedule array
+        for (let i = 0; i < 16; i++, offset += 4)
+            SHA256_W[i] = view.getUint32(offset, false);
+        for (let i = 16; i < 64; i++) {
+            const W15 = SHA256_W[i - 15];
+            const W2 = SHA256_W[i - 2];
+            const s0 = rotr(W15, 7) ^ rotr(W15, 18) ^ (W15 >>> 3);
+            const s1 = rotr(W2, 17) ^ rotr(W2, 19) ^ (W2 >>> 10);
+            SHA256_W[i] = (s1 + SHA256_W[i - 7] + s0 + SHA256_W[i - 16]) | 0;
+        }
+        // Compression function main loop, 64 rounds
+        let { A, B, C, D, E, F, G, H } = this;
+        for (let i = 0; i < 64; i++) {
+            const sigma1 = rotr(E, 6) ^ rotr(E, 11) ^ rotr(E, 25);
+            const T1 = (H + sigma1 + Chi(E, F, G) + SHA256_K[i] + SHA256_W[i]) | 0;
+            const sigma0 = rotr(A, 2) ^ rotr(A, 13) ^ rotr(A, 22);
+            const T2 = (sigma0 + Maj(A, B, C)) | 0;
+            H = G;
+            G = F;
+            F = E;
+            E = (D + T1) | 0;
+            D = C;
+            C = B;
+            B = A;
+            A = (T1 + T2) | 0;
+        }
+        // Add the compressed chunk to the current hash value
+        A = (A + this.A) | 0;
+        B = (B + this.B) | 0;
+        C = (C + this.C) | 0;
+        D = (D + this.D) | 0;
+        E = (E + this.E) | 0;
+        F = (F + this.F) | 0;
+        G = (G + this.G) | 0;
+        H = (H + this.H) | 0;
+        this.set(A, B, C, D, E, F, G, H);
+    }
+    roundClean() {
+        SHA256_W.fill(0);
+    }
+    destroy() {
+        this.set(0, 0, 0, 0, 0, 0, 0, 0);
+        this.buffer.fill(0);
+    }
+}
+/**
+ * SHA2-256 hash function
+ * @param message - data that would be hashed
+ */
+const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
+
 var Protocols;
 (function (Protocols) {
     Protocols["Relay"] = "relay";
@@ -715,6 +1091,213 @@ var EConnectionStateEvents;
     EConnectionStateEvents["CONNECTION_STATUS"] = "waku:connection";
 })(EConnectionStateEvents || (EConnectionStateEvents = {}));
 
+/**
+ * DefaultPubsubTopic is the default gossipsub topic to use for Waku.
+ */
+/**
+ * The default cluster ID for The Waku Network
+ */
+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 = totalLength ?? 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");
+    return `/waku/2/rs/${shardInfo.clusterId ?? DEFAULT_CLUSTER_ID}/${shardInfo.shard}`;
+};
+const shardInfoToPubsubTopics = (shardInfo) => {
+    if ("contentTopics" in shardInfo && shardInfo.contentTopics) {
+        // Autosharding: explicitly defined content topics
+        return Array.from(new Set(shardInfo.contentTopics.map((contentTopic) => contentTopicToPubsubTopic(contentTopic, shardInfo.clusterId))));
+    }
+    else if ("shards" in shardInfo) {
+        // Static sharding
+        if (shardInfo.shards === undefined)
+            throw new Error("Invalid shard");
+        return Array.from(new Set(shardInfo.shards.map((index) => `/waku/2/rs/${shardInfo.clusterId ?? DEFAULT_CLUSTER_ID}/${index}`)));
+    }
+    else if ("application" in shardInfo && "version" in shardInfo) {
+        // Autosharding: single shard from application and version
+        return [
+            contentTopicToPubsubTopic(`/${shardInfo.application}/${shardInfo.version}/default/default`, shardInfo.clusterId)
+        ];
+    }
+    else {
+        throw new Error("Missing required configuration in shard parameters");
+    }
+};
+const pubsubTopicToSingleShardInfo = (pubsubTopics) => {
+    const parts = pubsubTopics.split("/");
+    if (parts.length != 6 ||
+        parts[1] !== "waku" ||
+        parts[2] !== "2" ||
+        parts[3] !== "rs")
+        throw new Error("Invalid pubsub topic");
+    const clusterId = parseInt(parts[4]);
+    const shard = parseInt(parts[5]);
+    if (isNaN(clusterId) || isNaN(shard))
+        throw new Error("Invalid clusterId or shard");
+    return {
+        clusterId,
+        shard
+    };
+};
+/**
+ * Given a string, will throw an error if it is not formatted as a valid content topic for autosharding based on https://rfc.vac.dev/spec/51/
+ * @param contentTopic String to validate
+ * @returns Object with each content topic field as an attribute
+ */
+function ensureValidContentTopic(contentTopic) {
+    const parts = contentTopic.split("/");
+    if (parts.length < 5 || parts.length > 6) {
+        throw Error("Content topic format is invalid");
+    }
+    // Validate generation field if present
+    let generation = 0;
+    if (parts.length == 6) {
+        generation = parseInt(parts[1]);
+        if (isNaN(generation)) {
+            throw new Error("Invalid generation field in content topic");
+        }
+        if (generation > 0) {
+            throw new Error("Generation greater than 0 is not supported");
+        }
+    }
+    // Validate remaining fields
+    const fields = parts.splice(-4);
+    // Validate application field
+    if (fields[0].length == 0) {
+        throw new Error("Application field cannot be empty");
+    }
+    // Validate version field
+    if (fields[1].length == 0) {
+        throw new Error("Version field cannot be empty");
+    }
+    // Validate topic name field
+    if (fields[2].length == 0) {
+        throw new Error("Topic name field cannot be empty");
+    }
+    // Validate encoding field
+    if (fields[3].length == 0) {
+        throw new Error("Encoding field cannot be empty");
+    }
+    return {
+        generation,
+        application: fields[0],
+        version: fields[1],
+        topicName: fields[2],
+        encoding: fields[3]
+    };
+}
+/**
+ * Given a string, determines which autoshard index to use for its pubsub topic.
+ * Based on the algorithm described in the RFC: https://rfc.vac.dev/spec/51//#algorithm
+ */
+function contentTopicToShardIndex(contentTopic, networkShards = 8) {
+    const { application, version } = ensureValidContentTopic(contentTopic);
+    const digest = sha256(concat([utf8ToBytes(application), utf8ToBytes(version)]));
+    const dataview = new DataView(digest.buffer.slice(-8));
+    return Number(dataview.getBigUint64(0, false) % BigInt(networkShards));
+}
+function contentTopicToPubsubTopic(contentTopic, clusterId = DEFAULT_CLUSTER_ID, networkShards = 8) {
+    if (!contentTopic) {
+        throw Error("Content topic must be specified");
+    }
+    const shardIndex = contentTopicToShardIndex(contentTopic, networkShards);
+    return `/waku/2/rs/${clusterId}/${shardIndex}`;
+}
+/**
+ * Used when creating encoders/decoders to determine which pubsub topic to use
+ */
+function determinePubsubTopic(contentTopic, pubsubTopicShardInfo) {
+    if (typeof pubsubTopicShardInfo == "string") {
+        return pubsubTopicShardInfo;
+    }
+    return pubsubTopicShardInfo?.shard !== undefined
+        ? singleShardInfoToPubsubTopic(pubsubTopicShardInfo)
+        : contentTopicToPubsubTopic(contentTopic, pubsubTopicShardInfo?.clusterId ?? DEFAULT_CLUSTER_ID);
+}
+/**
+ * Validates sharding configuration and sets defaults where possible.
+ * @returns Validated sharding parameters, with any missing values set to defaults
+ */
+const ensureShardingConfigured = (shardInfo) => {
+    const clusterId = shardInfo.clusterId ?? DEFAULT_CLUSTER_ID;
+    const shards = "shards" in shardInfo ? shardInfo.shards : [];
+    const contentTopics = "contentTopics" in shardInfo ? shardInfo.contentTopics : [];
+    const [application, version] = "application" in shardInfo && "version" in shardInfo
+        ? [shardInfo.application, shardInfo.version]
+        : [undefined, undefined];
+    const isShardsConfigured = shards && shards.length > 0;
+    const isContentTopicsConfigured = contentTopics && contentTopics.length > 0;
+    const isApplicationVersionConfigured = application && version;
+    if (isShardsConfigured) {
+        return {
+            shardingParams: { clusterId, shards },
+            shardInfo: { clusterId, shards },
+            pubsubTopics: shardInfoToPubsubTopics({ clusterId, shards })
+        };
+    }
+    if (isContentTopicsConfigured) {
+        const pubsubTopics = Array.from(new Set(contentTopics.map((topic) => contentTopicToPubsubTopic(topic, clusterId))));
+        const shards = Array.from(new Set(contentTopics.map((topic) => contentTopicToShardIndex(topic))));
+        return {
+            shardingParams: { clusterId, contentTopics },
+            shardInfo: { clusterId, shards },
+            pubsubTopics
+        };
+    }
+    if (isApplicationVersionConfigured) {
+        const pubsubTopic = contentTopicToPubsubTopic(`/${application}/${version}/default/default`, clusterId);
+        return {
+            shardingParams: { clusterId, application, version },
+            shardInfo: {
+                clusterId,
+                shards: [pubsubTopicToSingleShardInfo(pubsubTopic).shard]
+            },
+            pubsubTopics: [pubsubTopic]
+        };
+    }
+    throw new Error("Missing minimum required configuration options for static sharding or autosharding.");
+};
+
 function getDefaultExportFromCjs (x) {
 	return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, 'default') ? x['default'] : x;
 }
@@ -1441,4 +2024,32 @@ var common = setup;
 var browserExports = browser.exports;
 var debug = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
-export { EConnectionStateEvents as E, ProtocolError as P, Tags as T, Protocols as a, EPeersByDiscoveryEvents as b, base2$1 as c, base8$1 as d, base10$1 as e, base16$1 as f, getDefaultExportFromCjs as g, base32$1 as h, identityBase as i, base36$1 as j, base58 as k, base64$1 as l, base256emoji$1 as m, debug as n };
+const APP_NAME = "waku";
+class Logger {
+    _info;
+    _warn;
+    _error;
+    static createDebugNamespace(level, prefix) {
+        return prefix ? `${APP_NAME}:${level}:${prefix}` : `${APP_NAME}:${level}`;
+    }
+    constructor(prefix) {
+        this._info = debug(Logger.createDebugNamespace("info", prefix));
+        this._warn = debug(Logger.createDebugNamespace("warn", prefix));
+        this._error = debug(Logger.createDebugNamespace("error", prefix));
+    }
+    get info() {
+        return this._info;
+    }
+    get warn() {
+        return this._warn;
+    }
+    get error() {
+        return this._error;
+    }
+    log(level, ...args) {
+        const logger = this[level];
+        logger(...args);
+    }
+}
+
+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 };