@waku/enr 0.0.20-7eb3375.0 → 0.0.20

package/bundle/index.js

@@ -10,7 +10,7 @@ const MULTIADDR_LENGTH_SIZE = 2;
  * To guarantee Uint8Array semantics, convert nodejs Buffers
  * into vanilla Uint8Arrays
  */
-function asUint8Array(buf) {
+function asUint8Array$1(buf) {
     if (globalThis.Buffer != null) {
         return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
     }
@@ -147,7 +147,7 @@ var _brrp__multiformats_scope_baseX = src;
  * @param {Uint8Array} aa
  * @param {Uint8Array} bb
  */
-const equals$2 = (aa, bb) => {
+const equals$3 = (aa, bb) => {
   if (aa === bb) return true
   if (aa.byteLength !== bb.byteLength) {
     return false
@@ -179,13 +179,13 @@ const coerce = o => {
  * @param {string} str
  * @returns {Uint8Array}
  */
-const fromString$1 = str => (new TextEncoder()).encode(str);
+const fromString$2 = str => (new TextEncoder()).encode(str);
 
 /**
  * @param {Uint8Array} b
  * @returns {string}
  */
-const toString$2 = b => (new TextDecoder()).decode(b);
+const toString$3 = b => (new TextDecoder()).decode(b);
 
 /**
  * Class represents both BaseEncoder and MultibaseEncoder meaning it
@@ -793,8 +793,8 @@ var base8$1 = /*#__PURE__*/Object.freeze({
 const identity$1 = from$1({
   prefix: '\x00',
   name: 'identity',
-  encode: (buf) => toString$2(buf),
-  decode: (str) => fromString$1(str)
+  encode: (buf) => toString$3(buf),
+  decode: (str) => fromString$2(str)
 });
 
 var identityBase = /*#__PURE__*/Object.freeze({
@@ -974,7 +974,7 @@ const decode$2 = (multihash) => {
  * @param {unknown} b
  * @returns {b is MultihashDigest}
  */
-const equals$1 = (a, b) => {
+const equals$2 = (a, b) => {
   if (a === b) {
     return true
   } else {
@@ -984,7 +984,7 @@ const equals$1 = (a, b) => {
       a.code === data.code &&
       a.size === data.size &&
       data.bytes instanceof Uint8Array &&
-      equals$2(a.bytes, data.bytes)
+      equals$3(a.bytes, data.bytes)
     )
   }
 };
@@ -1287,7 +1287,7 @@ class CID {
       unknown &&
       self.code === unknown.code &&
       self.version === unknown.version &&
-      equals$1(self.multihash, unknown.multihash)
+      equals$2(self.multihash, unknown.multihash)
     )
   }
 
@@ -1692,14 +1692,14 @@ const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$
  * uninitialized memory. Only use if you are certain you will immediately
  * overwrite every value in the returned `Uint8Array`.
  */
-function allocUnsafe(size = 0) {
+function allocUnsafe$1(size = 0) {
     if (globalThis.Buffer?.allocUnsafe != null) {
-        return asUint8Array(globalThis.Buffer.allocUnsafe(size));
+        return asUint8Array$1(globalThis.Buffer.allocUnsafe(size));
     }
     return new Uint8Array(size);
 }
 
-function createCodec$1(name, prefix, encode, decode) {
+function createCodec$2(name, prefix, encode, decode) {
     return {
         name,
         prefix,
@@ -1713,14 +1713,14 @@ function createCodec$1(name, prefix, encode, decode) {
         }
     };
 }
-const string = createCodec$1('utf8', 'u', (buf) => {
+const string$1 = createCodec$2('utf8', 'u', (buf) => {
     const decoder = new TextDecoder('utf8');
     return 'u' + decoder.decode(buf);
 }, (str) => {
     const encoder = new TextEncoder();
     return encoder.encode(str.substring(1));
 });
-const ascii = createCodec$1('ascii', 'a', (buf) => {
+const ascii$1 = createCodec$2('ascii', 'a', (buf) => {
     let string = 'a';
     for (let i = 0; i < buf.length; i++) {
         string += String.fromCharCode(buf[i]);
@@ -1728,19 +1728,19 @@ const ascii = createCodec$1('ascii', 'a', (buf) => {
     return string;
 }, (str) => {
     str = str.substring(1);
-    const buf = allocUnsafe(str.length);
+    const buf = allocUnsafe$1(str.length);
     for (let i = 0; i < str.length; i++) {
         buf[i] = str.charCodeAt(i);
     }
     return buf;
 });
-const BASES = {
-    utf8: string,
-    'utf-8': string,
+const BASES$1 = {
+    utf8: string$1,
+    'utf-8': string$1,
     hex: bases.base16,
-    latin1: ascii,
-    ascii,
-    binary: ascii,
+    latin1: ascii$1,
+    ascii: ascii$1,
+    binary: ascii$1,
     ...bases
 };
 
@@ -1751,13 +1751,13 @@ const BASES = {
  *
  * Also `ascii` which is similar to node's 'binary' encoding.
  */
-function fromString(string, encoding = 'utf8') {
-    const base = BASES[encoding];
+function fromString$1(string, encoding = 'utf8') {
+    const base = BASES$1[encoding];
     if (base == null) {
         throw new Error(`Unsupported encoding "${encoding}"`);
     }
     if ((encoding === 'utf8' || encoding === 'utf-8') && globalThis.Buffer != null && globalThis.Buffer.from != null) {
-        return asUint8Array(globalThis.Buffer.from(string, 'utf-8'));
+        return asUint8Array$1(globalThis.Buffer.from(string, 'utf-8'));
     }
     // add multibase prefix
     return base.decoder.decode(`${base.prefix}${string}`); // eslint-disable-line @typescript-eslint/restrict-template-expressions
@@ -1770,8 +1770,8 @@ function fromString(string, encoding = 'utf8') {
  *
  * Also `ascii` which is similar to node's 'binary' encoding.
  */
-function toString$1(array, encoding = 'utf8') {
-    const base = BASES[encoding];
+function toString$2(array, encoding = 'utf8') {
+    const base = BASES$1[encoding];
     if (base == null) {
         throw new Error(`Unsupported encoding "${encoding}"`);
     }
@@ -1790,26 +1790,26 @@ function toString$1(array, encoding = 'utf8') {
 function hexToBytes$2(hex) {
     if (typeof hex === "string") {
         const _hex = hex.replace(/^0x/i, "");
-        return fromString(_hex.toLowerCase(), "base16");
+        return fromString$1(_hex.toLowerCase(), "base16");
     }
     return hex;
 }
 /**
  * Convert byte array to hex string (no `0x` prefix).
  */
-const bytesToHex$2 = (bytes) => toString$1(bytes, "base16");
+const bytesToHex$2 = (bytes) => toString$2(bytes, "base16");
 /**
  * Decode byte array to utf-8 string.
  */
-const bytesToUtf8 = (b) => toString$1(b, "utf8");
+const bytesToUtf8 = (b) => toString$2(b, "utf8");
 /**
  * Encode utf-8 string to byte array.
  */
-const utf8ToBytes$2 = (s) => fromString(s, "utf8");
+const utf8ToBytes$2 = (s) => fromString$1(s, "utf8");
 /**
  * Concatenate using Uint8Arrays as `Buffer` has a different behavior with `DataView`
  */
-function concat$1(byteArrays, totalLength) {
+function concat$2(byteArrays, totalLength) {
     const len = totalLength ?? byteArrays.reduce((acc, curr) => acc + curr.length, 0);
     const res = new Uint8Array(len);
     let offset = 0;
@@ -3559,14 +3559,14 @@ async function sign$1(message, privateKey) {
         recovered: true,
         der: false
     });
-    return concat$1([signature, new Uint8Array([recoveryId])], signature.length + 1);
+    return concat$2([signature, new Uint8Array([recoveryId])], signature.length + 1);
 }
 function keccak256(input) {
     return new Uint8Array(sha3.keccak256.arrayBuffer(input));
 }
 function compressPublicKey$1(publicKey) {
     if (publicKey.length === 64) {
-        publicKey = concat$1([new Uint8Array([4]), publicKey], 65);
+        publicKey = concat$2([new Uint8Array([4]), publicKey], 65);
     }
     const point = Point.fromHex(publicKey);
     return point.toRawBytes(true);
@@ -3912,6 +3912,85 @@ class SHA256 extends SHA2 {
  */
 const sha256$1 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
+var Protocols;
+(function (Protocols) {
+    Protocols["Relay"] = "relay";
+    Protocols["Store"] = "store";
+    Protocols["LightPush"] = "lightpush";
+    Protocols["Filter"] = "filter";
+})(Protocols || (Protocols = {}));
+var SendError;
+(function (SendError) {
+    /** Could not determine the origin of the fault. Best to check connectivity and try again */
+    SendError["GENERIC_FAIL"] = "Generic error";
+    /**
+     * Failure to protobuf encode the message. This is not recoverable and needs
+     * further investigation.
+     */
+    SendError["ENCODE_FAILED"] = "Failed to encode";
+    /**
+     * Failure to protobuf decode the message. May be due to a remote peer issue,
+     * ensuring that messages are sent via several peer enable mitigation of this error.
+     */
+    SendError["DECODE_FAILED"] = "Failed to decode";
+    /**
+     * The message payload is empty, making the message invalid. Ensure that a non-empty
+     * payload is set on the outgoing message.
+     */
+    SendError["EMPTY_PAYLOAD"] = "Payload is empty";
+    /**
+     * The message size is above the maximum message size allowed on the Waku Network.
+     * Compressing the message or using an alternative strategy for large messages is recommended.
+     */
+    SendError["SIZE_TOO_BIG"] = "Size is too big";
+    /**
+     * The PubsubTopic passed to the send function is not configured on the Waku node.
+     * Please ensure that the PubsubTopic is used when initializing the Waku node.
+     */
+    SendError["TOPIC_NOT_CONFIGURED"] = "Topic not configured";
+    /**
+     * Failure to find a peer with suitable protocols. This may due to a connection issue.
+     * Mitigation can be: retrying after a given time period, display connectivity issue
+     * to user or listening for `peer:connected:bootstrap` or `peer:connected:peer-exchange`
+     * on the connection manager before retrying.
+     */
+    SendError["NO_PEER_AVAILABLE"] = "No peer available";
+    /**
+     * The remote peer did not behave as expected. Mitigation for `NO_PEER_AVAILABLE`
+     * or `DECODE_FAILED` can be used.
+     */
+    SendError["REMOTE_PEER_FAULT"] = "Remote peer fault";
+    /**
+     * The remote peer rejected the message. Information provided by the remote peer
+     * is logged. Review message validity, or mitigation for `NO_PEER_AVAILABLE`
+     * or `DECODE_FAILED` can be used.
+     */
+    SendError["REMOTE_PEER_REJECTED"] = "Remote peer rejected";
+})(SendError || (SendError = {}));
+
+var PageDirection;
+(function (PageDirection) {
+    PageDirection["BACKWARD"] = "backward";
+    PageDirection["FORWARD"] = "forward";
+})(PageDirection || (PageDirection = {}));
+
+var Tags;
+(function (Tags) {
+    Tags["BOOTSTRAP"] = "bootstrap";
+    Tags["PEER_EXCHANGE"] = "peer-exchange";
+})(Tags || (Tags = {}));
+var EPeersByDiscoveryEvents;
+(function (EPeersByDiscoveryEvents) {
+    EPeersByDiscoveryEvents["PEER_DISCOVERY_BOOTSTRAP"] = "peer:discovery:bootstrap";
+    EPeersByDiscoveryEvents["PEER_DISCOVERY_PEER_EXCHANGE"] = "peer:discovery:peer-exchange";
+    EPeersByDiscoveryEvents["PEER_CONNECT_BOOTSTRAP"] = "peer:connected:bootstrap";
+    EPeersByDiscoveryEvents["PEER_CONNECT_PEER_EXCHANGE"] = "peer:connected:peer-exchange";
+})(EPeersByDiscoveryEvents || (EPeersByDiscoveryEvents = {}));
+var EConnectionStateEvents;
+(function (EConnectionStateEvents) {
+    EConnectionStateEvents["CONNECTION_STATUS"] = "waku:connection";
+})(EConnectionStateEvents || (EConnectionStateEvents = {}));
+
 var browser = {exports: {}};
 
 /**
@@ -4662,12 +4741,51 @@ let Logger$1 = class Logger {
     }
 };
 
+/**
+ * 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
  * AbortSignal.
  */
-class CodeError extends Error {
+let CodeError$1 = class CodeError extends Error {
     code;
     props;
     constructor(message, code, props) {
@@ -4676,12 +4794,12 @@ class CodeError extends Error {
         this.name = props?.name ?? 'CodeError';
         this.props = props ?? {}; // eslint-disable-line @typescript-eslint/consistent-type-assertions
     }
-}
+};
 
 /**
  * Returns true if the two passed Uint8Arrays have the same content
  */
-function equals(a, b) {
+function equals$1(a, b) {
     if (a === b) {
         return true;
     }
@@ -4903,7 +5021,7 @@ function decodeUint8ArrayList(buf, offset) {
 }
 function encode$1(value, buf, offset = 0) {
     if (buf == null) {
-        buf = allocUnsafe(encodingLength(value));
+        buf = allocUnsafe$1(encodingLength(value));
     }
     if (buf instanceof Uint8Array) {
         return encodeUint8Array(value, buf, offset);
@@ -4924,17 +5042,17 @@ function decode$1(buf, offset = 0) {
 /**
  * Returns a new Uint8Array created by concatenating the passed ArrayLikes
  */
-function concat(arrays, length) {
+function concat$1(arrays, length) {
     if (length == null) {
         length = arrays.reduce((acc, curr) => acc + curr.length, 0);
     }
-    const output = allocUnsafe(length);
+    const output = allocUnsafe$1(length);
     let offset = 0;
     for (const arr of arrays) {
         output.set(arr, offset);
         offset += arr.length;
     }
-    return asUint8Array(output);
+    return asUint8Array$1(output);
 }
 
 /* eslint-disable @typescript-eslint/no-unsafe-return */
@@ -5207,10 +5325,10 @@ const toBytes = function (ip) {
             let v4Buffer;
             if (isv4) {
                 v4Buffer = toBytes(sections[i]);
-                sections[i] = toString$1(v4Buffer.slice(0, 2), 'base16');
+                sections[i] = toString$2(v4Buffer.slice(0, 2), 'base16');
             }
             if (v4Buffer != null && ++i < 8) {
-                sections.splice(i, 0, toString$1(v4Buffer.slice(2, 4), 'base16'));
+                sections.splice(i, 0, toString$2(v4Buffer.slice(2, 4), 'base16'));
             }
         }
         if (sections[0] === '') {
@@ -5241,7 +5359,7 @@ const toBytes = function (ip) {
     throw new Error('invalid ip address');
 };
 // Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L63
-const toString = function (buf, offset = 0, length) {
+const toString$1 = function (buf, offset = 0, length) {
     offset = ~~offset;
     length = length ?? (buf.length - offset);
     const view = new DataView(buf.buffer);
@@ -5397,7 +5515,7 @@ function convertToString(proto, buf) {
         case 466: // certhash
             return bytes2mb(buf);
         default:
-            return toString$1(buf, 'base16'); // no clue. convert to hex
+            return toString$2(buf, 'base16'); // no clue. convert to hex
     }
 }
 function convertToBytes(proto, str) {
@@ -5431,7 +5549,7 @@ function convertToBytes(proto, str) {
         case 466: // certhash
             return mb2bytes(str);
         default:
-            return fromString(str, 'base16'); // no clue. convert from hex
+            return fromString$1(str, 'base16'); // no clue. convert from hex
     }
 }
 const decoders = Object.values(bases).map((c) => c.decoder);
@@ -5447,7 +5565,7 @@ function ip2bytes(ipString) {
     return toBytes(ipString);
 }
 function bytes2ip(ipBuff) {
-    const ipString = toString(ipBuff, 0, ipBuff.length);
+    const ipString = toString$1(ipBuff, 0, ipBuff.length);
     if (ipString == null) {
         throw new Error('ipBuff is required');
     }
@@ -5467,9 +5585,9 @@ function bytes2port(buf) {
     return view.getUint16(buf.byteOffset);
 }
 function str2bytes(str) {
-    const buf = fromString(str);
+    const buf = fromString$1(str);
     const size = Uint8Array.from(encode$1(buf.length));
-    return concat([size, buf], size.length + buf.length);
+    return concat$1([size, buf], size.length + buf.length);
 }
 function bytes2str(buf) {
     const size = decode$1(buf);
@@ -5477,7 +5595,7 @@ function bytes2str(buf) {
     if (buf.length !== size) {
         throw new Error('inconsistent lengths');
     }
-    return toString$1(buf);
+    return toString$2(buf);
 }
 function mh2bytes(hash) {
     let mh;
@@ -5489,12 +5607,12 @@ function mh2bytes(hash) {
     }
     // the address is a varint prefixed multihash string representation
     const size = Uint8Array.from(encode$1(mh.length));
-    return concat([size, mh], size.length + mh.length);
+    return concat$1([size, mh], size.length + mh.length);
 }
 function mb2bytes(mbstr) {
     const mb = anybaseDecoder.decode(mbstr);
     const size = Uint8Array.from(encode$1(mb.length));
-    return concat([size, mb], size.length + mb.length);
+    return concat$1([size, mb], size.length + mb.length);
 }
 function bytes2mb(buf) {
     const size = decode$1(buf);
@@ -5502,7 +5620,7 @@ function bytes2mb(buf) {
     if (hash.length !== size) {
         throw new Error('inconsistent lengths');
     }
-    return 'u' + toString$1(hash, 'base64url');
+    return 'u' + toString$2(hash, 'base64url');
 }
 /**
  * Converts bytes to bas58btc string
@@ -5513,7 +5631,7 @@ function bytes2mh(buf) {
     if (address.length !== size) {
         throw new Error('inconsistent lengths');
     }
-    return toString$1(address, 'base58btc');
+    return toString$2(address, 'base58btc');
 }
 function onion2bytes(str) {
     const addr = str.split(':');
@@ -5531,7 +5649,7 @@ function onion2bytes(str) {
         throw new Error('Port number is not in range(1, 65536)');
     }
     const portBuf = port2bytes(port);
-    return concat([buf, portBuf], buf.length + portBuf.length);
+    return concat$1([buf, portBuf], buf.length + portBuf.length);
 }
 function onion32bytes(str) {
     const addr = str.split(':');
@@ -5549,12 +5667,12 @@ function onion32bytes(str) {
         throw new Error('Port number is not in range(1, 65536)');
     }
     const portBuf = port2bytes(port);
-    return concat([buf, portBuf], buf.length + portBuf.length);
+    return concat$1([buf, portBuf], buf.length + portBuf.length);
 }
 function bytes2onion(buf) {
     const addrBytes = buf.slice(0, buf.length - 2);
     const portBytes = buf.slice(buf.length - 2);
-    const addr = toString$1(addrBytes, 'base32');
+    const addr = toString$2(addrBytes, 'base32');
     const port = bytes2port(portBytes);
     return `${addr}:${port}`;
 }
@@ -5629,7 +5747,7 @@ function bytesToMultiaddrParts(bytes) {
         const addr = bytes.slice(i + n, i + n + size);
         i += (size + n);
         if (i > bytes.length) { // did not end _exactly_ at buffer.length
-            throw ParseError('Invalid address Uint8Array: ' + toString$1(bytes, 'base16'));
+            throw ParseError('Invalid address Uint8Array: ' + toString$2(bytes, 'base16'));
         }
         // ok, tuple seems good.
         tuples.push([code, addr]);
@@ -5670,11 +5788,11 @@ function stringTuplesToString(tuples) {
  * [[int code, Uint8Array ]... ] -> Uint8Array
  */
 function tuplesToBytes(tuples) {
-    return concat(tuples.map((tup) => {
+    return concat$1(tuples.map((tup) => {
         const proto = getProtocol(tup[0]);
         let buf = Uint8Array.from(encode$1(proto.code));
         if (tup.length > 1 && tup[1] != null) {
-            buf = concat([buf, tup[1]]); // add address buffer
+            buf = concat$1([buf, tup[1]]); // add address buffer
         }
         return buf;
     }));
@@ -5715,38 +5833,17 @@ function ParseError(str) {
  * ```
  */
 const inspect$1 = 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;
@@ -5846,8 +5943,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();
@@ -5856,13 +5953,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;
@@ -5887,10 +5984,10 @@ class DefaultMultiaddr {
                 // peer id is base58btc encoded string but not multibase encoded so add the `z`
                 // prefix so we can validate that it is correctly encoded
                 if (peerIdStr[0] === 'Q' || peerIdStr[0] === '1') {
-                    return toString$1(base58btc.decode(`z${peerIdStr}`), 'base58btc');
+                    return toString$2(base58btc.decode(`z${peerIdStr}`), 'base58btc');
                 }
                 // try to parse peer id as CID
-                return toString$1(CID.parse(peerIdStr).multihash.bytes, 'base58btc');
+                return toString$2(CID.parse(peerIdStr).multihash.bytes, 'base58btc');
             }
             return null;
         }
@@ -5902,7 +5999,7 @@ class DefaultMultiaddr {
         return this.#path;
     }
     equals(addr) {
-        return equals(this.bytes, addr.bytes);
+        return equals$1(this.bytes, addr.bytes);
     }
     async resolve(options) {
         const resolvableProto = this.protos().find((p) => p.resolvable);
@@ -5912,10 +6009,10 @@ class DefaultMultiaddr {
         }
         const resolver = resolvers.get(resolvableProto.name);
         if (resolver == null) {
-            throw new CodeError(`no available resolver for ${resolvableProto.name}`, 'ERR_NO_AVAILABLE_RESOLVER');
+            throw new CodeError$1(`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();
@@ -5957,6 +6054,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}
  *
@@ -5971,7 +6155,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 multiaddrFromFields(ipFamily, protocol, ipBytes, protocolBytes) {
@@ -20367,6 +20551,242 @@ function createPbkdf2Params(salt, countBytes, dkLen, prfAlgorithm) {
   return params;
 }
 
+/**
+ * On the producing side:
+ * * Build messages with the signature, key (from may be enough for certain inlineable public key types), from and seqno fields.
+ *
+ * On the consuming side:
+ * * Enforce the fields to be present, reject otherwise.
+ * * Propagate only if the fields are valid and signature can be verified, reject otherwise.
+ */
+var TopicValidatorResult;
+(function (TopicValidatorResult) {
+    /**
+     * The message is considered valid, and it should be delivered and forwarded to the network
+     */
+    TopicValidatorResult["Accept"] = "accept";
+    /**
+     * The message is neither delivered nor forwarded to the network
+     */
+    TopicValidatorResult["Ignore"] = "ignore";
+    /**
+     * The message is considered invalid, and it should be rejected
+     */
+    TopicValidatorResult["Reject"] = "reject";
+})(TopicValidatorResult || (TopicValidatorResult = {}));
+
+/**
+ * Enum Transport Manager Fault Tolerance values
+ */
+var FaultTolerance;
+(function (FaultTolerance) {
+    /**
+     * should be used for failing in any listen circumstance
+     */
+    FaultTolerance[FaultTolerance["FATAL_ALL"] = 0] = "FATAL_ALL";
+    /**
+     * should be used for not failing when not listening
+     */
+    FaultTolerance[FaultTolerance["NO_FATAL"] = 1] = "NO_FATAL";
+})(FaultTolerance || (FaultTolerance = {}));
+
+/**
+ * When this error is thrown it means an operation was aborted,
+ * usually in response to the `abort` event being emitted by an
+ * AbortSignal.
+ */
+class CodeError extends Error {
+    code;
+    props;
+    constructor(message, code, props) {
+        super(message);
+        this.code = code;
+        this.name = props?.name ?? 'CodeError';
+        this.props = props ?? {}; // eslint-disable-line @typescript-eslint/consistent-type-assertions
+    }
+}
+
+/**
+ * To guarantee Uint8Array semantics, convert nodejs Buffers
+ * into vanilla Uint8Arrays
+ */
+function asUint8Array(buf) {
+    if (globalThis.Buffer != null) {
+        return new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    }
+    return buf;
+}
+
+/**
+ * Where possible returns a Uint8Array of the requested size that references
+ * uninitialized memory. Only use if you are certain you will immediately
+ * overwrite every value in the returned `Uint8Array`.
+ */
+function allocUnsafe(size = 0) {
+    if (globalThis.Buffer?.allocUnsafe != null) {
+        return asUint8Array(globalThis.Buffer.allocUnsafe(size));
+    }
+    return new Uint8Array(size);
+}
+
+function createCodec$1(name, prefix, encode, decode) {
+    return {
+        name,
+        prefix,
+        encoder: {
+            name,
+            prefix,
+            encode
+        },
+        decoder: {
+            decode
+        }
+    };
+}
+const string = createCodec$1('utf8', 'u', (buf) => {
+    const decoder = new TextDecoder('utf8');
+    return 'u' + decoder.decode(buf);
+}, (str) => {
+    const encoder = new TextEncoder();
+    return encoder.encode(str.substring(1));
+});
+const ascii = createCodec$1('ascii', 'a', (buf) => {
+    let string = 'a';
+    for (let i = 0; i < buf.length; i++) {
+        string += String.fromCharCode(buf[i]);
+    }
+    return string;
+}, (str) => {
+    str = str.substring(1);
+    const buf = allocUnsafe(str.length);
+    for (let i = 0; i < str.length; i++) {
+        buf[i] = str.charCodeAt(i);
+    }
+    return buf;
+});
+const BASES = {
+    utf8: string,
+    'utf-8': string,
+    hex: bases.base16,
+    latin1: ascii,
+    ascii,
+    binary: ascii,
+    ...bases
+};
+
+/**
+ * Create a `Uint8Array` from the passed string
+ *
+ * Supports `utf8`, `utf-8`, `hex`, and any encoding supported by the multiformats module.
+ *
+ * Also `ascii` which is similar to node's 'binary' encoding.
+ */
+function fromString(string, encoding = 'utf8') {
+    const base = BASES[encoding];
+    if (base == null) {
+        throw new Error(`Unsupported encoding "${encoding}"`);
+    }
+    if ((encoding === 'utf8' || encoding === 'utf-8') && globalThis.Buffer != null && globalThis.Buffer.from != null) {
+        return asUint8Array(globalThis.Buffer.from(string, 'utf-8'));
+    }
+    // add multibase prefix
+    return base.decoder.decode(`${base.prefix}${string}`); // eslint-disable-line @typescript-eslint/restrict-template-expressions
+}
+
+/**
+ * Returns true if the two passed Uint8Arrays have the same content
+ */
+function equals(a, b) {
+    if (a === b) {
+        return true;
+    }
+    if (a.byteLength !== b.byteLength) {
+        return false;
+    }
+    for (let i = 0; i < a.byteLength; i++) {
+        if (a[i] !== b[i]) {
+            return false;
+        }
+    }
+    return true;
+}
+
+/**
+ * Returns a new Uint8Array created by concatenating the passed Uint8Arrays
+ */
+function concat(arrays, length) {
+    if (globalThis.Buffer != null) {
+        return asUint8Array(globalThis.Buffer.concat(arrays, length));
+    }
+    if (length == null) {
+        length = arrays.reduce((acc, curr) => acc + curr.length, 0);
+    }
+    const output = allocUnsafe(length);
+    let offset = 0;
+    for (const arr of arrays) {
+        output.set(arr, offset);
+        offset += arr.length;
+    }
+    return asUint8Array(output);
+}
+
+/**
+ * Turns a `Uint8Array` into a string.
+ *
+ * Supports `utf8`, `utf-8` and any encoding supported by the multibase module.
+ *
+ * Also `ascii` which is similar to node's 'binary' encoding.
+ */
+function toString(array, encoding = 'utf8') {
+    const base = BASES[encoding];
+    if (base == null) {
+        throw new Error(`Unsupported encoding "${encoding}"`);
+    }
+    if ((encoding === 'utf8' || encoding === 'utf-8') && globalThis.Buffer != null && globalThis.Buffer.from != null) {
+        return globalThis.Buffer.from(array.buffer, array.byteOffset, array.byteLength).toString('utf8');
+    }
+    // strip multibase prefix
+    return base.encoder.encode(array).substring(1);
+}
+
+function bigIntegerToUintBase64url(num, len) {
+    // Call `.abs()` to convert to unsigned
+    let buf = Uint8Array.from(num.abs().toByteArray()); // toByteArray converts to big endian
+    // toByteArray() gives us back a signed array, which will include a leading 0
+    // byte if the most significant bit of the number is 1:
+    // https://docs.microsoft.com/en-us/windows/win32/seccertenroll/about-integer
+    // Our number will always be positive so we should remove the leading padding.
+    buf = buf[0] === 0 ? buf.subarray(1) : buf;
+    if (len != null) {
+        if (buf.length > len)
+            throw new Error('byte array longer than desired length');
+        buf = concat([new Uint8Array(len - buf.length), buf]);
+    }
+    return toString(buf, 'base64url');
+}
+// Convert a base64url encoded string to a BigInteger
+function base64urlToBigInteger(str) {
+    const buf = base64urlToBuffer(str);
+    return new forge$n.jsbn.BigInteger(toString(buf, 'base16'), 16);
+}
+function base64urlToBuffer(str, len) {
+    let buf = fromString(str, 'base64urlpad');
+    if (len != null) {
+        if (buf.length > len)
+            throw new Error('byte array longer than desired length');
+        buf = concat([new Uint8Array(len - buf.length), buf]);
+    }
+    return buf;
+}
+function isPromise(thing) {
+    if (thing == null) {
+        return false;
+    }
+    return typeof thing.then === 'function' &&
+        typeof thing.catch === 'function' &&
+        typeof thing.finally === 'function';
+}
+
 const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
 const _32n = /* @__PURE__ */ BigInt(32);
 // We are not using BigUint64Array, because they are extremely slow as per 2022
@@ -21894,6 +22314,20 @@ const ed25519Defaults = {
     uvRatio,
 };
 const ed25519 = /* @__PURE__ */ twistedEdwards(ed25519Defaults);
+function ed25519_domain(data, ctx, phflag) {
+    if (ctx.length > 255)
+        throw new Error('Context is too big');
+    return concatBytes$1(utf8ToBytes$1('SigEd25519 no Ed25519 collisions'), new Uint8Array([phflag ? 1 : 0, ctx.length]), ctx, data);
+}
+/* @__PURE__ */ twistedEdwards({
+    ...ed25519Defaults,
+    domain: ed25519_domain,
+});
+/* @__PURE__ */ twistedEdwards({
+    ...ed25519Defaults,
+    domain: ed25519_domain,
+    prehash: sha512$1,
+});
 // Hash To Curve Elligator2 Map (NOTE: different from ristretto255 elligator)
 // NOTE: very important part is usage of FpSqrtEven for ELL2_C1_EDWARDS, since
 // SageMath returns different root first and everything falls apart
@@ -21916,7 +22350,7 @@ BigInt('0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff');
 const PUBLIC_KEY_BYTE_LENGTH = 32;
 const PRIVATE_KEY_BYTE_LENGTH = 64; // private key is actually 32 bytes but for historical reasons we concat private and public keys
 const KEYS_BYTE_LENGTH = 32;
-async function generateKey$2() {
+function generateKey$2() {
     // the actual private key (32 bytes)
     const privateKeyRaw = ed25519.utils.randomPrivateKey();
     const publicKey = ed25519.getPublicKey(privateKeyRaw);
@@ -21930,7 +22364,7 @@ async function generateKey$2() {
 /**
  * Generate keypair from a 32 byte uint8array
  */
-async function generateKeyFromSeed(seed) {
+function generateKeyFromSeed(seed) {
     if (seed.length !== KEYS_BYTE_LENGTH) {
         throw new TypeError('"seed" must be 32 bytes in length.');
     }
@@ -21946,12 +22380,12 @@ async function generateKeyFromSeed(seed) {
         publicKey
     };
 }
-async function hashAndSign$2(privateKey, msg) {
+function hashAndSign$2(privateKey, msg) {
     const privateKeyRaw = privateKey.subarray(0, KEYS_BYTE_LENGTH);
-    return ed25519.sign(msg, privateKeyRaw);
+    return ed25519.sign(msg instanceof Uint8Array ? msg : msg.subarray(), privateKeyRaw);
 }
-async function hashAndVerify$2(publicKey, sig, msg) {
-    return ed25519.verify(sig, msg, publicKey);
+function hashAndVerify$2(publicKey, sig, msg) {
+    return ed25519.verify(sig, msg instanceof Uint8Array ? msg : msg.subarray(), publicKey);
 }
 function concatKeys(privateKeyRaw, publicKey) {
     const privateKey = new Uint8Array(PRIVATE_KEY_BYTE_LENGTH);
@@ -21973,7 +22407,7 @@ var webcrypto = {
                 'The most likely cause of this error is that this page is being accessed ' +
                 'from an insecure context (i.e. not HTTPS). For more information and ' +
                 'possible resolutions see ' +
-                'https://github.com/libp2p/js-libp2p-crypto/blob/master/README.md#web-crypto-api'), { code: 'ERR_MISSING_WEB_CRYPTO' });
+                'https://github.com/libp2p/js-libp2p/blob/main/packages/crypto/README.md#web-crypto-api'), { code: 'ERR_MISSING_WEB_CRYPTO' });
         }
         return nativeCrypto;
     }
@@ -24831,7 +25265,7 @@ class Ed25519PublicKey {
     constructor(key) {
         this._key = ensureKey(key, PUBLIC_KEY_BYTE_LENGTH);
     }
-    async verify(data, sig) {
+    verify(data, sig) {
         return hashAndVerify$2(this._key, sig, data);
     }
     marshal() {
@@ -24846,9 +25280,12 @@ class Ed25519PublicKey {
     equals(key) {
         return equals(this.bytes, key.bytes);
     }
-    async hash() {
-        const { bytes } = await sha256$2.digest(this.bytes);
-        return bytes;
+    hash() {
+        const p = sha256$2.digest(this.bytes);
+        if (isPromise(p)) {
+            return p.then(({ bytes }) => bytes);
+        }
+        return p.bytes;
     }
 }
 class Ed25519PrivateKey {
@@ -24860,7 +25297,7 @@ class Ed25519PrivateKey {
         this._key = ensureKey(key, PRIVATE_KEY_BYTE_LENGTH);
         this._publicKey = ensureKey(publicKey, PUBLIC_KEY_BYTE_LENGTH);
     }
-    async sign(message) {
+    sign(message) {
         return hashAndSign$2(this._key, message);
     }
     get public() {
@@ -24879,7 +25316,14 @@ class Ed25519PrivateKey {
         return equals(this.bytes, key.bytes);
     }
     async hash() {
-        const { bytes } = await sha256$2.digest(this.bytes);
+        const p = sha256$2.digest(this.bytes);
+        let bytes;
+        if (isPromise(p)) {
+            ({ bytes } = await p);
+        }
+        else {
+            bytes = p.bytes;
+        }
         return bytes;
     }
     /**
@@ -24925,11 +25369,11 @@ function unmarshalEd25519PublicKey(bytes) {
     return new Ed25519PublicKey(bytes);
 }
 async function generateKeyPair$2() {
-    const { privateKey, publicKey } = await generateKey$2();
+    const { privateKey, publicKey } = generateKey$2();
     return new Ed25519PrivateKey(privateKey, publicKey);
 }
 async function generateKeyPairFromSeed(seed) {
-    const { privateKey, publicKey } = await generateKeyFromSeed(seed);
+    const { privateKey, publicKey } = generateKeyFromSeed(seed);
     return new Ed25519PrivateKey(privateKey, publicKey);
 }
 function ensureKey(key, length) {
@@ -24950,36 +25394,6 @@ var Ed25519 = /*#__PURE__*/Object.freeze({
     unmarshalEd25519PublicKey: unmarshalEd25519PublicKey
 });
 
-function bigIntegerToUintBase64url(num, len) {
-    // Call `.abs()` to convert to unsigned
-    let buf = Uint8Array.from(num.abs().toByteArray()); // toByteArray converts to big endian
-    // toByteArray() gives us back a signed array, which will include a leading 0
-    // byte if the most significant bit of the number is 1:
-    // https://docs.microsoft.com/en-us/windows/win32/seccertenroll/about-integer
-    // Our number will always be positive so we should remove the leading padding.
-    buf = buf[0] === 0 ? buf.subarray(1) : buf;
-    if (len != null) {
-        if (buf.length > len)
-            throw new Error('byte array longer than desired length');
-        buf = concat([new Uint8Array(len - buf.length), buf]);
-    }
-    return toString$1(buf, 'base64url');
-}
-// Convert a base64url encoded string to a BigInteger
-function base64urlToBigInteger(str) {
-    const buf = base64urlToBuffer(str);
-    return new forge$n.jsbn.BigInteger(toString$1(buf, 'base16'), 16);
-}
-function base64urlToBuffer(str, len) {
-    let buf = fromString(str, 'base64urlpad');
-    if (len != null) {
-        if (buf.length > len)
-            throw new Error('byte array longer than desired length');
-        buf = concat([new Uint8Array(len - buf.length), buf]);
-    }
-    return buf;
-}
-
 const bits = {
     'P-256': 256,
     'P-384': 384,
@@ -25573,7 +25987,7 @@ function jwk2pub(key) {
 
 // Convert a PKCS#1 in ASN1 DER format to a JWK key
 function pkcs1ToJwk(bytes) {
-    const asn1 = forge$n.asn1.fromDer(toString$1(bytes, 'ascii'));
+    const asn1 = forge$n.asn1.fromDer(toString(bytes, 'ascii'));
     const privateKey = forge$n.pki.privateKeyFromAsn1(asn1);
     // https://tools.ietf.org/html/rfc7518#section-6.3.1
     return {
@@ -25608,7 +26022,7 @@ function jwkToPkcs1(jwk) {
 }
 // Convert a PKCIX in ASN1 DER format to a JWK key
 function pkixToJwk(bytes) {
-    const asn1 = forge$n.asn1.fromDer(toString$1(bytes, 'ascii'));
+    const asn1 = forge$n.asn1.fromDer(toString(bytes, 'ascii'));
     const publicKey = forge$n.pki.publicKeyFromAsn1(asn1);
     return {
         kty: 'RSA',
@@ -25665,7 +26079,7 @@ async function hashAndSign$1(key, msg) {
         name: 'RSASSA-PKCS1-v1_5',
         hash: { name: 'SHA-256' }
     }, false, ['sign']);
-    const sig = await webcrypto.get().subtle.sign({ name: 'RSASSA-PKCS1-v1_5' }, privateKey, Uint8Array.from(msg));
+    const sig = await webcrypto.get().subtle.sign({ name: 'RSASSA-PKCS1-v1_5' }, privateKey, msg instanceof Uint8Array ? msg : msg.subarray());
     return new Uint8Array(sig, 0, sig.byteLength);
 }
 async function hashAndVerify$1(key, sig, msg) {
@@ -25673,7 +26087,7 @@ async function hashAndVerify$1(key, sig, msg) {
         name: 'RSASSA-PKCS1-v1_5',
         hash: { name: 'SHA-256' }
     }, false, ['verify']);
-    return webcrypto.get().subtle.verify({ name: 'RSASSA-PKCS1-v1_5' }, publicKey, sig, msg);
+    return webcrypto.get().subtle.verify({ name: 'RSASSA-PKCS1-v1_5' }, publicKey, sig, msg instanceof Uint8Array ? msg : msg.subarray());
 }
 async function exportKey(pair) {
     if (pair.privateKey == null || pair.publicKey == null) {
@@ -25707,7 +26121,7 @@ Explanation:
 */
 function convertKey(key, pub, msg, handle) {
     const fkey = pub ? jwk2pub(key) : jwk2priv(key);
-    const fmsg = toString$1(Uint8Array.from(msg), 'ascii');
+    const fmsg = toString(msg instanceof Uint8Array ? msg : msg.subarray(), 'ascii');
     const fomsg = handle(fmsg, fkey);
     return fromString(fomsg, 'ascii');
 }
@@ -25734,7 +26148,7 @@ class RsaPublicKey {
     constructor(key) {
         this._key = key;
     }
-    async verify(data, sig) {
+    verify(data, sig) {
         return hashAndVerify$1(this._key, sig, data);
     }
     marshal() {
@@ -25752,9 +26166,12 @@ class RsaPublicKey {
     equals(key) {
         return equals(this.bytes, key.bytes);
     }
-    async hash() {
-        const { bytes } = await sha256$2.digest(this.bytes);
-        return bytes;
+    hash() {
+        const p = sha256$2.digest(this.bytes);
+        if (isPromise(p)) {
+            return p.then(({ bytes }) => bytes);
+        }
+        return p.bytes;
     }
 }
 class RsaPrivateKey {
@@ -25767,7 +26184,7 @@ class RsaPrivateKey {
     genSecret() {
         return randomBytes(16);
     }
-    async sign(message) {
+    sign(message) {
         return hashAndSign$1(this._key, message);
     }
     get public() {
@@ -25791,9 +26208,12 @@ class RsaPrivateKey {
     equals(key) {
         return equals(this.bytes, key.bytes);
     }
-    async hash() {
-        const { bytes } = await sha256$2.digest(this.bytes);
-        return bytes;
+    hash() {
+        const p = sha256$2.digest(this.bytes);
+        if (isPromise(p)) {
+            return p.then(({ bytes }) => bytes);
+        }
+        return p.bytes;
     }
     /**
      * Gets the ID of the key.
@@ -25804,7 +26224,7 @@ class RsaPrivateKey {
      */
     async id() {
         const hash = await this.public.hash();
-        return toString$1(hash, 'base58btc');
+        return toString(hash, 'base58btc');
     }
     /**
      * Exports the key into a password protected PEM format
@@ -26978,11 +27398,16 @@ function generateKey() {
 /**
  * Hash and sign message with private key
  */
-async function hashAndSign(key, msg) {
-    const { digest } = await sha256$2.digest(msg);
+function hashAndSign(key, msg) {
+    const p = sha256$2.digest(msg instanceof Uint8Array ? msg : msg.subarray());
+    if (isPromise(p)) {
+        return p.then(({ digest }) => secp256k1.sign(digest, key).toDERRawBytes())
+            .catch(err => {
+            throw new CodeError(String(err), 'ERR_INVALID_INPUT');
+        });
+    }
     try {
-        const signature = secp256k1.sign(digest, key);
-        return signature.toDERRawBytes();
+        return secp256k1.sign(p.digest, key).toDERRawBytes();
     }
     catch (err) {
         throw new CodeError(String(err), 'ERR_INVALID_INPUT');
@@ -26991,10 +27416,16 @@ async function hashAndSign(key, msg) {
 /**
  * Hash message and verify signature with public key
  */
-async function hashAndVerify(key, sig, msg) {
+function hashAndVerify(key, sig, msg) {
+    const p = sha256$2.digest(msg instanceof Uint8Array ? msg : msg.subarray());
+    if (isPromise(p)) {
+        return p.then(({ digest }) => secp256k1.verify(sig, digest, key))
+            .catch(err => {
+            throw new CodeError(String(err), 'ERR_INVALID_INPUT');
+        });
+    }
     try {
-        const { digest } = await sha256$2.digest(msg);
-        return secp256k1.verify(sig, digest, key);
+        return secp256k1.verify(sig, p.digest, key);
     }
     catch (err) {
         throw new CodeError(String(err), 'ERR_INVALID_INPUT');
@@ -27035,7 +27466,7 @@ class Secp256k1PublicKey {
         validatePublicKey(key);
         this._key = key;
     }
-    async verify(data, sig) {
+    verify(data, sig) {
         return hashAndVerify(this._key, sig, data);
     }
     marshal() {
@@ -27051,7 +27482,14 @@ class Secp256k1PublicKey {
         return equals(this.bytes, key.bytes);
     }
     async hash() {
-        const { bytes } = await sha256$2.digest(this.bytes);
+        const p = sha256$2.digest(this.bytes);
+        let bytes;
+        if (isPromise(p)) {
+            ({ bytes } = await p);
+        }
+        else {
+            bytes = p.bytes;
+        }
         return bytes;
     }
 }
@@ -27064,7 +27502,7 @@ class Secp256k1PrivateKey {
         validatePrivateKey(this._key);
         validatePublicKey(this._publicKey);
     }
-    async sign(message) {
+    sign(message) {
         return hashAndSign(this._key, message);
     }
     get public() {
@@ -27082,9 +27520,12 @@ class Secp256k1PrivateKey {
     equals(key) {
         return equals(this.bytes, key.bytes);
     }
-    async hash() {
-        const { bytes } = await sha256$2.digest(this.bytes);
-        return bytes;
+    hash() {
+        const p = sha256$2.digest(this.bytes);
+        if (isPromise(p)) {
+            return p.then(({ bytes }) => bytes);
+        }
+        return p.bytes;
     }
     /**
      * Gets the ID of the key.
@@ -27095,7 +27536,7 @@ class Secp256k1PrivateKey {
      */
     async id() {
         const hash = await this.public.hash();
-        return toString$1(hash, 'base58btc');
+        return toString(hash, 'base58btc');
     }
     /**
      * Exports the key into a password protected `format`
@@ -27256,13 +27697,13 @@ class PeerIdImpl {
      */
     equals(id) {
         if (id instanceof Uint8Array) {
-            return equals(this.multihash.bytes, id);
+            return equals$1(this.multihash.bytes, id);
         }
         else if (typeof id === 'string') {
             return peerIdFromString(id).equals(this);
         }
         else if (id?.multihash?.bytes != null) {
-            return equals(this.multihash.bytes, id.multihash.bytes);
+            return equals$1(this.multihash.bytes, id.multihash.bytes);
         }
         else {
             throw new Error('not valid Id');
@@ -27436,15 +27877,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);
             }
         }
     }
@@ -27454,20 +27895,20 @@ 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 { cluster, indexList } = shardInfo;
-    const totalLength = indexList.length >= 64 ? 130 : 3 + 2 * indexList.length;
+    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, cluster);
-    if (indexList.length >= 64) {
+    view.setUint16(0, clusterId);
+    if (shards.length >= 64) {
         // rsv format (Bit Vector)
-        for (const index of indexList) {
+        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));
@@ -27475,9 +27916,9 @@ const encodeRelayShard = (shardInfo) => {
     }
     else {
         // rs format (Index List)
-        view.setUint8(2, indexList.length);
-        for (let i = 0, offset = 3; i < indexList.length; i++, offset += 2) {
-            view.setUint16(offset, indexList[i]);
+        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);
@@ -28469,7 +28910,7 @@ class EnrDecoder {
         if (!encoded.startsWith(ENR.RECORD_PREFIX)) {
             throw new Error(`"string encoded ENR must start with '${ENR.RECORD_PREFIX}'`);
         }
-        return EnrDecoder.fromRLP(fromString(encoded.slice(4), "base64url"));
+        return EnrDecoder.fromRLP(fromString$1(encoded.slice(4), "base64url"));
     }
     static fromRLP(encoded) {
         const decoded = decode(encoded).map(hexToBytes$2);