@waku/core 0.0.26-7eb3375.0 → 0.0.26

package/bundle/index.js

@@ -1,15 +1,54 @@
-import { c as coerce, e as equals$2, b as base32, a as base58btc, d as commonjsGlobal, g as getAugmentedNamespace, f as getDefaultExportFromCjs } from './browser-9a6558bb.js';
-import { a as allocUnsafe, b as asUint8Array, t as toString$1, c as bases, f as fromString, u as utf8ToBytes$1, E as EConnectionStateEvents, T as Tags, d as EPeersByDiscoveryEvents, P as Protocols, e as alloc, B as BaseProtocol, S as SendError, g as concat$1 } from './base_protocol-46017f51.js';
-export { h as StreamManager } from './base_protocol-46017f51.js';
-import { L as Logger } from './index-7581d519.js';
-import { e as enumeration, m as message, a as encodeMessage, d as decodeMessage, c as createEncoder, v as version_0, M as MessagePush, F as FilterSubscribeRequest, b as FilterSubscribeResponse$1, D as DefaultPubsubTopic, P as PushRpc$1, f as PushResponse, H as HistoryRpc$1, g as PagingInfo, h as HistoryResponse } from './version_0-7190df43.js';
-export { i as createDecoder } from './version_0-7190df43.js';
+import { c as coerce, e as equals$2, b as base32, a as base58btc, d as commonjsGlobal, g as getAugmentedNamespace, E as EConnectionStateEvents, T as Tags, f as EPeersByDiscoveryEvents, P as Protocols, h as getDefaultExportFromCjs, S as SendError } from './browser-mTOOnVZp.js';
+import { a as allocUnsafe, b as asUint8Array, t as toString$1, c as bases, f as fromString, L as Logger, u as utf8ToBytes, p as pubsubTopicToSingleShardInfo, s as shardInfoToPubsubTopics, D as DefaultPubsubTopic, d as alloc, e as singleShardInfoToPubsubTopic, g as ensurePubsubTopicIsConfigured, h as sha256$1, i as concat$1 } from './index-cmONXM-V.js';
+import { e as enumeration, m as message, a as encodeMessage, d as decodeMessage, c as createEncoder, v as version_0, M as MessagePush, F as FilterSubscribeRequest, b as FilterSubscribeResponse$1, P as PushRpc$1, f as PushResponse, H as HistoryRpc$1, g as PagingInfo, h as HistoryResponse, W as WakuMetadataResponse, i as WakuMetadataRequest } from './version_0-LQTFNC7k.js';
+export { j as createDecoder } from './version_0-LQTFNC7k.js';
+import { B as BaseProtocol } from './base_protocol-pDODy0G6.js';
+export { S as StreamManager } from './base_protocol-pDODy0G6.js';
 
 const symbol$2 = Symbol.for('@libp2p/peer-id');
 function isPeerId(other) {
     return other != null && Boolean(other[symbol$2]);
 }
 
+/**
+ * On the producing side:
+ * * Build messages with the signature, key (from may be enough for certain inlineable public key types), from and seqno fields.
+ *
+ * On the consuming side:
+ * * Enforce the fields to be present, reject otherwise.
+ * * Propagate only if the fields are valid and signature can be verified, reject otherwise.
+ */
+var TopicValidatorResult$1;
+(function (TopicValidatorResult) {
+    /**
+     * The message is considered valid, and it should be delivered and forwarded to the network
+     */
+    TopicValidatorResult["Accept"] = "accept";
+    /**
+     * The message is neither delivered nor forwarded to the network
+     */
+    TopicValidatorResult["Ignore"] = "ignore";
+    /**
+     * The message is considered invalid, and it should be rejected
+     */
+    TopicValidatorResult["Reject"] = "reject";
+})(TopicValidatorResult$1 || (TopicValidatorResult$1 = {}));
+
+/**
+ * Enum Transport Manager Fault Tolerance values
+ */
+var FaultTolerance$1;
+(function (FaultTolerance) {
+    /**
+     * should be used for failing in any listen circumstance
+     */
+    FaultTolerance[FaultTolerance["FATAL_ALL"] = 0] = "FATAL_ALL";
+    /**
+     * should be used for not failing when not listening
+     */
+    FaultTolerance[FaultTolerance["NO_FATAL"] = 1] = "NO_FATAL";
+})(FaultTolerance$1 || (FaultTolerance$1 = {}));
+
 /**
  * When this error is thrown it means an operation was aborted,
  * usually in response to the `abort` event being emitted by an
@@ -1315,7 +1354,7 @@ const isV4 = isIPv4;
 const isV6 = isIPv6;
 // Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L7
 // but with buf/offset args removed because we don't use them
-const toBytes$1 = function (ip) {
+const toBytes = function (ip) {
     let offset = 0;
     ip = ip.toString().trim();
     if (isV4(ip)) {
@@ -1332,7 +1371,7 @@ const toBytes$1 = function (ip) {
             const isv4 = isV4(sections[i]);
             let v4Buffer;
             if (isv4) {
-                v4Buffer = toBytes$1(sections[i]);
+                v4Buffer = toBytes(sections[i]);
                 sections[i] = toString$1(v4Buffer.slice(0, 2), 'base16');
             }
             if (v4Buffer != null && ++i < 8) {
@@ -1570,7 +1609,7 @@ function ip2bytes(ipString) {
     if (!isIP(ipString)) {
         throw new Error('invalid ip address');
     }
-    return toBytes$1(ipString);
+    return toBytes(ipString);
 }
 function bytes2ip(ipBuff) {
     const ipString = toString(ipBuff, 0, ipBuff.length);
@@ -1841,38 +1880,17 @@ function ParseError(str) {
  * ```
  */
 const inspect = Symbol.for('nodejs.util.inspect.custom');
+const symbol$1 = Symbol.for('@multiformats/js-multiaddr/multiaddr');
 const DNS_CODES = [
     getProtocol('dns').code,
     getProtocol('dns4').code,
     getProtocol('dns6').code,
     getProtocol('dnsaddr').code
 ];
-/**
- * All configured {@link Resolver}s
- */
-const resolvers = new Map();
-const symbol$1 = Symbol.for('@multiformats/js-multiaddr/multiaddr');
-/**
- * Check if object is a {@link Multiaddr} instance
- *
- * @example
- *
- * ```js
- * import { isMultiaddr, multiaddr } from '@multiformats/multiaddr'
- *
- * isMultiaddr(5)
- * // false
- * isMultiaddr(multiaddr('/ip4/127.0.0.1'))
- * // true
- * ```
- */
-function isMultiaddr(value) {
-    return Boolean(value?.[symbol$1]);
-}
 /**
  * Creates a {@link Multiaddr} from a {@link MultiaddrInput}
  */
-class DefaultMultiaddr {
+class Multiaddr {
     bytes;
     #string;
     #tuples;
@@ -1972,8 +1990,8 @@ class DefaultMultiaddr {
         return this.#stringTuples;
     }
     encapsulate(addr) {
-        addr = new DefaultMultiaddr(addr);
-        return new DefaultMultiaddr(this.toString() + addr.toString());
+        addr = new Multiaddr(addr);
+        return new Multiaddr(this.toString() + addr.toString());
     }
     decapsulate(addr) {
         const addrString = addr.toString();
@@ -1982,13 +2000,13 @@ class DefaultMultiaddr {
         if (i < 0) {
             throw new Error(`Address ${this.toString()} does not contain subaddress: ${addr.toString()}`);
         }
-        return new DefaultMultiaddr(s.slice(0, i));
+        return new Multiaddr(s.slice(0, i));
     }
     decapsulateCode(code) {
         const tuples = this.tuples();
         for (let i = tuples.length - 1; i >= 0; i--) {
             if (tuples[i][0] === code) {
-                return new DefaultMultiaddr(tuplesToBytes(tuples.slice(0, i)));
+                return new Multiaddr(tuplesToBytes(tuples.slice(0, i)));
             }
         }
         return this;
@@ -2041,7 +2059,7 @@ class DefaultMultiaddr {
             throw new CodeError(`no available resolver for ${resolvableProto.name}`, 'ERR_NO_AVAILABLE_RESOLVER');
         }
         const addresses = await resolver(this, options);
-        return addresses.map((a) => new DefaultMultiaddr(a));
+        return addresses.map((a) => new Multiaddr(a));
     }
     nodeAddress() {
         const options = this.toOptions();
@@ -2083,6 +2101,93 @@ class DefaultMultiaddr {
         return `Multiaddr(${this.#string})`;
     }
 }
+
+/**
+ * @packageDocumentation
+ *
+ * A standard way to represent addresses that
+ *
+ * - support any standard network protocol
+ * - are self-describing
+ * - have a binary packed format
+ * - have a nice string representation
+ * - encapsulate well
+ *
+ * @example
+ *
+ * ```js
+ * import { multiaddr } from '@multiformats/multiaddr'
+ * const addr =  multiaddr("/ip4/127.0.0.1/udp/1234")
+ * // Multiaddr(/ip4/127.0.0.1/udp/1234)
+ *
+ * const addr = multiaddr("/ip4/127.0.0.1/udp/1234")
+ * // Multiaddr(/ip4/127.0.0.1/udp/1234)
+ *
+ * addr.bytes
+ * // <Uint8Array 04 7f 00 00 01 11 04 d2>
+ *
+ * addr.toString()
+ * // '/ip4/127.0.0.1/udp/1234'
+ *
+ * addr.protos()
+ * // [
+ * //   {code: 4, name: 'ip4', size: 32},
+ * //   {code: 273, name: 'udp', size: 16}
+ * // ]
+ *
+ * // gives you an object that is friendly with what Node.js core modules expect for addresses
+ * addr.nodeAddress()
+ * // {
+ * //   family: 4,
+ * //   port: 1234,
+ * //   address: "127.0.0.1"
+ * // }
+ *
+ * addr.encapsulate('/sctp/5678')
+ * // Multiaddr(/ip4/127.0.0.1/udp/1234/sctp/5678)
+ * ```
+ *
+ * ## Resolvers
+ *
+ * `multiaddr` allows multiaddrs to be resolved when appropriate resolvers are provided. This module already has resolvers available, but you can also create your own.  Resolvers should always be set in the same module that is calling `multiaddr.resolve()` to avoid conflicts if multiple versions of `multiaddr` are in your dependency tree.
+ *
+ * To provide multiaddr resolvers you can do:
+ *
+ * ```js
+ * import { resolvers  } from '@multiformats/multiaddr'
+ *
+ * resolvers.set('dnsaddr', resolvers.dnsaddrResolver)
+ * ```
+ *
+ * The available resolvers are:
+ *
+ * | Name              | type      | Description                         |
+ * | ----------------- | --------- | ----------------------------------- |
+ * | `dnsaddrResolver` | `dnsaddr` | dnsaddr resolution with TXT Records |
+ *
+ * A resolver receives a `Multiaddr` as a parameter and returns a `Promise<Array<string>>`.
+ */
+/**
+ * All configured {@link Resolver}s
+ */
+const resolvers = new Map();
+/**
+ * Check if object is a {@link Multiaddr} instance
+ *
+ * @example
+ *
+ * ```js
+ * import { isMultiaddr, multiaddr } from '@multiformats/multiaddr'
+ *
+ * isMultiaddr(5)
+ * // false
+ * isMultiaddr(multiaddr('/ip4/127.0.0.1'))
+ * // true
+ * ```
+ */
+function isMultiaddr(value) {
+    return Boolean(value?.[symbol$1]);
+}
 /**
  * A function that takes a {@link MultiaddrInput} and returns a {@link Multiaddr}
  *
@@ -2097,7 +2202,7 @@ class DefaultMultiaddr {
  * @param {MultiaddrInput} [addr] - If String or Uint8Array, needs to adhere to the address format of a [multiaddr](https://github.com/multiformats/multiaddr#string-format)
  */
 function multiaddr(addr) {
-    return new DefaultMultiaddr(addr);
+    return new Multiaddr(addr);
 }
 
 function isDefined(value) {
@@ -2185,308 +2290,6 @@ async function isMessageSizeUnderCap(encoder, message) {
 }
 const isWireSizeUnderCap = (buf) => buf.length / MB <= SIZE_CAP_IN_MB;
 
-function bytes(b, ...lengths) {
-    if (!(b instanceof Uint8Array))
-        throw new Error('Expected Uint8Array');
-    if (lengths.length > 0 && !lengths.includes(b.length))
-        throw new Error(`Expected Uint8Array 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, we can just drop the import.
-const u8a = (a) => a instanceof Uint8Array;
-// 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);
-// big-endian hardware is rare. Just in case someone still decides to run hashes:
-// early-throw an error because we don't support BE yet.
-const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
-if (!isLE)
-    throw new Error('Non little-endian hardware is not supported');
-/**
- * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
- */
-function utf8ToBytes(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(data);
-    if (!u8a(data))
-        throw new Error(`expected Uint8Array, got ${typeof 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);
-}
-// Base SHA2 class (RFC 6234)
-class SHA2 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.
-// 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);
-// 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 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 SHA2 {
-    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 = IV[0] | 0;
-        this.B = IV[1] | 0;
-        this.C = IV[2] | 0;
-        this.D = IV[3] | 0;
-        this.E = IV[4] | 0;
-        this.F = IV[5] | 0;
-        this.G = IV[6] | 0;
-        this.H = 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$1 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
-
-const shardInfoToPubsubTopics = (shardInfo) => {
-    return shardInfo.indexList.map((index) => `/waku/2/rs/${shardInfo.cluster}/${index}`);
-};
-function ensurePubsubTopicIsConfigured(pubsubTopic, configuredTopics) {
-    if (!configuredTopics.includes(pubsubTopic)) {
-        throw new Error(`Pubsub topic ${pubsubTopic} has not been configured on this instance. Configured topics are: ${configuredTopics}. Please update your configuration by passing in the topic during Waku node instantiation.`);
-    }
-}
-
 /**
  * Adds types to the EventTarget class. Hopefully this won't be necessary forever.
  *
@@ -18272,6 +18075,45 @@ function createPbkdf2Params(salt, countBytes, dkLen, prfAlgorithm) {
   return params;
 }
 
+/**
+ * On the producing side:
+ * * Build messages with the signature, key (from may be enough for certain inlineable public key types), from and seqno fields.
+ *
+ * On the consuming side:
+ * * Enforce the fields to be present, reject otherwise.
+ * * Propagate only if the fields are valid and signature can be verified, reject otherwise.
+ */
+var TopicValidatorResult;
+(function (TopicValidatorResult) {
+    /**
+     * The message is considered valid, and it should be delivered and forwarded to the network
+     */
+    TopicValidatorResult["Accept"] = "accept";
+    /**
+     * The message is neither delivered nor forwarded to the network
+     */
+    TopicValidatorResult["Ignore"] = "ignore";
+    /**
+     * The message is considered invalid, and it should be rejected
+     */
+    TopicValidatorResult["Reject"] = "reject";
+})(TopicValidatorResult || (TopicValidatorResult = {}));
+
+/**
+ * Enum Transport Manager Fault Tolerance values
+ */
+var FaultTolerance;
+(function (FaultTolerance) {
+    /**
+     * should be used for failing in any listen circumstance
+     */
+    FaultTolerance[FaultTolerance["FATAL_ALL"] = 0] = "FATAL_ALL";
+    /**
+     * should be used for not failing when not listening
+     */
+    FaultTolerance[FaultTolerance["NO_FATAL"] = 1] = "NO_FATAL";
+})(FaultTolerance || (FaultTolerance = {}));
+
 /* eslint-disable import/export */
 /* eslint-disable complexity */
 /* eslint-disable @typescript-eslint/no-namespace */
@@ -18992,15 +18834,15 @@ const decodeRelayShard = (bytes) => {
     if (bytes.length < 3)
         throw new Error("Insufficient data");
     const view = new DataView(bytes.buffer);
-    const cluster = view.getUint16(0);
-    const indexList = [];
+    const clusterId = view.getUint16(0);
+    const shards = [];
     if (bytes.length === 130) {
         // rsv format (Bit Vector)
         for (let i = 0; i < 1024; i++) {
             const byteIndex = Math.floor(i / 8) + 2; // Adjusted for the 2-byte cluster field
             const bitIndex = 7 - (i % 8);
             if (view.getUint8(byteIndex) & (1 << bitIndex)) {
-                indexList.push(i);
+                shards.push(i);
             }
         }
     }
@@ -19010,10 +18852,33 @@ const decodeRelayShard = (bytes) => {
         for (let i = 0, offset = 3; i < numIndices; i++, offset += 2) {
             if (offset + 1 >= bytes.length)
                 throw new Error("Unexpected end of data");
-            indexList.push(view.getUint16(offset));
+            shards.push(view.getUint16(offset));
+        }
+    }
+    return { clusterId, shards };
+};
+const encodeRelayShard = (shardInfo) => {
+    const { clusterId, shards } = shardInfo;
+    const totalLength = shards.length >= 64 ? 130 : 3 + 2 * shards.length;
+    const buffer = new ArrayBuffer(totalLength);
+    const view = new DataView(buffer);
+    view.setUint16(0, clusterId);
+    if (shards.length >= 64) {
+        // rsv format (Bit Vector)
+        for (const index of shards) {
+            const byteIndex = Math.floor(index / 8) + 2; // Adjusted for the 2-byte cluster field
+            const bitIndex = 7 - (index % 8);
+            view.setUint8(byteIndex, view.getUint8(byteIndex) | (1 << bitIndex));
+        }
+    }
+    else {
+        // rs format (Index List)
+        view.setUint8(2, shards.length);
+        for (let i = 0, offset = 3; i < shards.length; i++, offset += 2) {
+            view.setUint16(offset, shards[i]);
         }
     }
-    return { cluster, indexList };
+    return new Uint8Array(buffer);
 };
 
 new Logger("enr");
@@ -19033,7 +18898,7 @@ var TransportProtocolPerIpVersion;
 new Logger("enr:decoder");
 
 const RelayPingContentTopic = "/relay-ping/1/ping/null";
-const log$6 = new Logger("keep-alive");
+const log$7 = new Logger("keep-alive");
 class KeepAliveManager {
     pingKeepAliveTimers;
     relayKeepAliveTimers;
@@ -19061,10 +18926,10 @@ class KeepAliveManager {
                         // also update the peer store with the latency
                         try {
                             ping = await libp2pPing.ping(peerId);
-                            log$6.info(`Ping succeeded (${peerIdStr})`, ping);
+                            log$7.info(`Ping succeeded (${peerIdStr})`, ping);
                         }
                         catch (error) {
-                            log$6.error(`Ping failed for peer (${peerIdStr}).
+                            log$7.error(`Ping failed for peer (${peerIdStr}).
                 Next ping will be attempted in ${pingPeriodSecs} seconds.
               `);
                             return;
@@ -19072,16 +18937,16 @@ class KeepAliveManager {
                         try {
                             await peerStore.patch(peerId, {
                                 metadata: {
-                                    ping: utf8ToBytes$1(ping.toString())
+                                    ping: utf8ToBytes(ping.toString())
                                 }
                             });
                         }
                         catch (e) {
-                            log$6.error("Failed to update ping", e);
+                            log$7.error("Failed to update ping", e);
                         }
                     }
                     catch (e) {
-                        log$6.error(`Ping failed (${peerIdStr})`, e);
+                        log$7.error(`Ping failed (${peerIdStr})`, e);
                     }
                 })();
             }, pingPeriodSecs * 1000);
@@ -19125,15 +18990,15 @@ class KeepAliveManager {
             if (!meshPeers.includes(peerIdStr))
                 continue;
             const encoder = createEncoder({
-                pubsubTopic: topic,
+                pubsubTopicShardInfo: pubsubTopicToSingleShardInfo(topic),
                 contentTopic: RelayPingContentTopic,
                 ephemeral: true
             });
             const interval = setInterval(() => {
-                log$6.info("Sending Waku Relay ping message");
+                log$7.info("Sending Waku Relay ping message");
                 relay
                     .send(encoder, { payload: new Uint8Array([1]) })
-                    .catch((e) => log$6.error("Failed to send relay ping", e));
+                    .catch((e) => log$7.error("Failed to send relay ping", e));
             }, relayPeriodSecs * 1000);
             intervals.push(interval);
         }
@@ -19141,7 +19006,7 @@ class KeepAliveManager {
     }
 }
 
-const log$5 = new Logger("connection-manager");
+const log$6 = new Logger("connection-manager");
 const DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED = 1;
 const DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER = 3;
 const DEFAULT_MAX_PARALLEL_DIALS = 3;
@@ -19235,12 +19100,12 @@ class ConnectionManager extends EventEmitter {
         };
         this.keepAliveManager = new KeepAliveManager(keepAliveOptions, relay);
         this.run()
-            .then(() => log$5.info(`Connection Manager is now running`))
-            .catch((error) => log$5.error(`Unexpected error while running service`, error));
+            .then(() => log$6.info(`Connection Manager is now running`))
+            .catch((error) => log$6.error(`Unexpected error while running service`, error));
         // libp2p emits `peer:discovery` events during its initialization
         // which means that before the ConnectionManager is initialized, some peers may have been discovered
         // we will dial the peers in peerStore ONCE before we start to listen to the `peer:discovery` events within the ConnectionManager
-        this.dialPeerStorePeers().catch((error) => log$5.error(`Unexpected error while dialing peer store peers`, error));
+        this.dialPeerStorePeers().catch((error) => log$6.error(`Unexpected error while dialing peer store peers`, error));
     }
     async dialPeerStorePeers() {
         const peerInfos = await this.libp2p.peerStore.all();
@@ -19254,7 +19119,7 @@ class ConnectionManager extends EventEmitter {
             await Promise.all(dialPromises);
         }
         catch (error) {
-            log$5.error(`Unexpected error while dialing peer store peers`, error);
+            log$6.error(`Unexpected error while dialing peer store peers`, error);
         }
     }
     async run() {
@@ -19274,7 +19139,7 @@ class ConnectionManager extends EventEmitter {
         let dialAttempt = 0;
         while (dialAttempt < this.options.maxDialAttemptsForPeer) {
             try {
-                log$5.info(`Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`);
+                log$6.info(`Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`);
                 await this.libp2p.dial(peerId);
                 const tags = await this.getTagNamesForPeer(peerId);
                 // add tag to connection describing discovery mechanism
@@ -19291,11 +19156,11 @@ class ConnectionManager extends EventEmitter {
             catch (error) {
                 if (error instanceof AggregateError) {
                     // Handle AggregateError
-                    log$5.error(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
+                    log$6.error(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
                 }
                 else {
                     // Handle generic error
-                    log$5.error(`Error dialing peer ${peerId.toString()} - ${error.message}`);
+                    log$6.error(`Error dialing peer ${peerId.toString()} - ${error.message}`);
                 }
                 this.dialErrorsForPeer.set(peerId.toString(), error);
                 dialAttempt++;
@@ -19313,10 +19178,10 @@ class ConnectionManager extends EventEmitter {
                     let errorMessage;
                     if (error instanceof AggregateError) {
                         if (!error.errors) {
-                            log$5.warn(`No errors array found for AggregateError`);
+                            log$6.warn(`No errors array found for AggregateError`);
                         }
                         else if (error.errors.length === 0) {
-                            log$5.warn(`Errors array is empty for AggregateError`);
+                            log$6.warn(`Errors array is empty for AggregateError`);
                         }
                         else {
                             errorMessage = JSON.stringify(error.errors[0]);
@@ -19325,7 +19190,7 @@ class ConnectionManager extends EventEmitter {
                     else {
                         errorMessage = error.message;
                     }
-                    log$5.info(`Deleting undialable peer ${peerId.toString()} from peer store. Reason: ${errorMessage}`);
+                    log$6.info(`Deleting undialable peer ${peerId.toString()} from peer store. Reason: ${errorMessage}`);
                 }
                 this.dialErrorsForPeer.delete(peerId.toString());
                 await this.libp2p.peerStore.delete(peerId);
@@ -19339,10 +19204,10 @@ class ConnectionManager extends EventEmitter {
         try {
             this.keepAliveManager.stop(peerId);
             await this.libp2p.hangUp(peerId);
-            log$5.info(`Dropped connection with peer ${peerId.toString()}`);
+            log$6.info(`Dropped connection with peer ${peerId.toString()}`);
         }
         catch (error) {
-            log$5.error(`Error dropping connection with peer ${peerId.toString()} - ${error}`);
+            log$6.error(`Error dropping connection with peer ${peerId.toString()} - ${error}`);
         }
     }
     processDialQueue() {
@@ -19352,7 +19217,7 @@ class ConnectionManager extends EventEmitter {
             if (!peerId)
                 return;
             this.attemptDial(peerId).catch((error) => {
-                log$5.error(error);
+                log$6.error(error);
             });
         }
     }
@@ -19385,7 +19250,7 @@ class ConnectionManager extends EventEmitter {
             return;
         }
         this.dialPeer(peerId).catch((err) => {
-            log$5.error(`Error dialing peer ${peerId.toString()} : ${err}`);
+            log$6.error(`Error dialing peer ${peerId.toString()} : ${err}`);
         });
     }
     onEventHandlers = {
@@ -19397,7 +19262,7 @@ class ConnectionManager extends EventEmitter {
                     await this.attemptDial(peerId);
                 }
                 catch (error) {
-                    log$5.error(`Error dialing peer ${peerId.toString()} : ${error}`);
+                    log$6.error(`Error dialing peer ${peerId.toString()} : ${error}`);
                 }
             })();
         },
@@ -19447,24 +19312,24 @@ class ConnectionManager extends EventEmitter {
         // if we're already connected to the peer, don't dial
         const isConnected = this.libp2p.getConnections(peerId).length > 0;
         if (isConnected) {
-            log$5.warn(`Already connected to peer ${peerId.toString()}. Not dialing.`);
+            log$6.warn(`Already connected to peer ${peerId.toString()}. Not dialing.`);
             return false;
         }
         // if the peer is not part of any of the configured pubsub topics, don't dial
         if (!(await this.isPeerTopicConfigured(peerId))) {
             const shardInfo = await this.getPeerShardInfo(peerId, this.libp2p.peerStore);
-            log$5.warn(`Discovered peer ${peerId.toString()} with ShardInfo ${shardInfo} is not part of any of the configured pubsub topics (${this.configuredPubsubTopics}).
+            log$6.warn(`Discovered peer ${peerId.toString()} with ShardInfo ${shardInfo} is not part of any of the configured pubsub topics (${this.configuredPubsubTopics}).
             Not dialing.`);
             return false;
         }
         // if the peer is not dialable based on bootstrap status, don't dial
         if (!(await this.isPeerDialableBasedOnBootstrapStatus(peerId))) {
-            log$5.warn(`Peer ${peerId.toString()} is not dialable based on bootstrap status. Not dialing.`);
+            log$6.warn(`Peer ${peerId.toString()} is not dialable based on bootstrap status. Not dialing.`);
             return false;
         }
         // If the peer is already already has an active dial attempt, or has been dialed before, don't dial it
         if (this.dialAttemptsForPeer.has(peerId.toString())) {
-            log$5.warn(`Peer ${peerId.toString()} has already been attempted dial before, or already has a dial attempt in progress, skipping dial`);
+            log$6.warn(`Peer ${peerId.toString()} has already been attempted dial before, or already has a dial attempt in progress, skipping dial`);
             return false;
         }
         return true;
@@ -19508,7 +19373,7 @@ class ConnectionManager extends EventEmitter {
             return Array.from(peer.tags.keys());
         }
         catch (error) {
-            log$5.error(`Failed to get peer ${peerId}, error: ${error}`);
+            log$6.error(`Failed to get peer ${peerId}, error: ${error}`);
             return [];
         }
     }
@@ -19533,17 +19398,23 @@ class ConnectionManager extends EventEmitter {
 const DefaultPingKeepAliveValueSecs = 5 * 60;
 const DefaultRelayKeepAliveValueSecs = 5 * 60;
 const DefaultUserAgent = "js-waku";
-const log$4 = new Logger("waku");
+const log$5 = new Logger("waku");
 class WakuNode {
-    pubsubTopics;
     libp2p;
     relay;
     store;
     filter;
     lightPush;
     connectionManager;
-    constructor(options, pubsubTopics, libp2p, store, lightPush, filter, relay) {
-        this.pubsubTopics = pubsubTopics;
+    pubsubTopics;
+    constructor(options, pubsubTopics = [], libp2p, pubsubShardInfo, store, lightPush, filter, relay) {
+        if (!pubsubShardInfo) {
+            this.pubsubTopics =
+                pubsubTopics.length > 0 ? pubsubTopics : [DefaultPubsubTopic];
+        }
+        else {
+            this.pubsubTopics = shardInfoToPubsubTopics(pubsubShardInfo);
+        }
         this.libp2p = libp2p;
         if (store) {
             this.store = store(libp2p);
@@ -19562,8 +19433,8 @@ class WakuNode {
             ? options.relayKeepAlive || DefaultRelayKeepAliveValueSecs
             : 0;
         const peerId = this.libp2p.peerId.toString();
-        this.connectionManager = ConnectionManager.create(peerId, libp2p, { pingKeepAlive, relayKeepAlive }, pubsubTopics, this.relay);
-        log$4.info("Waku node created", peerId, `relay: ${!!this.relay}, store: ${!!this.store}, light push: ${!!this
+        this.connectionManager = ConnectionManager.create(peerId, libp2p, { pingKeepAlive, relayKeepAlive }, this.pubsubTopics, this.relay);
+        log$5.info("Waku node created", peerId, `relay: ${!!this.relay}, store: ${!!this.store}, light push: ${!!this
             .lightPush}, filter: ${!!this.filter}`);
     }
     /**
@@ -19587,7 +19458,7 @@ class WakuNode {
                 this.relay.gossipSub.multicodecs.forEach((codec) => codecs.push(codec));
             }
             else {
-                log$4.error("Relay codec not included in dial codec: protocol not mounted locally");
+                log$5.error("Relay codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.Store)) {
@@ -19595,7 +19466,7 @@ class WakuNode {
                 codecs.push(this.store.multicodec);
             }
             else {
-                log$4.error("Store codec not included in dial codec: protocol not mounted locally");
+                log$5.error("Store codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.LightPush)) {
@@ -19603,7 +19474,7 @@ class WakuNode {
                 codecs.push(this.lightPush.multicodec);
             }
             else {
-                log$4.error("Light Push codec not included in dial codec: protocol not mounted locally");
+                log$5.error("Light Push codec not included in dial codec: protocol not mounted locally");
             }
         }
         if (_protocols.includes(Protocols.Filter)) {
@@ -19611,10 +19482,10 @@ class WakuNode {
                 codecs.push(this.filter.multicodec);
             }
             else {
-                log$4.error("Filter codec not included in dial codec: protocol not mounted locally");
+                log$5.error("Filter codec not included in dial codec: protocol not mounted locally");
             }
         }
-        log$4.info(`Dialing to ${peerId.toString()} with protocols ${_protocols}`);
+        log$5.info(`Dialing to ${peerId.toString()} with protocols ${_protocols}`);
         return this.libp2p.dialProtocol(peerId, codecs);
     }
     async start() {
@@ -21071,7 +20942,7 @@ class FilterSubscribeResponse {
     }
 }
 
-const log$3 = new Logger("filter:v2");
+const log$4 = new Logger("filter:v2");
 const FilterCodecs = {
     SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
     PUSH: "/vac/waku/filter-push/2.0.0-beta1"
@@ -21108,7 +20979,7 @@ class Subscription {
             if (statusCode < 200 || statusCode >= 300) {
                 throw new Error(`Filter subscribe request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             }
-            log$3.info("Subscribed to peer ", this.peer.id.toString(), "for content topics", contentTopics);
+            log$4.info("Subscribed to peer ", this.peer.id.toString(), "for content topics", contentTopics);
         }
         catch (e) {
             throw new Error("Error subscribing to peer: " +
@@ -21158,10 +21029,10 @@ class Subscription {
             if (statusCode < 200 || statusCode >= 300) {
                 throw new Error(`Filter ping request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             }
-            log$3.info("Ping successful");
+            log$4.info("Ping successful");
         }
         catch (error) {
-            log$3.error("Error pinging: ", error);
+            log$4.error("Error pinging: ", error);
             throw new Error("Error pinging: " + error);
         }
     }
@@ -21178,7 +21049,7 @@ class Subscription {
                 throw new Error(`Filter unsubscribe all request ${requestId} failed with status code ${statusCode}: ${statusDesc}`);
             }
             this.subscriptionCallbacks.clear();
-            log$3.info("Unsubscribed from all content topics");
+            log$4.info("Unsubscribed from all content topics");
         }
         catch (error) {
             throw new Error("Error unsubscribing from all content topics: " + error);
@@ -21188,7 +21059,7 @@ class Subscription {
         const contentTopic = message.contentTopic;
         const subscriptionCallback = this.subscriptionCallbacks.get(contentTopic);
         if (!subscriptionCallback) {
-            log$3.error("No subscription callback available for ", contentTopic);
+            log$4.error("No subscription callback available for ", contentTopic);
             return;
         }
         await pushMessage(subscriptionCallback, this.pubsubTopic, message);
@@ -21207,13 +21078,16 @@ class Filter extends BaseProtocol {
     }
     constructor(libp2p, options) {
         super(FilterCodecs.SUBSCRIBE, libp2p.components);
-        this.pubsubTopics = options?.pubsubTopics || [DefaultPubsubTopic];
+        this.pubsubTopics = this.initializePubsubTopic(options);
         libp2p.handle(FilterCodecs.PUSH, this.onRequest.bind(this)).catch((e) => {
-            log$3.error("Failed to register ", FilterCodecs.PUSH, e);
+            log$4.error("Failed to register ", FilterCodecs.PUSH, e);
         });
         this.activeSubscriptions = new Map();
     }
-    async createSubscription(pubsubTopic = DefaultPubsubTopic) {
+    async createSubscription(pubsubTopicShardInfo = DefaultPubsubTopic) {
+        const pubsubTopic = typeof pubsubTopicShardInfo == "string"
+            ? pubsubTopicShardInfo
+            : singleShardInfoToPubsubTopic(pubsubTopicShardInfo);
         ensurePubsubTopicIsConfigured(pubsubTopic, this.pubsubTopics);
         //TODO: get a relevant peer for the topic/shard
         // https://github.com/waku-org/js-waku/pull/1586#discussion_r1336428230
@@ -21258,29 +21132,29 @@ class Filter extends BaseProtocol {
                     const response = FilterPushRpc.decode(bytes.slice());
                     const { pubsubTopic, wakuMessage } = response;
                     if (!wakuMessage) {
-                        log$3.error("Received empty message");
+                        log$4.error("Received empty message");
                         return;
                     }
                     if (!pubsubTopic) {
-                        log$3.error("Pubsub topic missing from push message");
+                        log$4.error("Pubsub topic missing from push message");
                         return;
                     }
                     const peerIdStr = streamData.connection.remotePeer.toString();
                     const subscription = this.getActiveSubscription(pubsubTopic, peerIdStr);
                     if (!subscription) {
-                        log$3.error(`No subscription locally registered for topic ${pubsubTopic}`);
+                        log$4.error(`No subscription locally registered for topic ${pubsubTopic}`);
                         return;
                     }
                     await subscription.processMessage(wakuMessage);
                 }
             }).then(() => {
-                log$3.info("Receiving pipe closed.");
+                log$4.info("Receiving pipe closed.");
             }, (e) => {
-                log$3.error("Error with receiving pipe", e);
+                log$4.error("Error with receiving pipe", e);
             });
         }
         catch (e) {
-            log$3.error("Error decoding message", e);
+            log$4.error("Error decoding message", e);
         }
     }
 }
@@ -21291,7 +21165,7 @@ async function pushMessage(subscriptionCallback, pubsubTopic, message) {
     const { decoders, callback } = subscriptionCallback;
     const { contentTopic } = message;
     if (!contentTopic) {
-        log$3.warn("Message has no content topic, skipping");
+        log$4.warn("Message has no content topic, skipping");
         return;
     }
     try {
@@ -21302,7 +21176,7 @@ async function pushMessage(subscriptionCallback, pubsubTopic, message) {
         await callback(decodedMessage);
     }
     catch (e) {
-        log$3.error("Error decoding message", e);
+        log$4.error("Error decoding message", e);
     }
 }
 
@@ -21342,7 +21216,7 @@ class PushRpc {
     }
 }
 
-const log$2 = new Logger("light-push");
+const log$3 = new Logger("light-push");
 const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 /**
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
@@ -21352,21 +21226,21 @@ class LightPush extends BaseProtocol {
     NUM_PEERS_PROTOCOL = 1;
     constructor(libp2p, options) {
         super(LightPushCodec, libp2p.components);
-        this.pubsubTopics = options?.pubsubTopics ?? [DefaultPubsubTopic];
+        this.pubsubTopics = this.initializePubsubTopic(options);
     }
     async preparePushMessage(encoder, message, pubsubTopic) {
         try {
             if (!message.payload || message.payload.length === 0) {
-                log$2.error("Failed to send waku light push: payload is empty");
+                log$3.error("Failed to send waku light push: payload is empty");
                 return { query: null, error: SendError.EMPTY_PAYLOAD };
             }
             if (!(await isMessageSizeUnderCap(encoder, message))) {
-                log$2.error("Failed to send waku light push: message is bigger than 1MB");
+                log$3.error("Failed to send waku light push: message is bigger than 1MB");
                 return { query: null, error: SendError.SIZE_TOO_BIG };
             }
             const protoMessage = await encoder.toProtoObj(message);
             if (!protoMessage) {
-                log$2.error("Failed to encode to protoMessage, aborting push");
+                log$3.error("Failed to encode to protoMessage, aborting push");
                 return {
                     query: null,
                     error: SendError.ENCODE_FAILED
@@ -21376,7 +21250,7 @@ class LightPush extends BaseProtocol {
             return { query, error: null };
         }
         catch (error) {
-            log$2.error("Failed to prepare push message", error);
+            log$3.error("Failed to prepare push message", error);
             return {
                 query: null,
                 error: SendError.GENERIC_FAIL
@@ -21411,7 +21285,7 @@ class LightPush extends BaseProtocol {
                 stream = await this.getStream(peer);
             }
             catch (err) {
-                log$2.error(`Failed to get a stream for remote peer${peer.id.toString()}`, err);
+                log$3.error(`Failed to get a stream for remote peer${peer.id.toString()}`, err);
                 return { recipients, error: SendError.REMOTE_PEER_FAULT };
             }
             let res;
@@ -21419,7 +21293,7 @@ class LightPush extends BaseProtocol {
                 res = await pipe([query.encode()], encode, stream, decode, async (source) => await all(source));
             }
             catch (err) {
-                log$2.error("Failed to send waku light push request", err);
+                log$3.error("Failed to send waku light push request", err);
                 return { recipients, error: SendError.GENERIC_FAIL };
             }
             const bytes = new Uint8ArrayList();
@@ -21431,15 +21305,15 @@ class LightPush extends BaseProtocol {
                 response = PushRpc.decode(bytes).response;
             }
             catch (err) {
-                log$2.error("Failed to decode push reply", err);
+                log$3.error("Failed to decode push reply", err);
                 return { recipients, error: SendError.DECODE_FAILED };
             }
             if (!response) {
-                log$2.error("Remote peer fault: No response in PushRPC");
+                log$3.error("Remote peer fault: No response in PushRPC");
                 return { recipients, error: SendError.REMOTE_PEER_FAULT };
             }
             if (!response.isSuccess) {
-                log$2.error("Remote peer rejected the message: ", response.info);
+                log$3.error("Remote peer rejected the message: ", response.info);
                 return { recipients, error: SendError.REMOTE_PEER_REJECTED };
             }
             recipients.some((recipient) => recipient.equals(peer.id)) ||
@@ -21552,7 +21426,7 @@ function directionToProto(pageDirection) {
 }
 
 var HistoryError = HistoryResponse.HistoryError;
-const log$1 = new Logger("store");
+const log$2 = new Logger("store");
 const StoreCodec = "/vac/waku/store/2.0.0-beta4";
 const DefaultPageSize = 10;
 /**
@@ -21565,7 +21439,7 @@ class Store extends BaseProtocol {
     NUM_PEERS_PROTOCOL = 1;
     constructor(libp2p, options) {
         super(StoreCodec, libp2p.components);
-        this.pubsubTopics = options?.pubsubTopics ?? [DefaultPubsubTopic];
+        this.pubsubTopics = this.initializePubsubTopic(options);
     }
     /**
      * Processes messages based on the provided callback and options.
@@ -21733,7 +21607,7 @@ async function* paginate(streamFactory, queryOpts, decoders, cursor) {
     while (true) {
         queryOpts.cursor = currentCursor;
         const historyRpcQuery = HistoryRpc.createQuery(queryOpts);
-        log$1.info("Querying store peer", `for (${queryOpts.pubsubTopic})`, queryOpts.contentTopics);
+        log$2.info("Querying store peer", `for (${queryOpts.pubsubTopic})`, queryOpts.contentTopics);
         const stream = await streamFactory();
         const res = await pipe([historyRpcQuery.encode()], encode, stream, decode, async (source) => await all(source));
         const bytes = new Uint8ArrayList();
@@ -21742,7 +21616,7 @@ async function* paginate(streamFactory, queryOpts, decoders, cursor) {
         });
         const reply = historyRpcQuery.decode(bytes);
         if (!reply.response) {
-            log$1.warn("Stopping pagination due to store `response` field missing");
+            log$2.warn("Stopping pagination due to store `response` field missing");
             break;
         }
         const response = reply.response;
@@ -21750,10 +21624,10 @@ async function* paginate(streamFactory, queryOpts, decoders, cursor) {
             throw "History response contains an Error: " + response.error;
         }
         if (!response.messages || !response.messages.length) {
-            log$1.warn("Stopping pagination due to store `response.messages` field missing or empty");
+            log$2.warn("Stopping pagination due to store `response.messages` field missing or empty");
             break;
         }
-        log$1.error(`${response.messages.length} messages retrieved from store`);
+        log$2.error(`${response.messages.length} messages retrieved from store`);
         yield response.messages.map((protoMsg) => {
             const contentTopic = protoMsg.contentTopic;
             if (typeof contentTopic !== "undefined") {
@@ -21768,7 +21642,7 @@ async function* paginate(streamFactory, queryOpts, decoders, 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$1.warn("Stopping pagination due to `response.pagingInfo.cursor` missing from store response");
+            log$2.warn("Stopping pagination due to `response.pagingInfo.cursor` missing from store response");
             break;
         }
         currentCursor = nextCursor;
@@ -21790,7 +21664,7 @@ async function createCursor(message) {
         !message.contentTopic) {
         throw new Error("Message is missing required fields");
     }
-    const contentTopicBytes = utf8ToBytes$1(message.contentTopic);
+    const contentTopicBytes = utf8ToBytes(message.contentTopic);
     const digest = sha256$1(concat$1([contentTopicBytes, message.payload]));
     const messageTime = BigInt(message.timestamp.getTime()) * BigInt(1000000);
     return {
@@ -22045,7 +21919,7 @@ function pEvent(emitter, event, options) {
 	return promise;
 }
 
-const log = new Logger("wait-for-remote-peer");
+const log$1 = new Logger("wait-for-remote-peer");
 /**
  * Wait for a remote peer to be ready given the passed protocols.
  * Must be used after attempting to connect to nodes, using
@@ -22104,7 +21978,7 @@ async function waitForConnectedPeer(protocol) {
     const codec = protocol.multicodec;
     const peers = await protocol.peers();
     if (peers.length) {
-        log.info(`${codec} peer found: `, peers[0].id.toString());
+        log$1.info(`${codec} peer found: `, peers[0].id.toString());
         return;
     }
     await new Promise((resolve) => {
@@ -22152,4 +22026,63 @@ function getEnabledProtocols(waku) {
     return protocols;
 }
 
-export { ConnectionManager, DefaultPubsubTopic, DefaultUserAgent, FilterCodecs, KeepAliveManager, PageDirection, WakuNode, createCursor, createEncoder, index$3 as message, waitForRemotePeer, waku, wakuFilter, wakuLightPush, wakuStore, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };
+const log = new Logger("metadata");
+const MetadataCodec = "/vac/waku/metadata/1.0.0";
+class Metadata extends BaseProtocol {
+    shardInfo;
+    libp2pComponents;
+    constructor(shardInfo, libp2p) {
+        super(MetadataCodec, libp2p.components);
+        this.libp2pComponents = libp2p;
+        this.shardInfo = shardInfo;
+        void libp2p.registrar.handle(MetadataCodec, (streamData) => {
+            void this.onRequest(streamData);
+        });
+    }
+    /**
+     * Handle an incoming metadata request
+     */
+    async onRequest(streamData) {
+        try {
+            const { stream, connection } = streamData;
+            const encodedShardInfo = WakuMetadataResponse.encode(this.shardInfo);
+            const encodedResponse = await pipe([encodedShardInfo], encode, stream, decode, async (source) => await all(source));
+            const remoteShardInfoResponse = this.decodeMetadataResponse(encodedResponse);
+            // add or update the shardInfo to peer store
+            await this.libp2pComponents.peerStore.merge(connection.remotePeer, {
+                metadata: {
+                    shardInfo: encodeRelayShard(remoteShardInfoResponse)
+                }
+            });
+        }
+        catch (error) {
+            log.error("Error handling metadata request", error);
+        }
+    }
+    /**
+     * Make a metadata query to a peer
+     */
+    async query(peerId) {
+        const request = WakuMetadataRequest.encode(this.shardInfo);
+        const peer = await this.getPeer(peerId);
+        const stream = await this.getStream(peer);
+        const encodedResponse = await pipe([request], encode, stream, decode, async (source) => await all(source));
+        const decodedResponse = this.decodeMetadataResponse(encodedResponse);
+        return decodedResponse;
+    }
+    decodeMetadataResponse(encodedResponse) {
+        const bytes = new Uint8ArrayList();
+        encodedResponse.forEach((chunk) => {
+            bytes.append(chunk);
+        });
+        const response = WakuMetadataResponse.decode(bytes);
+        if (!response)
+            log.error("Error decoding metadata response");
+        return response;
+    }
+}
+function wakuMetadata(shardInfo) {
+    return (components) => new Metadata(shardInfo, components);
+}
+
+export { ConnectionManager, DefaultUserAgent, FilterCodecs, KeepAliveManager, LightPushCodec, MetadataCodec, PageDirection, WakuNode, createCursor, createEncoder, index$3 as message, waitForRemotePeer, waku, wakuFilter, wakuLightPush, wakuMetadata, wakuStore, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };