@waku/core 0.0.26-678635e.0 → 0.0.26

package/bundle/index.js

@@ -1,15 +1,54 @@
-import { c as coerce$1, e as equals$2, b as base32, a as base58btc, d as allocUnsafe, f as asUint8Array, t as toString$1, g as bases, h as fromString, u as utf8ToBytes$1, T as Tags, E as EPeersByDiscoveryEvents, P as Protocols, i as alloc, B as BaseProtocol, S as SendError, j as concat$1 } from './base_protocol-4bcf7514.js';
-export { k as StreamManager } from './base_protocol-4bcf7514.js';
-import { L as Logger } from './index-27b91e3b.js';
-import { c as commonjsGlobal, g as getAugmentedNamespace, a as getDefaultExportFromCjs } from './browser-90197c87.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-2f1176e3.js';
-export { i as createDecoder } from './version_0-2f1176e3.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
@@ -26,14 +65,14 @@ class CodeError extends Error {
     }
 }
 
-var encode_1 = encode$3;
+var encode_1 = encode$2;
 
 var MSB$1 = 0x80
   , REST$1 = 0x7F
   , MSBALL = ~REST$1
   , INT = Math.pow(2, 31);
 
-function encode$3(num, out, offset) {
+function encode$2(num, out, offset) {
   out = out || [];
   offset = offset || 0;
   var oldOffset = offset;
@@ -48,12 +87,12 @@ function encode$3(num, out, offset) {
   }
   out[offset] = num | 0;
   
-  encode$3.bytes = offset - oldOffset + 1;
+  encode$2.bytes = offset - oldOffset + 1;
   
   return out
 }
 
-var decode$5 = read;
+var decode$4 = read;
 
 var MSB$1$1 = 0x80
   , REST$1$1 = 0x7F;
@@ -110,7 +149,7 @@ var length = function (value) {
 
 var varint = {
     encode: encode_1
-  , decode: decode$5
+  , decode: decode$4
   , encodingLength: length
 };
 
@@ -121,7 +160,7 @@ var _brrp_varint = varint;
  * @param {number} [offset=0]
  * @returns {[number, number]}
  */
-const decode$4 = (data, offset = 0) => {
+const decode$3 = (data, offset = 0) => {
   const code = _brrp_varint.decode(data, offset);
   return [code, _brrp_varint.decode.bytes]
 };
@@ -170,10 +209,10 @@ const create = (code, digest) => {
  * @param {Uint8Array} multihash
  * @returns {MultihashDigest}
  */
-const decode$3 = (multihash) => {
-  const bytes = coerce$1(multihash);
-  const [code, sizeOffset] = decode$4(bytes);
-  const [size, digestOffset] = decode$4(bytes.subarray(sizeOffset));
+const decode$2 = (multihash) => {
+  const bytes = coerce(multihash);
+  const [code, sizeOffset] = decode$3(bytes);
+  const [size, digestOffset] = decode$3(bytes.subarray(sizeOffset));
   const digest = bytes.subarray(sizeOffset + digestOffset);
 
   if (digest.byteLength !== size) {
@@ -489,7 +528,7 @@ class CID {
       const { version, multihash, code } = value;
       const digest =
         /** @type {API.MultihashDigest<Alg>} */
-        (decode$3(multihash));
+        (decode$2(multihash));
       return CID.create(version, code, digest)
     } else {
       // Otherwise value is not a CID (or an incompatible version of it) in
@@ -604,7 +643,7 @@ class CID {
   static decodeFirst (bytes) {
     const specs = CID.inspectBytes(bytes);
     const prefixSize = specs.size - specs.multihashSize;
-    const multihashBytes = coerce$1(
+    const multihashBytes = coerce(
       bytes.subarray(prefixSize, prefixSize + specs.multihashSize)
     );
     if (multihashBytes.byteLength !== specs.multihashSize) {
@@ -645,7 +684,7 @@ class CID {
   static inspectBytes (initialBytes) {
     let offset = 0;
     const next = () => {
-      const [i, length] = decode$4(initialBytes.subarray(offset));
+      const [i, length] = decode$3(initialBytes.subarray(offset));
       offset += length;
       return i
     };
@@ -1027,7 +1066,7 @@ function decodeUint8ArrayList(buf, offset) {
     }
     throw new RangeError('Could not decode varint');
 }
-function encode$2(value, buf, offset = 0) {
+function encode$1(value, buf, offset = 0) {
     if (buf == null) {
         buf = allocUnsafe(encodingLength(value));
     }
@@ -1038,7 +1077,7 @@ function encode$2(value, buf, offset = 0) {
         return encodeUint8ArrayList(value, buf, offset);
     }
 }
-function decode$2(buf, offset = 0) {
+function decode$1(buf, offset = 0) {
     if (buf instanceof Uint8Array) {
         return decodeUint8Array(buf, offset);
     }
@@ -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);
@@ -1594,11 +1633,11 @@ function bytes2port(buf) {
 }
 function str2bytes(str) {
     const buf = fromString(str);
-    const size = Uint8Array.from(encode$2(buf.length));
+    const size = Uint8Array.from(encode$1(buf.length));
     return concat([size, buf], size.length + buf.length);
 }
 function bytes2str(buf) {
-    const size = decode$2(buf);
+    const size = decode$1(buf);
     buf = buf.slice(encodingLength(size));
     if (buf.length !== size) {
         throw new Error('inconsistent lengths');
@@ -1608,22 +1647,22 @@ function bytes2str(buf) {
 function mh2bytes(hash) {
     let mh;
     if (hash[0] === 'Q' || hash[0] === '1') {
-        mh = decode$3(base58btc.decode(`z${hash}`)).bytes;
+        mh = decode$2(base58btc.decode(`z${hash}`)).bytes;
     }
     else {
         mh = CID.parse(hash).multihash.bytes;
     }
     // the address is a varint prefixed multihash string representation
-    const size = Uint8Array.from(encode$2(mh.length));
+    const size = Uint8Array.from(encode$1(mh.length));
     return concat([size, mh], size.length + mh.length);
 }
 function mb2bytes(mbstr) {
     const mb = anybaseDecoder.decode(mbstr);
-    const size = Uint8Array.from(encode$2(mb.length));
+    const size = Uint8Array.from(encode$1(mb.length));
     return concat([size, mb], size.length + mb.length);
 }
 function bytes2mb(buf) {
-    const size = decode$2(buf);
+    const size = decode$1(buf);
     const hash = buf.slice(encodingLength(size));
     if (hash.length !== size) {
         throw new Error('inconsistent lengths');
@@ -1634,7 +1673,7 @@ function bytes2mb(buf) {
  * Converts bytes to bas58btc string
  */
 function bytes2mh(buf) {
-    const size = decode$2(buf);
+    const size = decode$1(buf);
     const address = buf.slice(encodingLength(size));
     if (address.length !== size) {
         throw new Error('inconsistent lengths');
@@ -1741,7 +1780,7 @@ function bytesToMultiaddrParts(bytes) {
     let path = null;
     let i = 0;
     while (i < bytes.length) {
-        const code = decode$2(bytes, i);
+        const code = decode$1(bytes, i);
         const n = encodingLength(code);
         const p = getProtocol(code);
         const size = sizeForAddr(p, bytes.slice(i + n));
@@ -1798,7 +1837,7 @@ function stringTuplesToString(tuples) {
 function tuplesToBytes(tuples) {
     return concat(tuples.map((tup) => {
         const proto = getProtocol(tup[0]);
-        let buf = Uint8Array.from(encode$2(proto.code));
+        let buf = Uint8Array.from(encode$1(proto.code));
         if (tup.length > 1 && tup[1] != null) {
             buf = concat([buf, tup[1]]); // add address buffer
         }
@@ -1816,7 +1855,7 @@ function sizeForAddr(p, addr) {
         return 0;
     }
     else {
-        const size = decode$2(addr instanceof Uint8Array ? addr : Uint8Array.from(addr));
+        const size = decode$1(addr instanceof Uint8Array ? addr : Uint8Array.from(addr));
         return size + encodingLength(size);
     }
 }
@@ -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,15 +2290,6 @@ async function isMessageSizeUnderCap(encoder, message) {
 }
 const isWireSizeUnderCap = (buf) => buf.length / MB <= SIZE_CAP_IN_MB;
 
-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.
  *
@@ -2266,41 +2362,41 @@ const CustomEvent = globalThis.CustomEvent ?? CustomEventPolyfill;
 
 var _nodeResolve_empty = {};
 
-var nodeCrypto = /*#__PURE__*/Object.freeze({
+var _nodeResolve_empty$1 = /*#__PURE__*/Object.freeze({
     __proto__: null,
     default: _nodeResolve_empty
 });
 
 /*! noble-secp256k1 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
-const _0n$1 = BigInt(0);
-const _1n$1 = BigInt(1);
-const _2n$1 = BigInt(2);
+const _0n = BigInt(0);
+const _1n = BigInt(1);
+const _2n = BigInt(2);
 const _3n = BigInt(3);
-const _8n$1 = BigInt(8);
-const CURVE$1 = Object.freeze({
-    a: _0n$1,
+const _8n = BigInt(8);
+const CURVE = Object.freeze({
+    a: _0n,
     b: BigInt(7),
     P: BigInt('0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffefffffc2f'),
     n: BigInt('0xfffffffffffffffffffffffffffffffebaaedce6af48a03bbfd25e8cd0364141'),
-    h: _1n$1,
+    h: _1n,
     Gx: BigInt('55066263022277343669578718895168534326250603453777594175500187360389116729240'),
     Gy: BigInt('32670510020758816978083085130507043184471273380659243275938904335757337482424'),
     beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),
 });
-const divNearest = (a, b) => (a + b / _2n$1) / b;
+const divNearest = (a, b) => (a + b / _2n) / b;
 const endo = {
     beta: BigInt('0x7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee'),
     splitScalar(k) {
-        const { n } = CURVE$1;
+        const { n } = CURVE;
         const a1 = BigInt('0x3086d221a7d46bcde86c90e49284eb15');
-        const b1 = -_1n$1 * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');
+        const b1 = -_1n * BigInt('0xe4437ed6010e88286f547fa90abfe4c3');
         const a2 = BigInt('0x114ca50f7a8e2f3f657c1108d9d44cfd8');
         const b2 = a1;
         const POW_2_128 = BigInt('0x100000000000000000000000000000000');
         const c1 = divNearest(b2 * k, n);
         const c2 = divNearest(-b1 * k, n);
-        let k1 = mod$1(k - c1 * a1 - c2 * a2, n);
-        let k2 = mod$1(-c1 * b1 - c2 * b2, n);
+        let k1 = mod(k - c1 * a1 - c2 * a2, n);
+        let k2 = mod(-c1 * b1 - c2 * b2, n);
         const k1neg = k1 > POW_2_128;
         const k2neg = k2 > POW_2_128;
         if (k1neg)
@@ -2318,12 +2414,12 @@ const groupLen = 32;
 const compressedLen = fieldLen + 1;
 const uncompressedLen = 2 * fieldLen + 1;
 function weierstrass(x) {
-    const { a, b } = CURVE$1;
-    const x2 = mod$1(x * x);
-    const x3 = mod$1(x2 * x);
-    return mod$1(x3 + a * x + b);
+    const { a, b } = CURVE;
+    const x2 = mod(x * x);
+    const x3 = mod(x2 * x);
+    return mod(x3 + a * x + b);
 }
-const USE_ENDOMORPHISM = CURVE$1.a === _0n$1;
+const USE_ENDOMORPHISM = CURVE.a === _0n;
 function assertJacPoint(other) {
     if (!(other instanceof JacobianPoint))
         throw new TypeError('JacobianPoint expected');
@@ -2335,15 +2431,15 @@ class JacobianPoint {
         this.z = z;
     }
     static fromAffine(p) {
-        if (!(p instanceof Point$1)) {
+        if (!(p instanceof Point)) {
             throw new TypeError('JacobianPoint#fromAffine: expected Point');
         }
-        if (p.equals(Point$1.ZERO))
+        if (p.equals(Point.ZERO))
             return JacobianPoint.ZERO;
-        return new JacobianPoint(p.x, p.y, _1n$1);
+        return new JacobianPoint(p.x, p.y, _1n);
     }
     static toAffineBatch(points) {
-        const toInv = invertBatch$1(points.map((p) => p.z));
+        const toInv = invertBatch(points.map((p) => p.z));
         return points.map((p, i) => p.toAffine(toInv[i]));
     }
     static normalizeZ(points) {
@@ -2353,61 +2449,61 @@ class JacobianPoint {
         assertJacPoint(other);
         const { x: X1, y: Y1, z: Z1 } = this;
         const { x: X2, y: Y2, z: Z2 } = other;
-        const Z1Z1 = mod$1(Z1 * Z1);
-        const Z2Z2 = mod$1(Z2 * Z2);
-        const U1 = mod$1(X1 * Z2Z2);
-        const U2 = mod$1(X2 * Z1Z1);
-        const S1 = mod$1(mod$1(Y1 * Z2) * Z2Z2);
-        const S2 = mod$1(mod$1(Y2 * Z1) * Z1Z1);
+        const Z1Z1 = mod(Z1 * Z1);
+        const Z2Z2 = mod(Z2 * Z2);
+        const U1 = mod(X1 * Z2Z2);
+        const U2 = mod(X2 * Z1Z1);
+        const S1 = mod(mod(Y1 * Z2) * Z2Z2);
+        const S2 = mod(mod(Y2 * Z1) * Z1Z1);
         return U1 === U2 && S1 === S2;
     }
     negate() {
-        return new JacobianPoint(this.x, mod$1(-this.y), this.z);
+        return new JacobianPoint(this.x, mod(-this.y), this.z);
     }
     double() {
         const { x: X1, y: Y1, z: Z1 } = this;
-        const A = mod$1(X1 * X1);
-        const B = mod$1(Y1 * Y1);
-        const C = mod$1(B * B);
+        const A = mod(X1 * X1);
+        const B = mod(Y1 * Y1);
+        const C = mod(B * B);
         const x1b = X1 + B;
-        const D = mod$1(_2n$1 * (mod$1(x1b * x1b) - A - C));
-        const E = mod$1(_3n * A);
-        const F = mod$1(E * E);
-        const X3 = mod$1(F - _2n$1 * D);
-        const Y3 = mod$1(E * (D - X3) - _8n$1 * C);
-        const Z3 = mod$1(_2n$1 * Y1 * Z1);
+        const D = mod(_2n * (mod(x1b * x1b) - A - C));
+        const E = mod(_3n * A);
+        const F = mod(E * E);
+        const X3 = mod(F - _2n * D);
+        const Y3 = mod(E * (D - X3) - _8n * C);
+        const Z3 = mod(_2n * Y1 * Z1);
         return new JacobianPoint(X3, Y3, Z3);
     }
     add(other) {
         assertJacPoint(other);
         const { x: X1, y: Y1, z: Z1 } = this;
         const { x: X2, y: Y2, z: Z2 } = other;
-        if (X2 === _0n$1 || Y2 === _0n$1)
+        if (X2 === _0n || Y2 === _0n)
             return this;
-        if (X1 === _0n$1 || Y1 === _0n$1)
+        if (X1 === _0n || Y1 === _0n)
             return other;
-        const Z1Z1 = mod$1(Z1 * Z1);
-        const Z2Z2 = mod$1(Z2 * Z2);
-        const U1 = mod$1(X1 * Z2Z2);
-        const U2 = mod$1(X2 * Z1Z1);
-        const S1 = mod$1(mod$1(Y1 * Z2) * Z2Z2);
-        const S2 = mod$1(mod$1(Y2 * Z1) * Z1Z1);
-        const H = mod$1(U2 - U1);
-        const r = mod$1(S2 - S1);
-        if (H === _0n$1) {
-            if (r === _0n$1) {
+        const Z1Z1 = mod(Z1 * Z1);
+        const Z2Z2 = mod(Z2 * Z2);
+        const U1 = mod(X1 * Z2Z2);
+        const U2 = mod(X2 * Z1Z1);
+        const S1 = mod(mod(Y1 * Z2) * Z2Z2);
+        const S2 = mod(mod(Y2 * Z1) * Z1Z1);
+        const H = mod(U2 - U1);
+        const r = mod(S2 - S1);
+        if (H === _0n) {
+            if (r === _0n) {
                 return this.double();
             }
             else {
                 return JacobianPoint.ZERO;
             }
         }
-        const HH = mod$1(H * H);
-        const HHH = mod$1(H * HH);
-        const V = mod$1(U1 * HH);
-        const X3 = mod$1(r * r - HHH - _2n$1 * V);
-        const Y3 = mod$1(r * (V - X3) - S1 * HHH);
-        const Z3 = mod$1(Z1 * Z2 * H);
+        const HH = mod(H * H);
+        const HHH = mod(H * HH);
+        const V = mod(U1 * HH);
+        const X3 = mod(r * r - HHH - _2n * V);
+        const Y3 = mod(r * (V - X3) - S1 * HHH);
+        const Z3 = mod(Z1 * Z2 * H);
         return new JacobianPoint(X3, Y3, Z3);
     }
     subtract(other) {
@@ -2415,19 +2511,19 @@ class JacobianPoint {
     }
     multiplyUnsafe(scalar) {
         const P0 = JacobianPoint.ZERO;
-        if (typeof scalar === 'bigint' && scalar === _0n$1)
+        if (typeof scalar === 'bigint' && scalar === _0n)
             return P0;
-        let n = normalizeScalar$1(scalar);
-        if (n === _1n$1)
+        let n = normalizeScalar(scalar);
+        if (n === _1n)
             return this;
         if (!USE_ENDOMORPHISM) {
             let p = P0;
             let d = this;
-            while (n > _0n$1) {
-                if (n & _1n$1)
+            while (n > _0n) {
+                if (n & _1n)
                     p = p.add(d);
                 d = d.double();
-                n >>= _1n$1;
+                n >>= _1n;
             }
             return p;
         }
@@ -2435,20 +2531,20 @@ class JacobianPoint {
         let k1p = P0;
         let k2p = P0;
         let d = this;
-        while (k1 > _0n$1 || k2 > _0n$1) {
-            if (k1 & _1n$1)
+        while (k1 > _0n || k2 > _0n) {
+            if (k1 & _1n)
                 k1p = k1p.add(d);
-            if (k2 & _1n$1)
+            if (k2 & _1n)
                 k2p = k2p.add(d);
             d = d.double();
-            k1 >>= _1n$1;
-            k2 >>= _1n$1;
+            k1 >>= _1n;
+            k2 >>= _1n;
         }
         if (k1neg)
             k1p = k1p.negate();
         if (k2neg)
             k2p = k2p.negate();
-        k2p = new JacobianPoint(mod$1(k2p.x * endo.beta), k2p.y, k2p.z);
+        k2p = new JacobianPoint(mod(k2p.x * endo.beta), k2p.y, k2p.z);
         return k1p.add(k2p);
     }
     precomputeWindow(W) {
@@ -2469,17 +2565,17 @@ class JacobianPoint {
     }
     wNAF(n, affinePoint) {
         if (!affinePoint && this.equals(JacobianPoint.BASE))
-            affinePoint = Point$1.BASE;
+            affinePoint = Point.BASE;
         const W = (affinePoint && affinePoint._WINDOW_SIZE) || 1;
         if (256 % W) {
             throw new Error('Point#wNAF: Invalid precomputation window, must be power of 2');
         }
-        let precomputes = affinePoint && pointPrecomputes$1.get(affinePoint);
+        let precomputes = affinePoint && pointPrecomputes.get(affinePoint);
         if (!precomputes) {
             precomputes = this.precomputeWindow(W);
             if (affinePoint && W !== 1) {
                 precomputes = JacobianPoint.normalizeZ(precomputes);
-                pointPrecomputes$1.set(affinePoint, precomputes);
+                pointPrecomputes.set(affinePoint, precomputes);
             }
         }
         let p = JacobianPoint.ZERO;
@@ -2495,32 +2591,32 @@ class JacobianPoint {
             n >>= shiftBy;
             if (wbits > windowSize) {
                 wbits -= maxNumber;
-                n += _1n$1;
+                n += _1n;
             }
             const offset1 = offset;
             const offset2 = offset + Math.abs(wbits) - 1;
             const cond1 = window % 2 !== 0;
             const cond2 = wbits < 0;
             if (wbits === 0) {
-                f = f.add(constTimeNegate$1(cond1, precomputes[offset1]));
+                f = f.add(constTimeNegate(cond1, precomputes[offset1]));
             }
             else {
-                p = p.add(constTimeNegate$1(cond2, precomputes[offset2]));
+                p = p.add(constTimeNegate(cond2, precomputes[offset2]));
             }
         }
         return { p, f };
     }
     multiply(scalar, affinePoint) {
-        let n = normalizeScalar$1(scalar);
+        let n = normalizeScalar(scalar);
         let point;
         let fake;
         if (USE_ENDOMORPHISM) {
             const { k1neg, k1, k2neg, k2 } = endo.splitScalar(n);
             let { p: k1p, f: f1p } = this.wNAF(k1, affinePoint);
             let { p: k2p, f: f2p } = this.wNAF(k2, affinePoint);
-            k1p = constTimeNegate$1(k1neg, k1p);
-            k2p = constTimeNegate$1(k2neg, k2p);
-            k2p = new JacobianPoint(mod$1(k2p.x * endo.beta), k2p.y, k2p.z);
+            k1p = constTimeNegate(k1neg, k1p);
+            k2p = constTimeNegate(k2neg, k2p);
+            k2p = new JacobianPoint(mod(k2p.x * endo.beta), k2p.y, k2p.z);
             point = k1p.add(k2p);
             fake = f1p.add(f2p);
         }
@@ -2535,38 +2631,38 @@ class JacobianPoint {
         const { x, y, z } = this;
         const is0 = this.equals(JacobianPoint.ZERO);
         if (invZ == null)
-            invZ = is0 ? _8n$1 : invert$1(z);
+            invZ = is0 ? _8n : invert(z);
         const iz1 = invZ;
-        const iz2 = mod$1(iz1 * iz1);
-        const iz3 = mod$1(iz2 * iz1);
-        const ax = mod$1(x * iz2);
-        const ay = mod$1(y * iz3);
-        const zz = mod$1(z * iz1);
+        const iz2 = mod(iz1 * iz1);
+        const iz3 = mod(iz2 * iz1);
+        const ax = mod(x * iz2);
+        const ay = mod(y * iz3);
+        const zz = mod(z * iz1);
         if (is0)
-            return Point$1.ZERO;
-        if (zz !== _1n$1)
+            return Point.ZERO;
+        if (zz !== _1n)
             throw new Error('invZ was invalid');
-        return new Point$1(ax, ay);
+        return new Point(ax, ay);
     }
 }
-JacobianPoint.BASE = new JacobianPoint(CURVE$1.Gx, CURVE$1.Gy, _1n$1);
-JacobianPoint.ZERO = new JacobianPoint(_0n$1, _1n$1, _0n$1);
-function constTimeNegate$1(condition, item) {
+JacobianPoint.BASE = new JacobianPoint(CURVE.Gx, CURVE.Gy, _1n);
+JacobianPoint.ZERO = new JacobianPoint(_0n, _1n, _0n);
+function constTimeNegate(condition, item) {
     const neg = item.negate();
     return condition ? neg : item;
 }
-const pointPrecomputes$1 = new WeakMap();
-let Point$1 = class Point {
+const pointPrecomputes = new WeakMap();
+class Point {
     constructor(x, y) {
         this.x = x;
         this.y = y;
     }
     _setWindowSize(windowSize) {
         this._WINDOW_SIZE = windowSize;
-        pointPrecomputes$1.delete(this);
+        pointPrecomputes.delete(this);
     }
     hasEvenY() {
-        return this.y % _2n$1 === _0n$1;
+        return this.y % _2n === _0n;
     }
     static fromCompressedHex(bytes) {
         const isShort = bytes.length === 32;
@@ -2575,15 +2671,15 @@ let Point$1 = class Point {
             throw new Error('Point is not on curve');
         const y2 = weierstrass(x);
         let y = sqrtMod(y2);
-        const isYOdd = (y & _1n$1) === _1n$1;
+        const isYOdd = (y & _1n) === _1n;
         if (isShort) {
             if (isYOdd)
-                y = mod$1(-y);
+                y = mod(-y);
         }
         else {
             const isFirstByteOdd = (bytes[0] & 1) === 1;
             if (isFirstByteOdd !== isYOdd)
-                y = mod$1(-y);
+                y = mod(-y);
         }
         const point = new Point(x, y);
         point.assertValidity();
@@ -2597,7 +2693,7 @@ let Point$1 = class Point {
         return point;
     }
     static fromHex(hex) {
-        const bytes = ensureBytes$1(hex);
+        const bytes = ensureBytes(hex);
         const len = bytes.length;
         const header = bytes[0];
         if (len === fieldLen)
@@ -2616,12 +2712,12 @@ let Point$1 = class Point {
         const { r, s } = normalizeSignature(signature);
         if (![0, 1, 2, 3].includes(recovery))
             throw new Error('Cannot recover: invalid recovery bit');
-        const h = truncateHash(ensureBytes$1(msgHash));
-        const { n } = CURVE$1;
+        const h = truncateHash(ensureBytes(msgHash));
+        const { n } = CURVE;
         const radj = recovery === 2 || recovery === 3 ? r + n : r;
-        const rinv = invert$1(radj, n);
-        const u1 = mod$1(-h * rinv, n);
-        const u2 = mod$1(s * rinv, n);
+        const rinv = invert(radj, n);
+        const u1 = mod(-h * rinv, n);
+        const u2 = mod(s * rinv, n);
         const prefix = recovery & 1 ? '03' : '02';
         const R = Point.fromHex(prefix + numTo32bStr(radj));
         const Q = Point.BASE.multiplyAndAddUnsafe(R, u1, u2);
@@ -2631,7 +2727,7 @@ let Point$1 = class Point {
         return Q;
     }
     toRawBytes(isCompressed = false) {
-        return hexToBytes$1(this.toHex(isCompressed));
+        return hexToBytes(this.toHex(isCompressed));
     }
     toHex(isCompressed = false) {
         const x = numTo32bStr(this.x);
@@ -2654,16 +2750,16 @@ let Point$1 = class Point {
         const { x, y } = this;
         if (!isValidFieldElement(x) || !isValidFieldElement(y))
             throw new Error(msg);
-        const left = mod$1(y * y);
+        const left = mod(y * y);
         const right = weierstrass(x);
-        if (mod$1(left - right) !== _0n$1)
+        if (mod(left - right) !== _0n)
             throw new Error(msg);
     }
     equals(other) {
         return this.x === other.x && this.y === other.y;
     }
     negate() {
-        return new Point(this.x, mod$1(-this.y));
+        return new Point(this.x, mod(-this.y));
     }
     double() {
         return JacobianPoint.fromAffine(this).double().toAffine();
@@ -2679,20 +2775,20 @@ let Point$1 = class Point {
     }
     multiplyAndAddUnsafe(Q, a, b) {
         const P = JacobianPoint.fromAffine(this);
-        const aP = a === _0n$1 || a === _1n$1 || this !== Point.BASE ? P.multiplyUnsafe(a) : P.multiply(a);
+        const aP = a === _0n || a === _1n || this !== Point.BASE ? P.multiplyUnsafe(a) : P.multiply(a);
         const bQ = JacobianPoint.fromAffine(Q).multiplyUnsafe(b);
         const sum = aP.add(bQ);
         return sum.equals(JacobianPoint.ZERO) ? undefined : sum.toAffine();
     }
-};
-Point$1.BASE = new Point$1(CURVE$1.Gx, CURVE$1.Gy);
-Point$1.ZERO = new Point$1(_0n$1, _0n$1);
+}
+Point.BASE = new Point(CURVE.Gx, CURVE.Gy);
+Point.ZERO = new Point(_0n, _0n);
 function sliceDER(s) {
     return Number.parseInt(s[0], 16) >= 8 ? '00' + s : s;
 }
 function parseDERInt(data) {
     if (data.length < 2 || data[0] !== 0x02) {
-        throw new Error(`Invalid signature integer tag: ${bytesToHex$1(data)}`);
+        throw new Error(`Invalid signature integer tag: ${bytesToHex(data)}`);
     }
     const len = data[1];
     const res = data.subarray(2, len + 2);
@@ -2706,7 +2802,7 @@ function parseDERInt(data) {
 }
 function parseDERSignature(data) {
     if (data.length < 2 || data[0] != 0x30) {
-        throw new Error(`Invalid signature tag: ${bytesToHex$1(data)}`);
+        throw new Error(`Invalid signature tag: ${bytesToHex(data)}`);
     }
     if (data[1] !== data.length - 2) {
         throw new Error('Invalid signature: incorrect length');
@@ -2714,7 +2810,7 @@ function parseDERSignature(data) {
     const { data: r, left: sBytes } = parseDERInt(data.subarray(2));
     const { data: s, left: rBytesLeft } = parseDERInt(sBytes);
     if (rBytesLeft.length) {
-        throw new Error(`Invalid signature: left bytes after parsing: ${bytesToHex$1(rBytesLeft)}`);
+        throw new Error(`Invalid signature: left bytes after parsing: ${bytesToHex(rBytesLeft)}`);
     }
     return { r, s };
 }
@@ -2729,7 +2825,7 @@ class Signature {
         const name = 'Signature.fromCompact';
         if (typeof hex !== 'string' && !arr)
             throw new TypeError(`${name}: Expected string or Uint8Array`);
-        const str = arr ? bytesToHex$1(hex) : hex;
+        const str = arr ? bytesToHex(hex) : hex;
         if (str.length !== 128)
             throw new Error(`${name}: Expected 64-byte hex`);
         return new Signature(hexToNumber(str.slice(0, 64)), hexToNumber(str.slice(64, 128)));
@@ -2738,7 +2834,7 @@ class Signature {
         const arr = hex instanceof Uint8Array;
         if (typeof hex !== 'string' && !arr)
             throw new TypeError(`Signature.fromDER: Expected string or Uint8Array`);
-        const { r, s } = parseDERSignature(arr ? hex : hexToBytes$1(hex));
+        const { r, s } = parseDERSignature(arr ? hex : hexToBytes(hex));
         return new Signature(r, s);
     }
     static fromHex(hex) {
@@ -2752,14 +2848,14 @@ class Signature {
             throw new Error('Invalid Signature: s must be 0 < s < n');
     }
     hasHighS() {
-        const HALF = CURVE$1.n >> _1n$1;
+        const HALF = CURVE.n >> _1n;
         return this.s > HALF;
     }
     normalizeS() {
-        return this.hasHighS() ? new Signature(this.r, mod$1(-this.s, CURVE$1.n)) : this;
+        return this.hasHighS() ? new Signature(this.r, mod(-this.s, CURVE.n)) : this;
     }
     toDERRawBytes() {
-        return hexToBytes$1(this.toDERHex());
+        return hexToBytes(this.toDERHex());
     }
     toDERHex() {
         const sHex = sliceDER(numberToHexUnpadded(this.s));
@@ -2778,27 +2874,27 @@ class Signature {
         return this.toDERHex();
     }
     toCompactRawBytes() {
-        return hexToBytes$1(this.toCompactHex());
+        return hexToBytes(this.toCompactHex());
     }
     toCompactHex() {
         return numTo32bStr(this.r) + numTo32bStr(this.s);
     }
 }
-const hexes$1 = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
-function bytesToHex$1(uint8a) {
+const hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
+function bytesToHex(uint8a) {
     if (!(uint8a instanceof Uint8Array))
         throw new Error('Expected Uint8Array');
     let hex = '';
     for (let i = 0; i < uint8a.length; i++) {
-        hex += hexes$1[uint8a[i]];
+        hex += hexes[uint8a[i]];
     }
     return hex;
 }
-const POW_2_256$1 = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000');
+const POW_2_256 = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000');
 function numTo32bStr(num) {
     if (typeof num !== 'bigint')
         throw new Error('Expected bigint');
-    if (!(_0n$1 <= num && num < POW_2_256$1))
+    if (!(_0n <= num && num < POW_2_256))
         throw new Error('Expected number 0 <= n < 2^256');
     return num.toString(16).padStart(64, '0');
 }
@@ -2812,7 +2908,7 @@ function hexToNumber(hex) {
     }
     return BigInt(`0x${hex}`);
 }
-function hexToBytes$1(hex) {
+function hexToBytes(hex) {
     if (typeof hex !== 'string') {
         throw new TypeError('hexToBytes: expected string, got ' + typeof hex);
     }
@@ -2830,33 +2926,33 @@ function hexToBytes$1(hex) {
     return array;
 }
 function bytesToNumber(bytes) {
-    return hexToNumber(bytesToHex$1(bytes));
+    return hexToNumber(bytesToHex(bytes));
 }
-function ensureBytes$1(hex) {
-    return hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes$1(hex);
+function ensureBytes(hex) {
+    return hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes(hex);
 }
-function normalizeScalar$1(num) {
+function normalizeScalar(num) {
     if (typeof num === 'number' && Number.isSafeInteger(num) && num > 0)
         return BigInt(num);
     if (typeof num === 'bigint' && isWithinCurveOrder(num))
         return num;
     throw new TypeError('Expected valid private scalar: 0 < scalar < curve.n');
 }
-function mod$1(a, b = CURVE$1.P) {
+function mod(a, b = CURVE.P) {
     const result = a % b;
-    return result >= _0n$1 ? result : b + result;
+    return result >= _0n ? result : b + result;
 }
-function pow2$1(x, power) {
-    const { P } = CURVE$1;
+function pow2(x, power) {
+    const { P } = CURVE;
     let res = x;
-    while (power-- > _0n$1) {
+    while (power-- > _0n) {
         res *= res;
         res %= P;
     }
     return res;
 }
 function sqrtMod(x) {
-    const { P } = CURVE$1;
+    const { P } = CURVE;
     const _6n = BigInt(6);
     const _11n = BigInt(11);
     const _22n = BigInt(22);
@@ -2865,55 +2961,55 @@ function sqrtMod(x) {
     const _88n = BigInt(88);
     const b2 = (x * x * x) % P;
     const b3 = (b2 * b2 * x) % P;
-    const b6 = (pow2$1(b3, _3n) * b3) % P;
-    const b9 = (pow2$1(b6, _3n) * b3) % P;
-    const b11 = (pow2$1(b9, _2n$1) * b2) % P;
-    const b22 = (pow2$1(b11, _11n) * b11) % P;
-    const b44 = (pow2$1(b22, _22n) * b22) % P;
-    const b88 = (pow2$1(b44, _44n) * b44) % P;
-    const b176 = (pow2$1(b88, _88n) * b88) % P;
-    const b220 = (pow2$1(b176, _44n) * b44) % P;
-    const b223 = (pow2$1(b220, _3n) * b3) % P;
-    const t1 = (pow2$1(b223, _23n) * b22) % P;
-    const t2 = (pow2$1(t1, _6n) * b2) % P;
-    const rt = pow2$1(t2, _2n$1);
+    const b6 = (pow2(b3, _3n) * b3) % P;
+    const b9 = (pow2(b6, _3n) * b3) % P;
+    const b11 = (pow2(b9, _2n) * b2) % P;
+    const b22 = (pow2(b11, _11n) * b11) % P;
+    const b44 = (pow2(b22, _22n) * b22) % P;
+    const b88 = (pow2(b44, _44n) * b44) % P;
+    const b176 = (pow2(b88, _88n) * b88) % P;
+    const b220 = (pow2(b176, _44n) * b44) % P;
+    const b223 = (pow2(b220, _3n) * b3) % P;
+    const t1 = (pow2(b223, _23n) * b22) % P;
+    const t2 = (pow2(t1, _6n) * b2) % P;
+    const rt = pow2(t2, _2n);
     const xc = (rt * rt) % P;
     if (xc !== x)
         throw new Error('Cannot find square root');
     return rt;
 }
-function invert$1(number, modulo = CURVE$1.P) {
-    if (number === _0n$1 || modulo <= _0n$1) {
+function invert(number, modulo = CURVE.P) {
+    if (number === _0n || modulo <= _0n) {
         throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);
     }
-    let a = mod$1(number, modulo);
+    let a = mod(number, modulo);
     let b = modulo;
-    let x = _0n$1, u = _1n$1;
-    while (a !== _0n$1) {
+    let x = _0n, u = _1n;
+    while (a !== _0n) {
         const q = b / a;
         const r = b % a;
         const m = x - u * q;
         b = a, a = r, x = u, u = m;
     }
     const gcd = b;
-    if (gcd !== _1n$1)
+    if (gcd !== _1n)
         throw new Error('invert: does not exist');
-    return mod$1(x, modulo);
+    return mod(x, modulo);
 }
-function invertBatch$1(nums, p = CURVE$1.P) {
+function invertBatch(nums, p = CURVE.P) {
     const scratch = new Array(nums.length);
     const lastMultiplied = nums.reduce((acc, num, i) => {
-        if (num === _0n$1)
+        if (num === _0n)
             return acc;
         scratch[i] = acc;
-        return mod$1(acc * num, p);
-    }, _1n$1);
-    const inverted = invert$1(lastMultiplied, p);
+        return mod(acc * num, p);
+    }, _1n);
+    const inverted = invert(lastMultiplied, p);
     nums.reduceRight((acc, num, i) => {
-        if (num === _0n$1)
+        if (num === _0n)
             return acc;
-        scratch[i] = mod$1(acc * scratch[i], p);
-        return mod$1(acc * num, p);
+        scratch[i] = mod(acc * scratch[i], p);
+        return mod(acc * num, p);
     }, inverted);
     return scratch;
 }
@@ -2926,14 +3022,14 @@ function truncateHash(hash, truncateOnly = false) {
     const h = bits2int_2(hash);
     if (truncateOnly)
         return h;
-    const { n } = CURVE$1;
+    const { n } = CURVE;
     return h >= n ? h - n : h;
 }
 function isWithinCurveOrder(num) {
-    return _0n$1 < num && num < CURVE$1.n;
+    return _0n < num && num < CURVE.n;
 }
 function isValidFieldElement(num) {
-    return _0n$1 < num && num < CURVE$1.P;
+    return _0n < num && num < CURVE.P;
 }
 function normalizePrivateKey(key) {
     let num;
@@ -2972,7 +3068,7 @@ function normalizeSignature(signature) {
         return Signature.fromCompact(signature);
     }
 }
-Point$1.BASE._setWindowSize(8);
+Point.BASE._setWindowSize(8);
 
 var sha3 = {exports: {}};
 
@@ -11081,7 +11177,7 @@ hmac.create = function() {
   return ctx;
 };
 
-var require$$8 = /*@__PURE__*/getAugmentedNamespace(nodeCrypto);
+var require$$8 = /*@__PURE__*/getAugmentedNamespace(_nodeResolve_empty$1);
 
 /**
  * Password-Based Key-Derivation Function #2 implementation.
@@ -11100,9 +11196,9 @@ var forge$c = forge$m;
 
 var pkcs5 = forge$c.pkcs5 = forge$c.pkcs5 || {};
 
-var crypto$2;
+var crypto$1;
 if(forge$c.util.isNodejs && !forge$c.options.usePureJavaScript) {
-  crypto$2 = require$$8;
+  crypto$1 = require$$8;
 }
 
 /**
@@ -11131,8 +11227,8 @@ forge$c.pbkdf2 = pkcs5.pbkdf2 = function(
   // use native implementation if possible and not disabled, note that
   // some node versions only support SHA-1, others allow digest to be changed
   if(forge$c.util.isNodejs && !forge$c.options.usePureJavaScript &&
-    crypto$2.pbkdf2 && (md === null || typeof md !== 'object') &&
-    (crypto$2.pbkdf2Sync.length > 4 || (!md || md === 'sha1'))) {
+    crypto$1.pbkdf2 && (md === null || typeof md !== 'object') &&
+    (crypto$1.pbkdf2Sync.length > 4 || (!md || md === 'sha1'))) {
     if(typeof md !== 'string') {
       // default prf to SHA-1
       md = 'sha1';
@@ -11140,20 +11236,20 @@ forge$c.pbkdf2 = pkcs5.pbkdf2 = function(
     p = Buffer.from(p, 'binary');
     s = Buffer.from(s, 'binary');
     if(!callback) {
-      if(crypto$2.pbkdf2Sync.length === 4) {
-        return crypto$2.pbkdf2Sync(p, s, c, dkLen).toString('binary');
+      if(crypto$1.pbkdf2Sync.length === 4) {
+        return crypto$1.pbkdf2Sync(p, s, c, dkLen).toString('binary');
       }
-      return crypto$2.pbkdf2Sync(p, s, c, dkLen, md).toString('binary');
+      return crypto$1.pbkdf2Sync(p, s, c, dkLen, md).toString('binary');
     }
-    if(crypto$2.pbkdf2Sync.length === 4) {
-      return crypto$2.pbkdf2(p, s, c, dkLen, function(err, key) {
+    if(crypto$1.pbkdf2Sync.length === 4) {
+      return crypto$1.pbkdf2(p, s, c, dkLen, function(err, key) {
         if(err) {
           return callback(err);
         }
         callback(null, key.toString('binary'));
       });
     }
-    return crypto$2.pbkdf2(p, s, c, dkLen, md, function(err, key) {
+    return crypto$1.pbkdf2(p, s, c, dkLen, md, function(err, key) {
       if(err) {
         return callback(err);
       }
@@ -11549,15 +11645,15 @@ var forge$a = forge$m;
 
 
 
-var sha256$1 = forge$a.sha256 = forge$a.sha256 || {};
-forge$a.md.sha256 = forge$a.md.algorithms.sha256 = sha256$1;
+var sha256 = forge$a.sha256 = forge$a.sha256 || {};
+forge$a.md.sha256 = forge$a.md.algorithms.sha256 = sha256;
 
 /**
  * Creates a SHA-256 message digest object.
  *
  * @return a message digest object.
  */
-sha256$1.create = function() {
+sha256.create = function() {
   // do initialization as necessary
   if(!_initialized$2) {
     _init$2();
@@ -17979,1240 +18075,44 @@ function createPbkdf2Params(salt, countBytes, dkLen, prfAlgorithm) {
   return params;
 }
 
-// base-x encoding / decoding
-// Copyright (c) 2018 base-x contributors
-// Copyright (c) 2014-2018 The Bitcoin Core developers (base58.cpp)
-// Distributed under the MIT software license, see the accompanying
-// file LICENSE or http://www.opensource.org/licenses/mit-license.php.
-function base (ALPHABET, name) {
-  if (ALPHABET.length >= 255) { throw new TypeError('Alphabet too long') }
-  var BASE_MAP = new Uint8Array(256);
-  for (var j = 0; j < BASE_MAP.length; j++) {
-    BASE_MAP[j] = 255;
-  }
-  for (var i = 0; i < ALPHABET.length; i++) {
-    var x = ALPHABET.charAt(i);
-    var xc = x.charCodeAt(0);
-    if (BASE_MAP[xc] !== 255) { throw new TypeError(x + ' is ambiguous') }
-    BASE_MAP[xc] = i;
-  }
-  var BASE = ALPHABET.length;
-  var LEADER = ALPHABET.charAt(0);
-  var FACTOR = Math.log(BASE) / Math.log(256); // log(BASE) / log(256), rounded up
-  var iFACTOR = Math.log(256) / Math.log(BASE); // log(256) / log(BASE), rounded up
-  function encode (source) {
-    if (source instanceof Uint8Array) ; else if (ArrayBuffer.isView(source)) {
-      source = new Uint8Array(source.buffer, source.byteOffset, source.byteLength);
-    } else if (Array.isArray(source)) {
-      source = Uint8Array.from(source);
-    }
-    if (!(source instanceof Uint8Array)) { throw new TypeError('Expected Uint8Array') }
-    if (source.length === 0) { return '' }
-        // Skip & count leading zeroes.
-    var zeroes = 0;
-    var length = 0;
-    var pbegin = 0;
-    var pend = source.length;
-    while (pbegin !== pend && source[pbegin] === 0) {
-      pbegin++;
-      zeroes++;
-    }
-        // Allocate enough space in big-endian base58 representation.
-    var size = ((pend - pbegin) * iFACTOR + 1) >>> 0;
-    var b58 = new Uint8Array(size);
-        // Process the bytes.
-    while (pbegin !== pend) {
-      var carry = source[pbegin];
-            // Apply "b58 = b58 * 256 + ch".
-      var i = 0;
-      for (var it1 = size - 1; (carry !== 0 || i < length) && (it1 !== -1); it1--, i++) {
-        carry += (256 * b58[it1]) >>> 0;
-        b58[it1] = (carry % BASE) >>> 0;
-        carry = (carry / BASE) >>> 0;
-      }
-      if (carry !== 0) { throw new Error('Non-zero carry') }
-      length = i;
-      pbegin++;
-    }
-        // Skip leading zeroes in base58 result.
-    var it2 = size - length;
-    while (it2 !== size && b58[it2] === 0) {
-      it2++;
-    }
-        // Translate the result into a string.
-    var str = LEADER.repeat(zeroes);
-    for (; it2 < size; ++it2) { str += ALPHABET.charAt(b58[it2]); }
-    return str
-  }
-  function decodeUnsafe (source) {
-    if (typeof source !== 'string') { throw new TypeError('Expected String') }
-    if (source.length === 0) { return new Uint8Array() }
-    var psz = 0;
-        // Skip leading spaces.
-    if (source[psz] === ' ') { return }
-        // Skip and count leading '1's.
-    var zeroes = 0;
-    var length = 0;
-    while (source[psz] === LEADER) {
-      zeroes++;
-      psz++;
-    }
-        // Allocate enough space in big-endian base256 representation.
-    var size = (((source.length - psz) * FACTOR) + 1) >>> 0; // log(58) / log(256), rounded up.
-    var b256 = new Uint8Array(size);
-        // Process the characters.
-    while (source[psz]) {
-            // Decode character
-      var carry = BASE_MAP[source.charCodeAt(psz)];
-            // Invalid character
-      if (carry === 255) { return }
-      var i = 0;
-      for (var it3 = size - 1; (carry !== 0 || i < length) && (it3 !== -1); it3--, i++) {
-        carry += (BASE * b256[it3]) >>> 0;
-        b256[it3] = (carry % 256) >>> 0;
-        carry = (carry / 256) >>> 0;
-      }
-      if (carry !== 0) { throw new Error('Non-zero carry') }
-      length = i;
-      psz++;
-    }
-        // Skip trailing spaces.
-    if (source[psz] === ' ') { return }
-        // Skip leading zeroes in b256.
-    var it4 = size - length;
-    while (it4 !== size && b256[it4] === 0) {
-      it4++;
-    }
-    var vch = new Uint8Array(zeroes + (size - it4));
-    var j = zeroes;
-    while (it4 !== size) {
-      vch[j++] = b256[it4++];
-    }
-    return vch
-  }
-  function decode (string) {
-    var buffer = decodeUnsafe(string);
-    if (buffer) { return buffer }
-    throw new Error(`Non-${name} character`)
-  }
-  return {
-    encode: encode,
-    decodeUnsafe: decodeUnsafe,
-    decode: decode
-  }
-}
-var src = base;
-
-var _brrp__multiformats_scope_baseX = src;
-
-/**
- * @param {ArrayBufferView|ArrayBuffer|Uint8Array} o
- * @returns {Uint8Array}
- */
-const coerce = o => {
-  if (o instanceof Uint8Array && o.constructor.name === 'Uint8Array') return o
-  if (o instanceof ArrayBuffer) return new Uint8Array(o)
-  if (ArrayBuffer.isView(o)) {
-    return new Uint8Array(o.buffer, o.byteOffset, o.byteLength)
-  }
-  throw new Error('Unknown type, must be binary type')
-};
-
-/**
- * Class represents both BaseEncoder and MultibaseEncoder meaning it
- * can be used to encode to multibase or base encode without multibase
- * prefix.
- *
- * @class
- * @template {string} Base
- * @template {string} Prefix
- * @implements {API.MultibaseEncoder<Prefix>}
- * @implements {API.BaseEncoder}
- */
-class Encoder {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(bytes:Uint8Array) => string} baseEncode
-   */
-  constructor (name, prefix, baseEncode) {
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-  }
-
-  /**
-   * @param {Uint8Array} bytes
-   * @returns {API.Multibase<Prefix>}
-   */
-  encode (bytes) {
-    if (bytes instanceof Uint8Array) {
-      return `${this.prefix}${this.baseEncode(bytes)}`
-    } else {
-      throw Error('Unknown type, must be binary type')
-    }
-  }
-}
-
-/**
- * @template {string} Prefix
- */
 /**
- * Class represents both BaseDecoder and MultibaseDecoder so it could be used
- * to decode multibases (with matching prefix) or just base decode strings
- * with corresponding base encoding.
+ * On the producing side:
+ * * Build messages with the signature, key (from may be enough for certain inlineable public key types), from and seqno fields.
  *
- * @class
- * @template {string} Base
- * @template {string} Prefix
- * @implements {API.MultibaseDecoder<Prefix>}
- * @implements {API.UnibaseDecoder<Prefix>}
- * @implements {API.BaseDecoder}
- */
-class Decoder {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(text:string) => Uint8Array} baseDecode
-   */
-  constructor (name, prefix, baseDecode) {
-    this.name = name;
-    this.prefix = prefix;
-    /* c8 ignore next 3 */
-    if (prefix.codePointAt(0) === undefined) {
-      throw new Error('Invalid prefix character')
-    }
-    /** @private */
-    this.prefixCodePoint = /** @type {number} */ (prefix.codePointAt(0));
-    this.baseDecode = baseDecode;
-  }
-
-  /**
-   * @param {string} text
-   */
-  decode (text) {
-    if (typeof text === 'string') {
-      if (text.codePointAt(0) !== this.prefixCodePoint) {
-        throw Error(`Unable to decode multibase string ${JSON.stringify(text)}, ${this.name} decoder only supports inputs prefixed with ${this.prefix}`)
-      }
-      return this.baseDecode(text.slice(this.prefix.length))
-    } else {
-      throw Error('Can only multibase decode strings')
-    }
-  }
-
-  /**
-   * @template {string} OtherPrefix
-   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-   */
-  or (decoder) {
-    return or(this, decoder)
-  }
-}
-
-/**
- * @template {string} Prefix
- * @typedef {Record<Prefix, API.UnibaseDecoder<Prefix>>} Decoders
- */
-
-/**
- * @template {string} Prefix
- * @implements {API.MultibaseDecoder<Prefix>}
- * @implements {API.CombobaseDecoder<Prefix>}
- */
-class ComposedDecoder {
-  /**
-   * @param {Decoders<Prefix>} decoders
-   */
-  constructor (decoders) {
-    this.decoders = decoders;
-  }
-
-  /**
-   * @template {string} OtherPrefix
-   * @param {API.UnibaseDecoder<OtherPrefix>|ComposedDecoder<OtherPrefix>} decoder
-   * @returns {ComposedDecoder<Prefix|OtherPrefix>}
-   */
-  or (decoder) {
-    return or(this, decoder)
-  }
-
-  /**
-   * @param {string} input
-   * @returns {Uint8Array}
-   */
-  decode (input) {
-    const prefix = /** @type {Prefix} */ (input[0]);
-    const decoder = this.decoders[prefix];
-    if (decoder) {
-      return decoder.decode(input)
-    } else {
-      throw RangeError(`Unable to decode multibase string ${JSON.stringify(input)}, only inputs prefixed with ${Object.keys(this.decoders)} are supported`)
-    }
-  }
-}
-
-/**
- * @template {string} L
- * @template {string} R
- * @param {API.UnibaseDecoder<L>|API.CombobaseDecoder<L>} left
- * @param {API.UnibaseDecoder<R>|API.CombobaseDecoder<R>} right
- * @returns {ComposedDecoder<L|R>}
- */
-const or = (left, right) => new ComposedDecoder(/** @type {Decoders<L|R>} */({
-  ...(left.decoders || { [/** @type API.UnibaseDecoder<L> */(left).prefix]: left }),
-  ...(right.decoders || { [/** @type API.UnibaseDecoder<R> */(right).prefix]: right })
-}));
-
-/**
- * @class
- * @template {string} Base
- * @template {string} Prefix
- * @implements {API.MultibaseCodec<Prefix>}
- * @implements {API.MultibaseEncoder<Prefix>}
- * @implements {API.MultibaseDecoder<Prefix>}
- * @implements {API.BaseCodec}
- * @implements {API.BaseEncoder}
- * @implements {API.BaseDecoder}
- */
-class Codec {
-  /**
-   * @param {Base} name
-   * @param {Prefix} prefix
-   * @param {(bytes:Uint8Array) => string} baseEncode
-   * @param {(text:string) => Uint8Array} baseDecode
-   */
-  constructor (name, prefix, baseEncode, baseDecode) {
-    this.name = name;
-    this.prefix = prefix;
-    this.baseEncode = baseEncode;
-    this.baseDecode = baseDecode;
-    this.encoder = new Encoder(name, prefix, baseEncode);
-    this.decoder = new Decoder(name, prefix, baseDecode);
-  }
-
-  /**
-   * @param {Uint8Array} input
-   */
-  encode (input) {
-    return this.encoder.encode(input)
-  }
-
-  /**
-   * @param {string} input
-   */
-  decode (input) {
-    return this.decoder.decode(input)
-  }
-}
-
-/**
- * @template {string} Base
- * @template {string} Prefix
- * @param {object} options
- * @param {Base} options.name
- * @param {Prefix} options.prefix
- * @param {(bytes:Uint8Array) => string} options.encode
- * @param {(input:string) => Uint8Array} options.decode
- * @returns {Codec<Base, Prefix>}
+ * 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.
  */
-const from = ({ name, prefix, encode, decode }) =>
-  new Codec(name, prefix, encode, decode);
-
-/**
- * @template {string} Base
- * @template {string} Prefix
- * @param {object} options
- * @param {Base} options.name
- * @param {Prefix} options.prefix
- * @param {string} options.alphabet
- * @returns {Codec<Base, Prefix>}
- */
-const baseX = ({ prefix, name, alphabet }) => {
-  const { encode, decode } = _brrp__multiformats_scope_baseX(alphabet, name);
-  return from({
-    prefix,
-    name,
-    encode,
+var TopicValidatorResult;
+(function (TopicValidatorResult) {
     /**
-     * @param {string} text
+     * The message is considered valid, and it should be delivered and forwarded to the network
      */
-    decode: text => coerce(decode(text))
-  })
-};
+    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 = {}));
 
 /**
- * @param {string} string
- * @param {string} alphabet
- * @param {number} bitsPerChar
- * @param {string} name
- * @returns {Uint8Array}
+ * Enum Transport Manager Fault Tolerance values
  */
-const decode$1 = (string, alphabet, bitsPerChar, name) => {
-  // Build the character lookup table:
-  /** @type {Record<string, number>} */
-  const codes = {};
-  for (let i = 0; i < alphabet.length; ++i) {
-    codes[alphabet[i]] = i;
-  }
-
-  // Count the padding bytes:
-  let end = string.length;
-  while (string[end - 1] === '=') {
-    --end;
-  }
-
-  // Allocate the output:
-  const out = new Uint8Array((end * bitsPerChar / 8) | 0);
-
-  // Parse the data:
-  let bits = 0; // Number of bits currently in the buffer
-  let buffer = 0; // Bits waiting to be written out, MSB first
-  let written = 0; // Next byte to write
-  for (let i = 0; i < end; ++i) {
-    // Read one character from the string:
-    const value = codes[string[i]];
-    if (value === undefined) {
-      throw new SyntaxError(`Non-${name} character`)
-    }
-
-    // Append the bits to the buffer:
-    buffer = (buffer << bitsPerChar) | value;
-    bits += bitsPerChar;
-
-    // Write out some bits if the buffer has a byte's worth:
-    if (bits >= 8) {
-      bits -= 8;
-      out[written++] = 0xff & (buffer >> bits);
-    }
-  }
-
-  // Verify that we have received just enough bits:
-  if (bits >= bitsPerChar || 0xff & (buffer << (8 - bits))) {
-    throw new SyntaxError('Unexpected end of data')
-  }
-
-  return out
-};
-
-/**
- * @param {Uint8Array} data
- * @param {string} alphabet
- * @param {number} bitsPerChar
- * @returns {string}
- */
-const encode$1 = (data, alphabet, bitsPerChar) => {
-  const pad = alphabet[alphabet.length - 1] === '=';
-  const mask = (1 << bitsPerChar) - 1;
-  let out = '';
-
-  let bits = 0; // Number of bits currently in the buffer
-  let buffer = 0; // Bits waiting to be written out, MSB first
-  for (let i = 0; i < data.length; ++i) {
-    // Slurp data into the buffer:
-    buffer = (buffer << 8) | data[i];
-    bits += 8;
-
-    // Write out as much as we can:
-    while (bits > bitsPerChar) {
-      bits -= bitsPerChar;
-      out += alphabet[mask & (buffer >> bits)];
-    }
-  }
-
-  // Partial character:
-  if (bits) {
-    out += alphabet[mask & (buffer << (bitsPerChar - bits))];
-  }
-
-  // Add padding characters until we hit a byte boundary:
-  if (pad) {
-    while ((out.length * bitsPerChar) & 7) {
-      out += '=';
-    }
-  }
-
-  return out
-};
-
-/**
- * RFC4648 Factory
- *
- * @template {string} Base
- * @template {string} Prefix
- * @param {object} options
- * @param {Base} options.name
- * @param {Prefix} options.prefix
- * @param {string} options.alphabet
- * @param {number} options.bitsPerChar
- */
-const rfc4648 = ({ name, prefix, bitsPerChar, alphabet }) => {
-  return from({
-    prefix,
-    name,
-    encode (input) {
-      return encode$1(input, alphabet, bitsPerChar)
-    },
-    decode (input) {
-      return decode$1(input, alphabet, bitsPerChar, name)
-    }
-  })
-};
-
-baseX({
-  name: 'base58btc',
-  prefix: 'z',
-  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-});
-
-baseX({
-  name: 'base58flickr',
-  prefix: 'Z',
-  alphabet: '123456789abcdefghijkmnopqrstuvwxyzABCDEFGHJKLMNPQRSTUVWXYZ'
-});
-
-/*! noble-ed25519 - MIT License (c) 2019 Paul Miller (paulmillr.com) */
-const _0n = BigInt(0);
-const _1n = BigInt(1);
-const _2n = BigInt(2);
-const _8n = BigInt(8);
-const CU_O = BigInt('7237005577332262213973186563042994240857116359379907606001950938285454250989');
-const CURVE = Object.freeze({
-    a: BigInt(-1),
-    d: BigInt('37095705934669439343138083508754565189542113879843219016388785533085940283555'),
-    P: BigInt('57896044618658097711785492504343953926634992332820282019728792003956564819949'),
-    l: CU_O,
-    n: CU_O,
-    h: BigInt(8),
-    Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),
-    Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),
-});
-const POW_2_256 = BigInt('0x10000000000000000000000000000000000000000000000000000000000000000');
-const SQRT_M1 = BigInt('19681161376707505956807079304988542015446066515923890162744021073123829784752');
-BigInt('6853475219497561581579357271197624642482790079785650197046958215289687604742');
-const SQRT_AD_MINUS_ONE = BigInt('25063068953384623474111414158702152701244531502492656460079210482610430750235');
-const INVSQRT_A_MINUS_D = BigInt('54469307008909316920995813868745141605393597292927456921205312896311721017578');
-const ONE_MINUS_D_SQ = BigInt('1159843021668779879193775521855586647937357759715417654439879720876111806838');
-const D_MINUS_ONE_SQ = BigInt('40440834346308536858101042469323190826248399146238708352240133220865137265952');
-class ExtendedPoint {
-    constructor(x, y, z, t) {
-        this.x = x;
-        this.y = y;
-        this.z = z;
-        this.t = t;
-    }
-    static fromAffine(p) {
-        if (!(p instanceof Point)) {
-            throw new TypeError('ExtendedPoint#fromAffine: expected Point');
-        }
-        if (p.equals(Point.ZERO))
-            return ExtendedPoint.ZERO;
-        return new ExtendedPoint(p.x, p.y, _1n, mod(p.x * p.y));
-    }
-    static toAffineBatch(points) {
-        const toInv = invertBatch(points.map((p) => p.z));
-        return points.map((p, i) => p.toAffine(toInv[i]));
-    }
-    static normalizeZ(points) {
-        return this.toAffineBatch(points).map(this.fromAffine);
-    }
-    equals(other) {
-        assertExtPoint(other);
-        const { x: X1, y: Y1, z: Z1 } = this;
-        const { x: X2, y: Y2, z: Z2 } = other;
-        const X1Z2 = mod(X1 * Z2);
-        const X2Z1 = mod(X2 * Z1);
-        const Y1Z2 = mod(Y1 * Z2);
-        const Y2Z1 = mod(Y2 * Z1);
-        return X1Z2 === X2Z1 && Y1Z2 === Y2Z1;
-    }
-    negate() {
-        return new ExtendedPoint(mod(-this.x), this.y, this.z, mod(-this.t));
-    }
-    double() {
-        const { x: X1, y: Y1, z: Z1 } = this;
-        const { a } = CURVE;
-        const A = mod(X1 * X1);
-        const B = mod(Y1 * Y1);
-        const C = mod(_2n * mod(Z1 * Z1));
-        const D = mod(a * A);
-        const x1y1 = X1 + Y1;
-        const E = mod(mod(x1y1 * x1y1) - A - B);
-        const G = D + B;
-        const F = G - C;
-        const H = D - B;
-        const X3 = mod(E * F);
-        const Y3 = mod(G * H);
-        const T3 = mod(E * H);
-        const Z3 = mod(F * G);
-        return new ExtendedPoint(X3, Y3, Z3, T3);
-    }
-    add(other) {
-        assertExtPoint(other);
-        const { x: X1, y: Y1, z: Z1, t: T1 } = this;
-        const { x: X2, y: Y2, z: Z2, t: T2 } = other;
-        const A = mod((Y1 - X1) * (Y2 + X2));
-        const B = mod((Y1 + X1) * (Y2 - X2));
-        const F = mod(B - A);
-        if (F === _0n)
-            return this.double();
-        const C = mod(Z1 * _2n * T2);
-        const D = mod(T1 * _2n * Z2);
-        const E = D + C;
-        const G = B + A;
-        const H = D - C;
-        const X3 = mod(E * F);
-        const Y3 = mod(G * H);
-        const T3 = mod(E * H);
-        const Z3 = mod(F * G);
-        return new ExtendedPoint(X3, Y3, Z3, T3);
-    }
-    subtract(other) {
-        return this.add(other.negate());
-    }
-    precomputeWindow(W) {
-        const windows = 1 + 256 / W;
-        const points = [];
-        let p = this;
-        let base = p;
-        for (let window = 0; window < windows; window++) {
-            base = p;
-            points.push(base);
-            for (let i = 1; i < 2 ** (W - 1); i++) {
-                base = base.add(p);
-                points.push(base);
-            }
-            p = base.double();
-        }
-        return points;
-    }
-    wNAF(n, affinePoint) {
-        if (!affinePoint && this.equals(ExtendedPoint.BASE))
-            affinePoint = Point.BASE;
-        const W = (affinePoint && affinePoint._WINDOW_SIZE) || 1;
-        if (256 % W) {
-            throw new Error('Point#wNAF: Invalid precomputation window, must be power of 2');
-        }
-        let precomputes = affinePoint && pointPrecomputes.get(affinePoint);
-        if (!precomputes) {
-            precomputes = this.precomputeWindow(W);
-            if (affinePoint && W !== 1) {
-                precomputes = ExtendedPoint.normalizeZ(precomputes);
-                pointPrecomputes.set(affinePoint, precomputes);
-            }
-        }
-        let p = ExtendedPoint.ZERO;
-        let f = ExtendedPoint.BASE;
-        const windows = 1 + 256 / W;
-        const windowSize = 2 ** (W - 1);
-        const mask = BigInt(2 ** W - 1);
-        const maxNumber = 2 ** W;
-        const shiftBy = BigInt(W);
-        for (let window = 0; window < windows; window++) {
-            const offset = window * windowSize;
-            let wbits = Number(n & mask);
-            n >>= shiftBy;
-            if (wbits > windowSize) {
-                wbits -= maxNumber;
-                n += _1n;
-            }
-            const offset1 = offset;
-            const offset2 = offset + Math.abs(wbits) - 1;
-            const cond1 = window % 2 !== 0;
-            const cond2 = wbits < 0;
-            if (wbits === 0) {
-                f = f.add(constTimeNegate(cond1, precomputes[offset1]));
-            }
-            else {
-                p = p.add(constTimeNegate(cond2, precomputes[offset2]));
-            }
-        }
-        return ExtendedPoint.normalizeZ([p, f])[0];
-    }
-    multiply(scalar, affinePoint) {
-        return this.wNAF(normalizeScalar(scalar, CURVE.l), affinePoint);
-    }
-    multiplyUnsafe(scalar) {
-        let n = normalizeScalar(scalar, CURVE.l, false);
-        const G = ExtendedPoint.BASE;
-        const P0 = ExtendedPoint.ZERO;
-        if (n === _0n)
-            return P0;
-        if (this.equals(P0) || n === _1n)
-            return this;
-        if (this.equals(G))
-            return this.wNAF(n);
-        let p = P0;
-        let d = this;
-        while (n > _0n) {
-            if (n & _1n)
-                p = p.add(d);
-            d = d.double();
-            n >>= _1n;
-        }
-        return p;
-    }
-    isSmallOrder() {
-        return this.multiplyUnsafe(CURVE.h).equals(ExtendedPoint.ZERO);
-    }
-    isTorsionFree() {
-        let p = this.multiplyUnsafe(CURVE.l / _2n).double();
-        if (CURVE.l % _2n)
-            p = p.add(this);
-        return p.equals(ExtendedPoint.ZERO);
-    }
-    toAffine(invZ) {
-        const { x, y, z } = this;
-        const is0 = this.equals(ExtendedPoint.ZERO);
-        if (invZ == null)
-            invZ = is0 ? _8n : invert(z);
-        const ax = mod(x * invZ);
-        const ay = mod(y * invZ);
-        const zz = mod(z * invZ);
-        if (is0)
-            return Point.ZERO;
-        if (zz !== _1n)
-            throw new Error('invZ was invalid');
-        return new Point(ax, ay);
-    }
-    fromRistrettoBytes() {
-        legacyRist();
-    }
-    toRistrettoBytes() {
-        legacyRist();
-    }
-    fromRistrettoHash() {
-        legacyRist();
-    }
-}
-ExtendedPoint.BASE = new ExtendedPoint(CURVE.Gx, CURVE.Gy, _1n, mod(CURVE.Gx * CURVE.Gy));
-ExtendedPoint.ZERO = new ExtendedPoint(_0n, _1n, _1n, _0n);
-function constTimeNegate(condition, item) {
-    const neg = item.negate();
-    return condition ? neg : item;
-}
-function assertExtPoint(other) {
-    if (!(other instanceof ExtendedPoint))
-        throw new TypeError('ExtendedPoint expected');
-}
-function assertRstPoint(other) {
-    if (!(other instanceof RistrettoPoint))
-        throw new TypeError('RistrettoPoint expected');
-}
-function legacyRist() {
-    throw new Error('Legacy method: switch to RistrettoPoint');
-}
-class RistrettoPoint {
-    constructor(ep) {
-        this.ep = ep;
-    }
-    static calcElligatorRistrettoMap(r0) {
-        const { d } = CURVE;
-        const r = mod(SQRT_M1 * r0 * r0);
-        const Ns = mod((r + _1n) * ONE_MINUS_D_SQ);
-        let c = BigInt(-1);
-        const D = mod((c - d * r) * mod(r + d));
-        let { isValid: Ns_D_is_sq, value: s } = uvRatio(Ns, D);
-        let s_ = mod(s * r0);
-        if (!edIsNegative(s_))
-            s_ = mod(-s_);
-        if (!Ns_D_is_sq)
-            s = s_;
-        if (!Ns_D_is_sq)
-            c = r;
-        const Nt = mod(c * (r - _1n) * D_MINUS_ONE_SQ - D);
-        const s2 = s * s;
-        const W0 = mod((s + s) * D);
-        const W1 = mod(Nt * SQRT_AD_MINUS_ONE);
-        const W2 = mod(_1n - s2);
-        const W3 = mod(_1n + s2);
-        return new ExtendedPoint(mod(W0 * W3), mod(W2 * W1), mod(W1 * W3), mod(W0 * W2));
-    }
-    static hashToCurve(hex) {
-        hex = ensureBytes(hex, 64);
-        const r1 = bytes255ToNumberLE(hex.slice(0, 32));
-        const R1 = this.calcElligatorRistrettoMap(r1);
-        const r2 = bytes255ToNumberLE(hex.slice(32, 64));
-        const R2 = this.calcElligatorRistrettoMap(r2);
-        return new RistrettoPoint(R1.add(R2));
-    }
-    static fromHex(hex) {
-        hex = ensureBytes(hex, 32);
-        const { a, d } = CURVE;
-        const emsg = 'RistrettoPoint.fromHex: the hex is not valid encoding of RistrettoPoint';
-        const s = bytes255ToNumberLE(hex);
-        if (!equalBytes(numberTo32BytesLE(s), hex) || edIsNegative(s))
-            throw new Error(emsg);
-        const s2 = mod(s * s);
-        const u1 = mod(_1n + a * s2);
-        const u2 = mod(_1n - a * s2);
-        const u1_2 = mod(u1 * u1);
-        const u2_2 = mod(u2 * u2);
-        const v = mod(a * d * u1_2 - u2_2);
-        const { isValid, value: I } = invertSqrt(mod(v * u2_2));
-        const Dx = mod(I * u2);
-        const Dy = mod(I * Dx * v);
-        let x = mod((s + s) * Dx);
-        if (edIsNegative(x))
-            x = mod(-x);
-        const y = mod(u1 * Dy);
-        const t = mod(x * y);
-        if (!isValid || edIsNegative(t) || y === _0n)
-            throw new Error(emsg);
-        return new RistrettoPoint(new ExtendedPoint(x, y, _1n, t));
-    }
-    toRawBytes() {
-        let { x, y, z, t } = this.ep;
-        const u1 = mod(mod(z + y) * mod(z - y));
-        const u2 = mod(x * y);
-        const u2sq = mod(u2 * u2);
-        const { value: invsqrt } = invertSqrt(mod(u1 * u2sq));
-        const D1 = mod(invsqrt * u1);
-        const D2 = mod(invsqrt * u2);
-        const zInv = mod(D1 * D2 * t);
-        let D;
-        if (edIsNegative(t * zInv)) {
-            let _x = mod(y * SQRT_M1);
-            let _y = mod(x * SQRT_M1);
-            x = _x;
-            y = _y;
-            D = mod(D1 * INVSQRT_A_MINUS_D);
-        }
-        else {
-            D = D2;
-        }
-        if (edIsNegative(x * zInv))
-            y = mod(-y);
-        let s = mod((z - y) * D);
-        if (edIsNegative(s))
-            s = mod(-s);
-        return numberTo32BytesLE(s);
-    }
-    toHex() {
-        return bytesToHex(this.toRawBytes());
-    }
-    toString() {
-        return this.toHex();
-    }
-    equals(other) {
-        assertRstPoint(other);
-        const a = this.ep;
-        const b = other.ep;
-        const one = mod(a.x * b.y) === mod(a.y * b.x);
-        const two = mod(a.y * b.y) === mod(a.x * b.x);
-        return one || two;
-    }
-    add(other) {
-        assertRstPoint(other);
-        return new RistrettoPoint(this.ep.add(other.ep));
-    }
-    subtract(other) {
-        assertRstPoint(other);
-        return new RistrettoPoint(this.ep.subtract(other.ep));
-    }
-    multiply(scalar) {
-        return new RistrettoPoint(this.ep.multiply(scalar));
-    }
-    multiplyUnsafe(scalar) {
-        return new RistrettoPoint(this.ep.multiplyUnsafe(scalar));
-    }
-}
-RistrettoPoint.BASE = new RistrettoPoint(ExtendedPoint.BASE);
-RistrettoPoint.ZERO = new RistrettoPoint(ExtendedPoint.ZERO);
-const pointPrecomputes = new WeakMap();
-class Point {
-    constructor(x, y) {
-        this.x = x;
-        this.y = y;
-    }
-    _setWindowSize(windowSize) {
-        this._WINDOW_SIZE = windowSize;
-        pointPrecomputes.delete(this);
-    }
-    static fromHex(hex, strict = true) {
-        const { d, P } = CURVE;
-        hex = ensureBytes(hex, 32);
-        const normed = hex.slice();
-        normed[31] = hex[31] & ~0x80;
-        const y = bytesToNumberLE(normed);
-        if (strict && y >= P)
-            throw new Error('Expected 0 < hex < P');
-        if (!strict && y >= POW_2_256)
-            throw new Error('Expected 0 < hex < 2**256');
-        const y2 = mod(y * y);
-        const u = mod(y2 - _1n);
-        const v = mod(d * y2 + _1n);
-        let { isValid, value: x } = uvRatio(u, v);
-        if (!isValid)
-            throw new Error('Point.fromHex: invalid y coordinate');
-        const isXOdd = (x & _1n) === _1n;
-        const isLastByteOdd = (hex[31] & 0x80) !== 0;
-        if (isLastByteOdd !== isXOdd) {
-            x = mod(-x);
-        }
-        return new Point(x, y);
-    }
-    static async fromPrivateKey(privateKey) {
-        return (await getExtendedPublicKey(privateKey)).point;
-    }
-    toRawBytes() {
-        const bytes = numberTo32BytesLE(this.y);
-        bytes[31] |= this.x & _1n ? 0x80 : 0;
-        return bytes;
-    }
-    toHex() {
-        return bytesToHex(this.toRawBytes());
-    }
-    toX25519() {
-        const { y } = this;
-        const u = mod((_1n + y) * invert(_1n - y));
-        return numberTo32BytesLE(u);
-    }
-    isTorsionFree() {
-        return ExtendedPoint.fromAffine(this).isTorsionFree();
-    }
-    equals(other) {
-        return this.x === other.x && this.y === other.y;
-    }
-    negate() {
-        return new Point(mod(-this.x), this.y);
-    }
-    add(other) {
-        return ExtendedPoint.fromAffine(this).add(ExtendedPoint.fromAffine(other)).toAffine();
-    }
-    subtract(other) {
-        return this.add(other.negate());
-    }
-    multiply(scalar) {
-        return ExtendedPoint.fromAffine(this).multiply(scalar, this).toAffine();
-    }
-}
-Point.BASE = new Point(CURVE.Gx, CURVE.Gy);
-Point.ZERO = new Point(_0n, _1n);
-function concatBytes(...arrays) {
-    if (!arrays.every((a) => a instanceof Uint8Array))
-        throw new Error('Expected Uint8Array list');
-    if (arrays.length === 1)
-        return arrays[0];
-    const length = arrays.reduce((a, arr) => a + arr.length, 0);
-    const result = new Uint8Array(length);
-    for (let i = 0, pad = 0; i < arrays.length; i++) {
-        const arr = arrays[i];
-        result.set(arr, pad);
-        pad += arr.length;
-    }
-    return result;
-}
-const hexes = Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
-function bytesToHex(uint8a) {
-    if (!(uint8a instanceof Uint8Array))
-        throw new Error('Uint8Array expected');
-    let hex = '';
-    for (let i = 0; i < uint8a.length; i++) {
-        hex += hexes[uint8a[i]];
-    }
-    return hex;
-}
-function hexToBytes(hex) {
-    if (typeof hex !== 'string') {
-        throw new TypeError('hexToBytes: expected string, got ' + typeof hex);
-    }
-    if (hex.length % 2)
-        throw new Error('hexToBytes: received invalid unpadded hex');
-    const array = new Uint8Array(hex.length / 2);
-    for (let i = 0; i < array.length; i++) {
-        const j = i * 2;
-        const hexByte = hex.slice(j, j + 2);
-        const byte = Number.parseInt(hexByte, 16);
-        if (Number.isNaN(byte) || byte < 0)
-            throw new Error('Invalid byte sequence');
-        array[i] = byte;
-    }
-    return array;
-}
-function numberTo32BytesBE(num) {
-    const length = 32;
-    const hex = num.toString(16).padStart(length * 2, '0');
-    return hexToBytes(hex);
-}
-function numberTo32BytesLE(num) {
-    return numberTo32BytesBE(num).reverse();
-}
-function edIsNegative(num) {
-    return (mod(num) & _1n) === _1n;
-}
-function bytesToNumberLE(uint8a) {
-    if (!(uint8a instanceof Uint8Array))
-        throw new Error('Expected Uint8Array');
-    return BigInt('0x' + bytesToHex(Uint8Array.from(uint8a).reverse()));
-}
-const MAX_255B = BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
-function bytes255ToNumberLE(bytes) {
-    return mod(bytesToNumberLE(bytes) & MAX_255B);
-}
-function mod(a, b = CURVE.P) {
-    const res = a % b;
-    return res >= _0n ? res : b + res;
-}
-function invert(number, modulo = CURVE.P) {
-    if (number === _0n || modulo <= _0n) {
-        throw new Error(`invert: expected positive integers, got n=${number} mod=${modulo}`);
-    }
-    let a = mod(number, modulo);
-    let b = modulo;
-    let x = _0n, u = _1n;
-    while (a !== _0n) {
-        const q = b / a;
-        const r = b % a;
-        const m = x - u * q;
-        b = a, a = r, x = u, u = m;
-    }
-    const gcd = b;
-    if (gcd !== _1n)
-        throw new Error('invert: does not exist');
-    return mod(x, modulo);
-}
-function invertBatch(nums, p = CURVE.P) {
-    const tmp = new Array(nums.length);
-    const lastMultiplied = nums.reduce((acc, num, i) => {
-        if (num === _0n)
-            return acc;
-        tmp[i] = acc;
-        return mod(acc * num, p);
-    }, _1n);
-    const inverted = invert(lastMultiplied, p);
-    nums.reduceRight((acc, num, i) => {
-        if (num === _0n)
-            return acc;
-        tmp[i] = mod(acc * tmp[i], p);
-        return mod(acc * num, p);
-    }, inverted);
-    return tmp;
-}
-function pow2(x, power) {
-    const { P } = CURVE;
-    let res = x;
-    while (power-- > _0n) {
-        res *= res;
-        res %= P;
-    }
-    return res;
-}
-function pow_2_252_3(x) {
-    const { P } = CURVE;
-    const _5n = BigInt(5);
-    const _10n = BigInt(10);
-    const _20n = BigInt(20);
-    const _40n = BigInt(40);
-    const _80n = BigInt(80);
-    const x2 = (x * x) % P;
-    const b2 = (x2 * x) % P;
-    const b4 = (pow2(b2, _2n) * b2) % P;
-    const b5 = (pow2(b4, _1n) * x) % P;
-    const b10 = (pow2(b5, _5n) * b5) % P;
-    const b20 = (pow2(b10, _10n) * b10) % P;
-    const b40 = (pow2(b20, _20n) * b20) % P;
-    const b80 = (pow2(b40, _40n) * b40) % P;
-    const b160 = (pow2(b80, _80n) * b80) % P;
-    const b240 = (pow2(b160, _80n) * b80) % P;
-    const b250 = (pow2(b240, _10n) * b10) % P;
-    const pow_p_5_8 = (pow2(b250, _2n) * x) % P;
-    return { pow_p_5_8, b2 };
-}
-function uvRatio(u, v) {
-    const v3 = mod(v * v * v);
-    const v7 = mod(v3 * v3 * v);
-    const pow = pow_2_252_3(u * v7).pow_p_5_8;
-    let x = mod(u * v3 * pow);
-    const vx2 = mod(v * x * x);
-    const root1 = x;
-    const root2 = mod(x * SQRT_M1);
-    const useRoot1 = vx2 === u;
-    const useRoot2 = vx2 === mod(-u);
-    const noRoot = vx2 === mod(-u * SQRT_M1);
-    if (useRoot1)
-        x = root1;
-    if (useRoot2 || noRoot)
-        x = root2;
-    if (edIsNegative(x))
-        x = mod(-x);
-    return { isValid: useRoot1 || useRoot2, value: x };
-}
-function invertSqrt(number) {
-    return uvRatio(_1n, number);
-}
-function modlLE(hash) {
-    return mod(bytesToNumberLE(hash), CURVE.l);
-}
-function equalBytes(b1, b2) {
-    if (b1.length !== b2.length) {
-        return false;
-    }
-    for (let i = 0; i < b1.length; i++) {
-        if (b1[i] !== b2[i]) {
-            return false;
-        }
-    }
-    return true;
-}
-function ensureBytes(hex, expectedLength) {
-    const bytes = hex instanceof Uint8Array ? Uint8Array.from(hex) : hexToBytes(hex);
-    if (typeof expectedLength === 'number' && bytes.length !== expectedLength)
-        throw new Error(`Expected ${expectedLength} bytes`);
-    return bytes;
-}
-function normalizeScalar(num, max, strict = true) {
-    if (!max)
-        throw new TypeError('Specify max value');
-    if (typeof num === 'number' && Number.isSafeInteger(num))
-        num = BigInt(num);
-    if (typeof num === 'bigint' && num < max) {
-        if (strict) {
-            if (_0n < num)
-                return num;
-        }
-        else {
-            if (_0n <= num)
-                return num;
-        }
-    }
-    throw new TypeError('Expected valid scalar: 0 < scalar < max');
-}
-function adjustBytes25519(bytes) {
-    bytes[0] &= 248;
-    bytes[31] &= 127;
-    bytes[31] |= 64;
-    return bytes;
-}
-function checkPrivateKey(key) {
-    key =
-        typeof key === 'bigint' || typeof key === 'number'
-            ? numberTo32BytesBE(normalizeScalar(key, POW_2_256))
-            : ensureBytes(key);
-    if (key.length !== 32)
-        throw new Error(`Expected 32 bytes`);
-    return key;
-}
-function getKeyFromHash(hashed) {
-    const head = adjustBytes25519(hashed.slice(0, 32));
-    const prefix = hashed.slice(32, 64);
-    const scalar = modlLE(head);
-    const point = Point.BASE.multiply(scalar);
-    const pointBytes = point.toRawBytes();
-    return { head, prefix, scalar, point, pointBytes };
-}
-let _sha512Sync;
-async function getExtendedPublicKey(key) {
-    return getKeyFromHash(await utils.sha512(checkPrivateKey(key)));
-}
-Point.BASE._setWindowSize(8);
-const crypto$1 = {
-    node: nodeCrypto,
-    web: typeof self === 'object' && 'crypto' in self ? self.crypto : undefined,
-};
-const utils = {
-    bytesToHex,
-    hexToBytes,
-    concatBytes,
-    getExtendedPublicKey,
-    mod,
-    invert,
-    TORSION_SUBGROUP: [
-        '0100000000000000000000000000000000000000000000000000000000000000',
-        'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac037a',
-        '0000000000000000000000000000000000000000000000000000000000000080',
-        '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc05',
-        'ecffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff7f',
-        '26e8958fc2b227b045c3f489f2ef98f0d5dfac05d3c63339b13802886d53fc85',
-        '0000000000000000000000000000000000000000000000000000000000000000',
-        'c7176a703d4dd84fba3c0b760d10670f2a2053fa2c39ccc64ec7fd7792ac03fa',
-    ],
-    hashToPrivateScalar: (hash) => {
-        hash = ensureBytes(hash);
-        if (hash.length < 40 || hash.length > 1024)
-            throw new Error('Expected 40-1024 bytes of private key as per FIPS 186');
-        return mod(bytesToNumberLE(hash), CURVE.l - _1n) + _1n;
-    },
-    randomBytes: (bytesLength = 32) => {
-        if (crypto$1.web) {
-            return crypto$1.web.getRandomValues(new Uint8Array(bytesLength));
-        }
-        else if (crypto$1.node) {
-            const { randomBytes } = crypto$1.node;
-            return new Uint8Array(randomBytes(bytesLength).buffer);
-        }
-        else {
-            throw new Error("The environment doesn't have randomBytes function");
-        }
-    },
-    randomPrivateKey: () => {
-        return utils.randomBytes(32);
-    },
-    sha512: async (...messages) => {
-        const message = concatBytes(...messages);
-        if (crypto$1.web) {
-            const buffer = await crypto$1.web.subtle.digest('SHA-512', message.buffer);
-            return new Uint8Array(buffer);
-        }
-        else if (crypto$1.node) {
-            return Uint8Array.from(crypto$1.node.createHash('sha512').update(message).digest());
-        }
-        else {
-            throw new Error("The environment doesn't have sha512 function");
-        }
-    },
-    precompute(windowSize = 8, point = Point.BASE) {
-        const cached = point.equals(Point.BASE) ? point : new Point(point.x, point.y);
-        cached._setWindowSize(windowSize);
-        cached.multiply(_2n);
-        return cached;
-    },
-    sha512Sync: undefined,
-};
-Object.defineProperties(utils, {
-    sha512Sync: {
-        configurable: false,
-        get() {
-            return _sha512Sync;
-        },
-        set(val) {
-            if (!_sha512Sync)
-                _sha512Sync = val;
-        },
-    },
-});
-
-// @ts-check
-
-
-rfc4648({
-  prefix: 'm',
-  name: 'base64',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
-  bitsPerChar: 6
-});
-
-rfc4648({
-  prefix: 'M',
-  name: 'base64pad',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
-  bitsPerChar: 6
-});
-
-rfc4648({
-  prefix: 'u',
-  name: 'base64url',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
-  bitsPerChar: 6
-});
-
-rfc4648({
-  prefix: 'U',
-  name: 'base64urlpad',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
-  bitsPerChar: 6
-});
+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 */
@@ -19934,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);
             }
         }
     }
@@ -19952,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 { cluster, indexList };
+    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 new Uint8Array(buffer);
 };
 
 new Logger("enr");
@@ -19975,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;
@@ -20003,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;
@@ -20014,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);
@@ -20056,23 +18979,26 @@ class KeepAliveManager {
         this.pingKeepAliveTimers.clear();
         this.relayKeepAliveTimers.clear();
     }
+    connectionsExist() {
+        return (this.pingKeepAliveTimers.size > 0 || this.relayKeepAliveTimers.size > 0);
+    }
     scheduleRelayPings(relay, relayPeriodSecs, peerIdStr) {
-        // send a ping message to each PubSubTopic the peer is part of
+        // send a ping message to each PubsubTopic the peer is part of
         const intervals = [];
         for (const topic of relay.pubsubTopics) {
             const meshPeers = relay.getMeshPeers(topic);
             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);
         }
@@ -20080,12 +19006,12 @@ 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;
 class ConnectionManager extends EventEmitter {
-    configuredPubSubTopics;
+    configuredPubsubTopics;
     static instances = new Map();
     keepAliveManager;
     options;
@@ -20094,6 +19020,26 @@ class ConnectionManager extends EventEmitter {
     dialErrorsForPeer = new Map();
     currentActiveParallelDialCount = 0;
     pendingPeerDialQueue = [];
+    online = false;
+    isConnected() {
+        return this.online;
+    }
+    toggleOnline() {
+        if (!this.online) {
+            this.online = true;
+            this.dispatchEvent(new CustomEvent(EConnectionStateEvents.CONNECTION_STATUS, {
+                detail: this.online
+            }));
+        }
+    }
+    toggleOffline() {
+        if (this.online && this.libp2p.getConnections().length == 0) {
+            this.online = false;
+            this.dispatchEvent(new CustomEvent(EConnectionStateEvents.CONNECTION_STATUS, {
+                detail: this.online
+            }));
+        }
+    }
     static create(peerId, libp2p, keepAliveOptions, pubsubTopics, relay, options) {
         let instance = ConnectionManager.instances.get(peerId);
         if (!instance) {
@@ -20141,11 +19087,11 @@ class ConnectionManager extends EventEmitter {
             }
         };
     }
-    constructor(libp2p, keepAliveOptions, configuredPubSubTopics, relay, options) {
+    constructor(libp2p, keepAliveOptions, configuredPubsubTopics, relay, options) {
         super();
-        this.configuredPubSubTopics = configuredPubSubTopics;
+        this.configuredPubsubTopics = configuredPubsubTopics;
         this.libp2p = libp2p;
-        this.configuredPubSubTopics = configuredPubSubTopics;
+        this.configuredPubsubTopics = configuredPubsubTopics;
         this.options = {
             maxDialAttemptsForPeer: DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER,
             maxBootstrapPeersAllowed: DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED,
@@ -20154,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();
@@ -20173,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() {
@@ -20193,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
@@ -20210,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++;
@@ -20232,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]);
@@ -20244,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);
@@ -20258,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() {
@@ -20271,7 +19217,7 @@ class ConnectionManager extends EventEmitter {
             if (!peerId)
                 return;
             this.attemptDial(peerId).catch((error) => {
-                log$5.error(error);
+                log$6.error(error);
             });
         }
     }
@@ -20304,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 = {
@@ -20316,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}`);
                 }
             })();
         },
@@ -20344,12 +19290,14 @@ class ConnectionManager extends EventEmitter {
                         detail: peerId
                     }));
                 }
+                this.toggleOnline();
             })();
         },
-        "peer:disconnect": () => {
-            return (evt) => {
+        "peer:disconnect": (evt) => {
+            void (async () => {
                 this.keepAliveManager.stop(evt.detail);
-            };
+                this.toggleOffline();
+            })();
         }
     };
     /**
@@ -20364,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;
@@ -20425,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 [];
         }
     }
@@ -20434,8 +19382,8 @@ class ConnectionManager extends EventEmitter {
         // If there's no shard information, simply return true
         if (!shardInfo)
             return true;
-        const pubsubTopics = shardInfoToPubSubTopics(shardInfo);
-        const isTopicConfigured = pubsubTopics.some((topic) => this.configuredPubSubTopics.includes(topic));
+        const pubsubTopics = shardInfoToPubsubTopics(shardInfo);
+        const isTopicConfigured = pubsubTopics.some((topic) => this.configuredPubsubTopics.includes(topic));
         return isTopicConfigured;
     }
     async getPeerShardInfo(peerId, peerStore) {
@@ -20450,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);
@@ -20479,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}`);
     }
     /**
@@ -20504,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)) {
@@ -20512,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)) {
@@ -20520,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)) {
@@ -20528,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() {
@@ -20544,6 +19498,9 @@ class WakuNode {
     isStarted() {
         return this.libp2p.isStarted();
     }
+    isConnected() {
+        return this.connectionManager.isConnected();
+    }
     /**
      * Return the local multiaddr with peer id on which libp2p is listening.
      *
@@ -20576,6 +19533,38 @@ var index$3 = /*#__PURE__*/Object.freeze({
     version_0: version_0
 });
 
+/**
+ * @packageDocumentation
+ *
+ * For when you need a one-liner to collect iterable values.
+ *
+ * @example
+ *
+ * ```javascript
+ * import all from 'it-all'
+ *
+ * // This can also be an iterator, etc
+ * const values = function * () {
+ *   yield * [0, 1, 2, 3, 4]
+ * }
+ *
+ * const arr = all(values)
+ *
+ * console.info(arr) // 0, 1, 2, 3, 4
+ * ```
+ *
+ * Async sources must be awaited:
+ *
+ * ```javascript
+ * const values = async function * () {
+ *   yield * [0, 1, 2, 3, 4]
+ * }
+ *
+ * const arr = await all(values())
+ *
+ * console.info(arr) // 0, 1, 2, 3, 4
+ * ```
+ */
 function isAsyncIterable$3(thing) {
     return thing[Symbol.asyncIterator] != null;
 }
@@ -21090,7 +20079,7 @@ function isAsyncIterable$2(thing) {
 const defaultEncoder = (length) => {
     const lengthLength = encodingLength(length);
     const lengthBuf = allocUnsafe(lengthLength);
-    encode$2(length, lengthBuf);
+    encode$1(length, lengthBuf);
     defaultEncoder.bytes = lengthLength;
     return lengthBuf;
 };
@@ -21216,7 +20205,7 @@ var ReadMode;
     ReadMode[ReadMode["DATA"] = 1] = "DATA";
 })(ReadMode || (ReadMode = {}));
 const defaultDecoder = (buf) => {
-    const length = decode$2(buf);
+    const length = decode$1(buf);
     defaultDecoder.bytes = encodingLength(length);
     return length;
 };
@@ -21953,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"
@@ -21990,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: " +
@@ -22040,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);
         }
     }
@@ -22060,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);
@@ -22070,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);
@@ -22089,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
@@ -22140,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);
         }
     }
 }
@@ -22173,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 {
@@ -22184,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);
     }
 }
 
@@ -22224,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/).
@@ -22234,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
@@ -22258,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
@@ -22293,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;
@@ -22301,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();
@@ -22313,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)) ||
@@ -22350,299 +21342,6 @@ var index$1 = /*#__PURE__*/Object.freeze({
     wakuLightPush: wakuLightPush
 });
 
-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 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
-
 const EmptyMessage = {
     payload: new Uint8Array(),
     contentTopic: "",
@@ -22727,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;
 /**
@@ -22740,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.
@@ -22859,18 +21558,18 @@ class Store extends BaseProtocol {
             endTime = options.timeFilter.endTime;
         }
         // convert array to set to remove duplicates
-        const uniquePubSubTopicsInQuery = Array.from(new Set(decoders.map((decoder) => decoder.pubsubTopic)));
+        const uniquePubsubTopicsInQuery = Array.from(new Set(decoders.map((decoder) => decoder.pubsubTopic)));
         // If multiple pubsub topics are provided, throw an error
-        if (uniquePubSubTopicsInQuery.length > 1) {
+        if (uniquePubsubTopicsInQuery.length > 1) {
             throw new Error("API does not support querying multiple pubsub topics at once");
         }
         // we can be certain that there is only one pubsub topic in the query
-        const pubSubTopicForQuery = uniquePubSubTopicsInQuery[0];
-        ensurePubsubTopicIsConfigured(pubSubTopicForQuery, this.pubsubTopics);
+        const pubsubTopicForQuery = uniquePubsubTopicsInQuery[0];
+        ensurePubsubTopicIsConfigured(pubsubTopicForQuery, this.pubsubTopics);
         // check that the pubsubTopic from the Cursor and Decoder match
         if (options?.cursor?.pubsubTopic &&
-            options.cursor.pubsubTopic !== pubSubTopicForQuery) {
-            throw new Error(`Cursor pubsub topic (${options?.cursor?.pubsubTopic}) does not match decoder pubsub topic (${pubSubTopicForQuery})`);
+            options.cursor.pubsubTopic !== pubsubTopicForQuery) {
+            throw new Error(`Cursor pubsub topic (${options?.cursor?.pubsubTopic}) does not match decoder pubsub topic (${pubsubTopicForQuery})`);
         }
         const decodersAsMap = new Map();
         decoders.forEach((dec) => {
@@ -22880,13 +21579,13 @@ class Store extends BaseProtocol {
             decodersAsMap.set(dec.contentTopic, dec);
         });
         const contentTopics = decoders
-            .filter((decoder) => decoder.pubsubTopic === pubSubTopicForQuery)
+            .filter((decoder) => decoder.pubsubTopic === pubsubTopicForQuery)
             .map((dec) => dec.contentTopic);
         if (contentTopics.length === 0) {
-            throw new Error("No decoders found for topic " + pubSubTopicForQuery);
+            throw new Error("No decoders found for topic " + pubsubTopicForQuery);
         }
         const queryOpts = Object.assign({
-            pubsubTopic: pubSubTopicForQuery,
+            pubsubTopic: pubsubTopicForQuery,
             pageDirection: PageDirection.BACKWARD,
             pageSize: DefaultPageSize
         }, options, { contentTopics, startTime, endTime });
@@ -22908,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();
@@ -22917,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;
@@ -22925,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") {
@@ -22943,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;
@@ -22965,8 +21664,8 @@ async function createCursor(message) {
         !message.contentTopic) {
         throw new Error("Message is missing required fields");
     }
-    const contentTopicBytes = utf8ToBytes$1(message.contentTopic);
-    const digest = sha256(concat$1([contentTopicBytes, message.payload]));
+    const contentTopicBytes = utf8ToBytes(message.contentTopic);
+    const digest = sha256$1(concat$1([contentTopicBytes, message.payload]));
     const messageTime = BigInt(message.timestamp.getTime()) * BigInt(1000000);
     return {
         digest,
@@ -23220,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
@@ -23279,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) => {
@@ -23327,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 };