@waku/core 0.0.21 → 0.0.23

package/bundle/index.js

@@ -1,251 +1,28 @@
+import { a as allocUnsafe, b as asUint8Array, t as toString$2, f as fromString$1, u as utf8ToBytes$1, T as Tags, E as EPeersByDiscoveryEvents, P as Protocols, c as alloc, B as BaseProtocol, S as SendError, d as concat$1 } from './base_protocol-84d9b670.js';
+export { e as StreamManager } from './base_protocol-84d9b670.js';
 import { g as getDefaultExportFromCjs, d as debug } from './browser-bde977a3.js';
-import { c as createEncoder, v as version_0, M as MessagePush, F as FilterSubscribeRequest, a as FilterSubscribeResponse$1, P as PushRpc$1, b as PushResponse, H as HistoryRpc$1, d as PagingInfo, e as HistoryResponse } from './version_0-86411fdf.js';
-export { f as createDecoder } from './version_0-86411fdf.js';
-import { BaseProtocol } from './lib/base_protocol.js';
+import { c as createEncoder, v as version_0, M as MessagePush, F as FilterSubscribeRequest, a as FilterSubscribeResponse$1, P as PushRpc$1, b as PushResponse, H as HistoryRpc$1, d as PagingInfo, e as HistoryResponse } from './version_0-74b4b9db.js';
+export { f as createDecoder } from './version_0-74b4b9db.js';
 
 const symbol$2 = Symbol.for('@libp2p/peer-id');
 function isPeerId(other) {
     return other != null && Boolean(other[symbol$2]);
 }
 
-/* eslint-disable @typescript-eslint/no-unsafe-return */
-class Parser {
-    index = 0;
-    input = "";
-    new(input) {
-        this.index = 0;
-        this.input = input;
-        return this;
-    }
-    /** Run a parser, and restore the pre-parse state if it fails. */
-    readAtomically(fn) {
-        const index = this.index;
-        const result = fn();
-        if (result === undefined) {
-            this.index = index;
-        }
-        return result;
-    }
-    /** Run a parser, but fail if the entire input wasn't consumed. Doesn't run atomically. */
-    parseWith(fn) {
-        const result = fn();
-        if (this.index !== this.input.length) {
-            return undefined;
-        }
-        return result;
-    }
-    /** Peek the next character from the input */
-    peekChar() {
-        if (this.index >= this.input.length) {
-            return undefined;
-        }
-        return this.input[this.index];
-    }
-    /** Read the next character from the input */
-    readChar() {
-        if (this.index >= this.input.length) {
-            return undefined;
-        }
-        return this.input[this.index++];
-    }
-    /** Read the next character from the input if it matches the target. */
-    readGivenChar(target) {
-        return this.readAtomically(() => {
-            const char = this.readChar();
-            if (char !== target) {
-                return undefined;
-            }
-            return char;
-        });
-    }
-    /**
-     * Helper for reading separators in an indexed loop. Reads the separator
-     * character iff index > 0, then runs the parser. When used in a loop,
-     * the separator character will only be read on index > 0 (see
-     * readIPv4Addr for an example)
-     */
-    readSeparator(sep, index, inner) {
-        return this.readAtomically(() => {
-            if (index > 0) {
-                if (this.readGivenChar(sep) === undefined) {
-                    return undefined;
-                }
-            }
-            return inner();
-        });
-    }
-    /**
-     * Read a number off the front of the input in the given radix, stopping
-     * at the first non-digit character or eof. Fails if the number has more
-     * digits than max_digits or if there is no number.
-     */
-    readNumber(radix, maxDigits, allowZeroPrefix, maxBytes) {
-        return this.readAtomically(() => {
-            let result = 0;
-            let digitCount = 0;
-            const leadingChar = this.peekChar();
-            if (leadingChar === undefined) {
-                return undefined;
-            }
-            const hasLeadingZero = leadingChar === "0";
-            const maxValue = 2 ** (8 * maxBytes) - 1;
-            // eslint-disable-next-line no-constant-condition
-            while (true) {
-                const digit = this.readAtomically(() => {
-                    const char = this.readChar();
-                    if (char === undefined) {
-                        return undefined;
-                    }
-                    const num = Number.parseInt(char, radix);
-                    if (Number.isNaN(num)) {
-                        return undefined;
-                    }
-                    return num;
-                });
-                if (digit === undefined) {
-                    break;
-                }
-                result *= radix;
-                result += digit;
-                if (result > maxValue) {
-                    return undefined;
-                }
-                digitCount += 1;
-                if (maxDigits !== undefined) {
-                    if (digitCount > maxDigits) {
-                        return undefined;
-                    }
-                }
-            }
-            if (digitCount === 0) {
-                return undefined;
-            }
-            else if (!allowZeroPrefix && hasLeadingZero && digitCount > 1) {
-                return undefined;
-            }
-            else {
-                return result;
-            }
-        });
-    }
-    /** Read an IPv4 address. */
-    readIPv4Addr() {
-        return this.readAtomically(() => {
-            const out = new Uint8Array(4);
-            for (let i = 0; i < out.length; i++) {
-                const ix = this.readSeparator(".", i, () => this.readNumber(10, 3, false, 1));
-                if (ix === undefined) {
-                    return undefined;
-                }
-                out[i] = ix;
-            }
-            return out;
-        });
-    }
-    /** Read an IPv6 Address. */
-    readIPv6Addr() {
-        /**
-         * Read a chunk of an IPv6 address into `groups`. Returns the number
-         * of groups read, along with a bool indicating if an embedded
-         * trailing IPv4 address was read. Specifically, read a series of
-         * colon-separated IPv6 groups (0x0000 - 0xFFFF), with an optional
-         * trailing embedded IPv4 address.
-         */
-        const readGroups = (groups) => {
-            for (let i = 0; i < groups.length / 2; i++) {
-                const ix = i * 2;
-                // Try to read a trailing embedded IPv4 address. There must be at least 4 groups left.
-                if (i < groups.length - 3) {
-                    const ipv4 = this.readSeparator(":", i, () => this.readIPv4Addr());
-                    if (ipv4 !== undefined) {
-                        groups[ix] = ipv4[0];
-                        groups[ix + 1] = ipv4[1];
-                        groups[ix + 2] = ipv4[2];
-                        groups[ix + 3] = ipv4[3];
-                        return [ix + 4, true];
-                    }
-                }
-                const group = this.readSeparator(":", i, () => this.readNumber(16, 4, true, 2));
-                if (group === undefined) {
-                    return [ix, false];
-                }
-                groups[ix] = group >> 8;
-                groups[ix + 1] = group & 255;
-            }
-            return [groups.length, false];
-        };
-        return this.readAtomically(() => {
-            // Read the front part of the address; either the whole thing, or up to the first ::
-            const head = new Uint8Array(16);
-            const [headSize, headIp4] = readGroups(head);
-            if (headSize === 16) {
-                return head;
-            }
-            // IPv4 part is not allowed before `::`
-            if (headIp4) {
-                return undefined;
-            }
-            // Read `::` if previous code parsed less than 8 groups.
-            // `::` indicates one or more groups of 16 bits of zeros.
-            if (this.readGivenChar(":") === undefined) {
-                return undefined;
-            }
-            if (this.readGivenChar(":") === undefined) {
-                return undefined;
-            }
-            // Read the back part of the address. The :: must contain at least one
-            // set of zeroes, so our max length is 7.
-            const tail = new Uint8Array(14);
-            const limit = 16 - (headSize + 2);
-            const [tailSize] = readGroups(tail.subarray(0, limit));
-            // Concat the head and tail of the IP address
-            head.set(tail.subarray(0, tailSize), 16 - tailSize);
-            return head;
-        });
-    }
-    /** Read an IP Address, either IPv4 or IPv6. */
-    readIPAddr() {
-        return this.readIPv4Addr() ?? this.readIPv6Addr();
-    }
-}
-
-// See https://stackoverflow.com/questions/166132/maximum-length-of-the-textual-representation-of-an-ipv6-address
-const MAX_IPV6_LENGTH = 45;
-const MAX_IPV4_LENGTH = 15;
-const parser = new Parser();
-/** Parse `input` into IPv4 bytes. */
-function parseIPv4(input) {
-    if (input.length > MAX_IPV4_LENGTH) {
-        return undefined;
-    }
-    return parser.new(input).parseWith(() => parser.readIPv4Addr());
-}
-/** Parse `input` into IPv6 bytes. */
-function parseIPv6(input) {
-    if (input.length > MAX_IPV6_LENGTH) {
-        return undefined;
-    }
-    return parser.new(input).parseWith(() => parser.readIPv6Addr());
-}
-/** Parse `input` into IPv4 or IPv6 bytes. */
-function parseIP(input) {
-    if (input.length > MAX_IPV6_LENGTH) {
-        return undefined;
+/**
+ * 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
     }
-    return parser.new(input).parseWith(() => parser.readIPAddr());
-}
-
-/** Check if `input` is IPv4. */
-function isIPv4(input) {
-    return Boolean(parseIPv4(input));
-}
-/** Check if `input` is IPv6. */
-function isIPv6(input) {
-    return Boolean(parseIPv6(input));
-}
-/** Check if `input` is IPv4 or IPv6. */
-function isIP(input) {
-    return Boolean(parseIP(input));
 }
 
 // base-x encoding / decoding
@@ -410,13 +187,13 @@ const coerce = o => {
  * @param {string} str
  * @returns {Uint8Array}
  */
-const fromString$2 = str => (new TextEncoder()).encode(str);
+const fromString = str => (new TextEncoder()).encode(str);
 
 /**
  * @param {Uint8Array} b
  * @returns {string}
  */
-const toString$2 = b => (new TextDecoder()).decode(b);
+const toString$1 = b => (new TextDecoder()).decode(b);
 
 /**
  * Class represents both BaseEncoder and MultibaseEncoder meaning it
@@ -760,180 +537,11 @@ const rfc4648 = ({ name, prefix, bitsPerChar, alphabet }) => {
   })
 };
 
-// @ts-check
-
-const identity = from({
-  prefix: '\x00',
-  name: 'identity',
-  encode: (buf) => toString$2(buf),
-  decode: (str) => fromString$2(str)
-});
-
-var identityBase = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    identity: identity
-});
-
-// @ts-check
-
-const base2 = rfc4648({
-  prefix: '0',
-  name: 'base2',
-  alphabet: '01',
-  bitsPerChar: 1
-});
-
-var base2$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base2: base2
-});
-
-// @ts-check
-
-const base8 = rfc4648({
-  prefix: '7',
-  name: 'base8',
-  alphabet: '01234567',
-  bitsPerChar: 3
-});
-
-var base8$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base8: base8
-});
-
-const base10 = baseX({
-  prefix: '9',
-  name: 'base10',
-  alphabet: '0123456789'
-});
-
-var base10$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base10: base10
-});
-
-// @ts-check
-
-const base16 = rfc4648({
-  prefix: 'f',
-  name: 'base16',
-  alphabet: '0123456789abcdef',
-  bitsPerChar: 4
-});
-
-const base16upper = rfc4648({
-  prefix: 'F',
-  name: 'base16upper',
-  alphabet: '0123456789ABCDEF',
-  bitsPerChar: 4
-});
-
-var base16$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base16: base16,
-    base16upper: base16upper
-});
-
-const base32 = rfc4648({
-  prefix: 'b',
-  name: 'base32',
-  alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
-  bitsPerChar: 5
-});
-
-const base32upper = rfc4648({
-  prefix: 'B',
-  name: 'base32upper',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
-  bitsPerChar: 5
-});
-
-const base32pad = rfc4648({
-  prefix: 'c',
-  name: 'base32pad',
-  alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
-  bitsPerChar: 5
-});
-
-const base32padupper = rfc4648({
-  prefix: 'C',
-  name: 'base32padupper',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
-  bitsPerChar: 5
-});
-
-const base32hex = rfc4648({
-  prefix: 'v',
-  name: 'base32hex',
-  alphabet: '0123456789abcdefghijklmnopqrstuv',
-  bitsPerChar: 5
-});
-
-const base32hexupper = rfc4648({
-  prefix: 'V',
-  name: 'base32hexupper',
-  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
-  bitsPerChar: 5
-});
-
-const base32hexpad = rfc4648({
-  prefix: 't',
-  name: 'base32hexpad',
-  alphabet: '0123456789abcdefghijklmnopqrstuv=',
-  bitsPerChar: 5
-});
-
-const base32hexpadupper = rfc4648({
-  prefix: 'T',
-  name: 'base32hexpadupper',
-  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
-  bitsPerChar: 5
-});
-
-const base32z = rfc4648({
-  prefix: 'h',
-  name: 'base32z',
-  alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
-  bitsPerChar: 5
-});
-
-var base32$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base32: base32,
-    base32hex: base32hex,
-    base32hexpad: base32hexpad,
-    base32hexpadupper: base32hexpadupper,
-    base32hexupper: base32hexupper,
-    base32pad: base32pad,
-    base32padupper: base32padupper,
-    base32upper: base32upper,
-    base32z: base32z
-});
-
-const base36 = baseX({
-  prefix: 'k',
-  name: 'base36',
-  alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
-});
-
-const base36upper = baseX({
-  prefix: 'K',
-  name: 'base36upper',
-  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
-});
-
-var base36$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base36: base36,
-    base36upper: base36upper
-});
-
-const base58btc = baseX({
-  name: 'base58btc',
-  prefix: 'z',
-  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
-});
+const base58btc = baseX({
+  name: 'base58btc',
+  prefix: 'z',
+  alphabet: '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
+});
 
 const base58flickr = baseX({
   name: 'base58flickr',
@@ -947,95 +555,14 @@ var base58 = /*#__PURE__*/Object.freeze({
     base58flickr: base58flickr
 });
 
-// @ts-check
-
-const base64 = rfc4648({
-  prefix: 'm',
-  name: 'base64',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
-  bitsPerChar: 6
-});
-
-const base64pad = rfc4648({
-  prefix: 'M',
-  name: 'base64pad',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
-  bitsPerChar: 6
-});
-
-const base64url = rfc4648({
-  prefix: 'u',
-  name: 'base64url',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
-  bitsPerChar: 6
-});
-
-const base64urlpad = rfc4648({
-  prefix: 'U',
-  name: 'base64urlpad',
-  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
-  bitsPerChar: 6
-});
-
-var base64$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base64: base64,
-    base64pad: base64pad,
-    base64url: base64url,
-    base64urlpad: base64urlpad
-});
-
-const alphabet = Array.from('🚀🪐☄🛰🌌🌑🌒🌓🌔🌕🌖🌗🌘🌍🌏🌎🐉☀💻🖥💾💿😂❤😍🤣😊🙏💕😭😘👍😅👏😁🔥🥰💔💖💙😢🤔😆🙄💪😉☺👌🤗💜😔😎😇🌹🤦🎉💞✌✨🤷😱😌🌸🙌😋💗💚😏💛🙂💓🤩😄😀🖤😃💯🙈👇🎶😒🤭❣😜💋👀😪😑💥🙋😞😩😡🤪👊🥳😥🤤👉💃😳✋😚😝😴🌟😬🙃🍀🌷😻😓⭐✅🥺🌈😈🤘💦✔😣🏃💐☹🎊💘😠☝😕🌺🎂🌻😐🖕💝🙊😹🗣💫💀👑🎵🤞😛🔴😤🌼😫⚽🤙☕🏆🤫👈😮🙆🍻🍃🐶💁😲🌿🧡🎁⚡🌞🎈❌✊👋😰🤨😶🤝🚶💰🍓💢🤟🙁🚨💨🤬✈🎀🍺🤓😙💟🌱😖👶🥴▶➡❓💎💸⬇😨🌚🦋😷🕺⚠🙅😟😵👎🤲🤠🤧📌🔵💅🧐🐾🍒😗🤑🌊🤯🐷☎💧😯💆👆🎤🙇🍑❄🌴💣🐸💌📍🥀🤢👅💡💩👐📸👻🤐🤮🎼🥵🚩🍎🍊👼💍📣🥂');
-const alphabetBytesToChars = /** @type {string[]} */ (alphabet.reduce((p, c, i) => { p[i] = c; return p }, /** @type {string[]} */([])));
-const alphabetCharsToBytes = /** @type {number[]} */ (alphabet.reduce((p, c, i) => { p[/** @type {number} */ (c.codePointAt(0))] = i; return p }, /** @type {number[]} */([])));
-
-/**
- * @param {Uint8Array} data
- * @returns {string}
- */
-function encode$3 (data) {
-  return data.reduce((p, c) => {
-    p += alphabetBytesToChars[c];
-    return p
-  }, '')
-}
-
-/**
- * @param {string} str
- * @returns {Uint8Array}
- */
-function decode$5 (str) {
-  const byts = [];
-  for (const char of str) {
-    const byt = alphabetCharsToBytes[/** @type {number} */ (char.codePointAt(0))];
-    if (byt === undefined) {
-      throw new Error(`Non-base256emoji character: ${char}`)
-    }
-    byts.push(byt);
-  }
-  return new Uint8Array(byts)
-}
-
-const base256emoji = from({
-  prefix: '🚀',
-  name: 'base256emoji',
-  encode: encode$3,
-  decode: decode$5
-});
-
-var base256emoji$1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    base256emoji: base256emoji
-});
-
-var encode_1$1 = encode$2;
+var encode_1$1 = encode$3;
 
 var MSB$2 = 0x80
   , REST$2 = 0x7F
   , MSBALL$1 = ~REST$2
   , INT$1 = Math.pow(2, 31);
 
-function encode$2(num, out, offset) {
+function encode$3(num, out, offset) {
   out = out || [];
   offset = offset || 0;
   var oldOffset = offset;
@@ -1050,12 +577,12 @@ function encode$2(num, out, offset) {
   }
   out[offset] = num | 0;
   
-  encode$2.bytes = offset - oldOffset + 1;
+  encode$3.bytes = offset - oldOffset + 1;
   
   return out
 }
 
-var decode$4 = read$1;
+var decode$5 = read$1;
 
 var MSB$1$1 = 0x80
   , REST$1$1 = 0x7F;
@@ -1112,7 +639,7 @@ var length$1 = function (value) {
 
 var varint$2 = {
     encode: encode_1$1
-  , decode: decode$4
+  , decode: decode$5
   , encodingLength: length$1
 };
 
@@ -1123,7 +650,7 @@ var _brrp_varint = varint$2;
  * @param {number} [offset=0]
  * @returns {[number, number]}
  */
-const decode$3 = (data, offset = 0) => {
+const decode$4 = (data, offset = 0) => {
   const code = _brrp_varint.decode(data, offset);
   return [code, _brrp_varint.decode.bytes]
 };
@@ -1172,10 +699,10 @@ const create = (code, digest) => {
  * @param {Uint8Array} multihash
  * @returns {MultihashDigest}
  */
-const decode$2 = (multihash) => {
+const decode$3 = (multihash) => {
   const bytes = coerce(multihash);
-  const [code, sizeOffset] = decode$3(bytes);
-  const [size, digestOffset] = decode$3(bytes.subarray(sizeOffset));
+  const [code, sizeOffset] = decode$4(bytes);
+  const [size, digestOffset] = decode$4(bytes.subarray(sizeOffset));
   const digest = bytes.subarray(sizeOffset + digestOffset);
 
   if (digest.byteLength !== size) {
@@ -1235,15 +762,81 @@ class Digest {
   }
 }
 
-// @ts-check
-
-/**
- * @template T
- * @typedef {import('./interface.js').ByteView<T>} ByteView
- */
+const base32 = rfc4648({
+  prefix: 'b',
+  name: 'base32',
+  alphabet: 'abcdefghijklmnopqrstuvwxyz234567',
+  bitsPerChar: 5
+});
 
-new TextEncoder();
-new TextDecoder();
+const base32upper = rfc4648({
+  prefix: 'B',
+  name: 'base32upper',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567',
+  bitsPerChar: 5
+});
+
+const base32pad = rfc4648({
+  prefix: 'c',
+  name: 'base32pad',
+  alphabet: 'abcdefghijklmnopqrstuvwxyz234567=',
+  bitsPerChar: 5
+});
+
+const base32padupper = rfc4648({
+  prefix: 'C',
+  name: 'base32padupper',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=',
+  bitsPerChar: 5
+});
+
+const base32hex = rfc4648({
+  prefix: 'v',
+  name: 'base32hex',
+  alphabet: '0123456789abcdefghijklmnopqrstuv',
+  bitsPerChar: 5
+});
+
+const base32hexupper = rfc4648({
+  prefix: 'V',
+  name: 'base32hexupper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV',
+  bitsPerChar: 5
+});
+
+const base32hexpad = rfc4648({
+  prefix: 't',
+  name: 'base32hexpad',
+  alphabet: '0123456789abcdefghijklmnopqrstuv=',
+  bitsPerChar: 5
+});
+
+const base32hexpadupper = rfc4648({
+  prefix: 'T',
+  name: 'base32hexpadupper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUV=',
+  bitsPerChar: 5
+});
+
+const base32z = rfc4648({
+  prefix: 'h',
+  name: 'base32z',
+  alphabet: 'ybndrfg8ejkmcpqxot1uwisza345h769',
+  bitsPerChar: 5
+});
+
+var base32$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base32: base32,
+    base32hex: base32hex,
+    base32hexpad: base32hexpad,
+    base32hexpadupper: base32hexpadupper,
+    base32hexupper: base32hexupper,
+    base32pad: base32pad,
+    base32padupper: base32padupper,
+    base32upper: base32upper,
+    base32z: base32z
+});
 
 /**
  * @template {API.Link<unknown, number, number, API.Version>} T
@@ -1499,7 +1092,7 @@ class CID {
       const { version, multihash, code } = value;
       const digest =
         /** @type {API.MultihashDigest<Alg>} */
-        (decode$2(multihash));
+        (decode$3(multihash));
       return CID.create(version, code, digest)
     } else {
       // Otherwise value is not a CID (or an incompatible version of it) in
@@ -1655,7 +1248,7 @@ class CID {
   static inspectBytes (initialBytes) {
     let offset = 0;
     const next = () => {
-      const [i, length] = decode$3(initialBytes.subarray(offset));
+      const [i, length] = decode$4(initialBytes.subarray(offset));
       offset += length;
       return i
     };
@@ -1793,126 +1386,595 @@ const toStringV1 = (bytes, cache, base) => {
   }
 };
 
-const DAG_PB_CODE = 0x70;
-const SHA_256_CODE = 0x12;
+const DAG_PB_CODE = 0x70;
+const SHA_256_CODE = 0x12;
+
+/**
+ * @param {API.Version} version
+ * @param {number} code
+ * @param {Uint8Array} multihash
+ * @returns {Uint8Array}
+ */
+const encodeCID = (version, code, multihash) => {
+  const codeOffset = encodingLength(version);
+  const hashOffset = codeOffset + encodingLength(code);
+  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
+  encodeTo(version, bytes, 0);
+  encodeTo(code, bytes, codeOffset);
+  bytes.set(multihash, hashOffset);
+  return bytes
+};
+
+const cidSymbol = Symbol.for('@ipld/js-cid/CID');
+
+/**
+ * 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 ArrayLikes
+ */
+function 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);
+}
+
+var encode_1 = encode$2;
+
+var MSB$1 = 0x80
+  , REST$1 = 0x7F
+  , MSBALL = ~REST$1
+  , INT = Math.pow(2, 31);
+
+function encode$2(num, out, offset) {
+  if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
+    encode$2.bytes = 0;
+    throw new RangeError('Could not encode varint')
+  }
+  out = out || [];
+  offset = offset || 0;
+  var oldOffset = offset;
+
+  while(num >= INT) {
+    out[offset++] = (num & 0xFF) | MSB$1;
+    num /= 128;
+  }
+  while(num & MSBALL) {
+    out[offset++] = (num & 0xFF) | MSB$1;
+    num >>>= 7;
+  }
+  out[offset] = num | 0;
+  
+  encode$2.bytes = offset - oldOffset + 1;
+  
+  return out
+}
+
+var decode$2 = read;
+
+var MSB = 0x80
+  , REST = 0x7F;
+
+function read(buf, offset) {
+  var res    = 0
+    , offset = offset || 0
+    , shift  = 0
+    , counter = offset
+    , b
+    , l = buf.length;
+
+  do {
+    if (counter >= l || shift > 49) {
+      read.bytes = 0;
+      throw new RangeError('Could not decode varint')
+    }
+    b = buf[counter++];
+    res += shift < 28
+      ? (b & REST) << shift
+      : (b & REST) * Math.pow(2, shift);
+    shift += 7;
+  } while (b >= MSB)
+
+  read.bytes = counter - offset;
+
+  return res
+}
+
+var N1$1 = Math.pow(2,  7);
+var N2$1 = Math.pow(2, 14);
+var N3$1 = Math.pow(2, 21);
+var N4$1 = Math.pow(2, 28);
+var N5$1 = Math.pow(2, 35);
+var N6$1 = Math.pow(2, 42);
+var N7$1 = Math.pow(2, 49);
+var N8$1 = Math.pow(2, 56);
+var N9$1 = Math.pow(2, 63);
+
+var length = function (value) {
+  return (
+    value < N1$1 ? 1
+  : value < N2$1 ? 2
+  : value < N3$1 ? 3
+  : value < N4$1 ? 4
+  : value < N5$1 ? 5
+  : value < N6$1 ? 6
+  : value < N7$1 ? 7
+  : value < N8$1 ? 8
+  : value < N9$1 ? 9
+  :              10
+  )
+};
+
+var varint = {
+    encode: encode_1
+  , decode: decode$2
+  , encodingLength: length
+};
+
+var varint$1 = /*@__PURE__*/getDefaultExportFromCjs(varint);
+
+/* eslint-disable @typescript-eslint/no-unsafe-return */
+class Parser {
+    index = 0;
+    input = "";
+    new(input) {
+        this.index = 0;
+        this.input = input;
+        return this;
+    }
+    /** Run a parser, and restore the pre-parse state if it fails. */
+    readAtomically(fn) {
+        const index = this.index;
+        const result = fn();
+        if (result === undefined) {
+            this.index = index;
+        }
+        return result;
+    }
+    /** Run a parser, but fail if the entire input wasn't consumed. Doesn't run atomically. */
+    parseWith(fn) {
+        const result = fn();
+        if (this.index !== this.input.length) {
+            return undefined;
+        }
+        return result;
+    }
+    /** Peek the next character from the input */
+    peekChar() {
+        if (this.index >= this.input.length) {
+            return undefined;
+        }
+        return this.input[this.index];
+    }
+    /** Read the next character from the input */
+    readChar() {
+        if (this.index >= this.input.length) {
+            return undefined;
+        }
+        return this.input[this.index++];
+    }
+    /** Read the next character from the input if it matches the target. */
+    readGivenChar(target) {
+        return this.readAtomically(() => {
+            const char = this.readChar();
+            if (char !== target) {
+                return undefined;
+            }
+            return char;
+        });
+    }
+    /**
+     * Helper for reading separators in an indexed loop. Reads the separator
+     * character iff index > 0, then runs the parser. When used in a loop,
+     * the separator character will only be read on index > 0 (see
+     * readIPv4Addr for an example)
+     */
+    readSeparator(sep, index, inner) {
+        return this.readAtomically(() => {
+            if (index > 0) {
+                if (this.readGivenChar(sep) === undefined) {
+                    return undefined;
+                }
+            }
+            return inner();
+        });
+    }
+    /**
+     * Read a number off the front of the input in the given radix, stopping
+     * at the first non-digit character or eof. Fails if the number has more
+     * digits than max_digits or if there is no number.
+     */
+    readNumber(radix, maxDigits, allowZeroPrefix, maxBytes) {
+        return this.readAtomically(() => {
+            let result = 0;
+            let digitCount = 0;
+            const leadingChar = this.peekChar();
+            if (leadingChar === undefined) {
+                return undefined;
+            }
+            const hasLeadingZero = leadingChar === "0";
+            const maxValue = 2 ** (8 * maxBytes) - 1;
+            // eslint-disable-next-line no-constant-condition
+            while (true) {
+                const digit = this.readAtomically(() => {
+                    const char = this.readChar();
+                    if (char === undefined) {
+                        return undefined;
+                    }
+                    const num = Number.parseInt(char, radix);
+                    if (Number.isNaN(num)) {
+                        return undefined;
+                    }
+                    return num;
+                });
+                if (digit === undefined) {
+                    break;
+                }
+                result *= radix;
+                result += digit;
+                if (result > maxValue) {
+                    return undefined;
+                }
+                digitCount += 1;
+                if (maxDigits !== undefined) {
+                    if (digitCount > maxDigits) {
+                        return undefined;
+                    }
+                }
+            }
+            if (digitCount === 0) {
+                return undefined;
+            }
+            else if (!allowZeroPrefix && hasLeadingZero && digitCount > 1) {
+                return undefined;
+            }
+            else {
+                return result;
+            }
+        });
+    }
+    /** Read an IPv4 address. */
+    readIPv4Addr() {
+        return this.readAtomically(() => {
+            const out = new Uint8Array(4);
+            for (let i = 0; i < out.length; i++) {
+                const ix = this.readSeparator(".", i, () => this.readNumber(10, 3, false, 1));
+                if (ix === undefined) {
+                    return undefined;
+                }
+                out[i] = ix;
+            }
+            return out;
+        });
+    }
+    /** Read an IPv6 Address. */
+    readIPv6Addr() {
+        /**
+         * Read a chunk of an IPv6 address into `groups`. Returns the number
+         * of groups read, along with a bool indicating if an embedded
+         * trailing IPv4 address was read. Specifically, read a series of
+         * colon-separated IPv6 groups (0x0000 - 0xFFFF), with an optional
+         * trailing embedded IPv4 address.
+         */
+        const readGroups = (groups) => {
+            for (let i = 0; i < groups.length / 2; i++) {
+                const ix = i * 2;
+                // Try to read a trailing embedded IPv4 address. There must be at least 4 groups left.
+                if (i < groups.length - 3) {
+                    const ipv4 = this.readSeparator(":", i, () => this.readIPv4Addr());
+                    if (ipv4 !== undefined) {
+                        groups[ix] = ipv4[0];
+                        groups[ix + 1] = ipv4[1];
+                        groups[ix + 2] = ipv4[2];
+                        groups[ix + 3] = ipv4[3];
+                        return [ix + 4, true];
+                    }
+                }
+                const group = this.readSeparator(":", i, () => this.readNumber(16, 4, true, 2));
+                if (group === undefined) {
+                    return [ix, false];
+                }
+                groups[ix] = group >> 8;
+                groups[ix + 1] = group & 255;
+            }
+            return [groups.length, false];
+        };
+        return this.readAtomically(() => {
+            // Read the front part of the address; either the whole thing, or up to the first ::
+            const head = new Uint8Array(16);
+            const [headSize, headIp4] = readGroups(head);
+            if (headSize === 16) {
+                return head;
+            }
+            // IPv4 part is not allowed before `::`
+            if (headIp4) {
+                return undefined;
+            }
+            // Read `::` if previous code parsed less than 8 groups.
+            // `::` indicates one or more groups of 16 bits of zeros.
+            if (this.readGivenChar(":") === undefined) {
+                return undefined;
+            }
+            if (this.readGivenChar(":") === undefined) {
+                return undefined;
+            }
+            // Read the back part of the address. The :: must contain at least one
+            // set of zeroes, so our max length is 7.
+            const tail = new Uint8Array(14);
+            const limit = 16 - (headSize + 2);
+            const [tailSize] = readGroups(tail.subarray(0, limit));
+            // Concat the head and tail of the IP address
+            head.set(tail.subarray(0, tailSize), 16 - tailSize);
+            return head;
+        });
+    }
+    /** Read an IP Address, either IPv4 or IPv6. */
+    readIPAddr() {
+        return this.readIPv4Addr() ?? this.readIPv6Addr();
+    }
+}
+
+// See https://stackoverflow.com/questions/166132/maximum-length-of-the-textual-representation-of-an-ipv6-address
+const MAX_IPV6_LENGTH = 45;
+const MAX_IPV4_LENGTH = 15;
+const parser = new Parser();
+/** Parse `input` into IPv4 bytes. */
+function parseIPv4(input) {
+    if (input.length > MAX_IPV4_LENGTH) {
+        return undefined;
+    }
+    return parser.new(input).parseWith(() => parser.readIPv4Addr());
+}
+/** Parse `input` into IPv6 bytes. */
+function parseIPv6(input) {
+    // strip zone index if it is present
+    if (input.includes("%")) {
+        input = input.split("%")[0];
+    }
+    if (input.length > MAX_IPV6_LENGTH) {
+        return undefined;
+    }
+    return parser.new(input).parseWith(() => parser.readIPv6Addr());
+}
+/** Parse `input` into IPv4 or IPv6 bytes. */
+function parseIP(input) {
+    // strip zone index if it is present
+    if (input.includes("%")) {
+        input = input.split("%")[0];
+    }
+    if (input.length > MAX_IPV6_LENGTH) {
+        return undefined;
+    }
+    return parser.new(input).parseWith(() => parser.readIPAddr());
+}
+
+// @ts-check
+
+
+const identity = from({
+  prefix: '\x00',
+  name: 'identity',
+  encode: (buf) => toString$1(buf),
+  decode: (str) => fromString(str)
+});
+
+var identityBase = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    identity: identity
+});
+
+// @ts-check
+
+
+const base2 = rfc4648({
+  prefix: '0',
+  name: 'base2',
+  alphabet: '01',
+  bitsPerChar: 1
+});
+
+var base2$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base2: base2
+});
+
+// @ts-check
+
+
+const base8 = rfc4648({
+  prefix: '7',
+  name: 'base8',
+  alphabet: '01234567',
+  bitsPerChar: 3
+});
+
+var base8$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base8: base8
+});
+
+const base10 = baseX({
+  prefix: '9',
+  name: 'base10',
+  alphabet: '0123456789'
+});
+
+var base10$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base10: base10
+});
+
+// @ts-check
+
+
+const base16 = rfc4648({
+  prefix: 'f',
+  name: 'base16',
+  alphabet: '0123456789abcdef',
+  bitsPerChar: 4
+});
+
+const base16upper = rfc4648({
+  prefix: 'F',
+  name: 'base16upper',
+  alphabet: '0123456789ABCDEF',
+  bitsPerChar: 4
+});
+
+var base16$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base16: base16,
+    base16upper: base16upper
+});
+
+const base36 = baseX({
+  prefix: 'k',
+  name: 'base36',
+  alphabet: '0123456789abcdefghijklmnopqrstuvwxyz'
+});
+
+const base36upper = baseX({
+  prefix: 'K',
+  name: 'base36upper',
+  alphabet: '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ'
+});
+
+var base36$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base36: base36,
+    base36upper: base36upper
+});
+
+// @ts-check
+
 
-/**
- * @param {API.Version} version
- * @param {number} code
- * @param {Uint8Array} multihash
- * @returns {Uint8Array}
- */
-const encodeCID = (version, code, multihash) => {
-  const codeOffset = encodingLength(version);
-  const hashOffset = codeOffset + encodingLength(code);
-  const bytes = new Uint8Array(hashOffset + multihash.byteLength);
-  encodeTo(version, bytes, 0);
-  encodeTo(code, bytes, codeOffset);
-  bytes.set(multihash, hashOffset);
-  return bytes
-};
+const base64 = rfc4648({
+  prefix: 'm',
+  name: 'base64',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
+  bitsPerChar: 6
+});
 
-const cidSymbol = Symbol.for('@ipld/js-cid/CID');
+const base64pad = rfc4648({
+  prefix: 'M',
+  name: 'base64pad',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=',
+  bitsPerChar: 6
+});
 
-// @ts-check
+const base64url = rfc4648({
+  prefix: 'u',
+  name: 'base64url',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_',
+  bitsPerChar: 6
+});
 
-const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$1, ...base32$1, ...base36$1, ...base58, ...base64$1, ...base256emoji$1 };
+const base64urlpad = rfc4648({
+  prefix: 'U',
+  name: 'base64urlpad',
+  alphabet: 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_=',
+  bitsPerChar: 6
+});
 
-/**
- * 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;
-}
+var base64$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base64: base64,
+    base64pad: base64pad,
+    base64url: base64url,
+    base64urlpad: base64urlpad
+});
+
+const alphabet = Array.from('🚀🪐☄🛰🌌🌑🌒🌓🌔🌕🌖🌗🌘🌍🌏🌎🐉☀💻🖥💾💿😂❤😍🤣😊🙏💕😭😘👍😅👏😁🔥🥰💔💖💙😢🤔😆🙄💪😉☺👌🤗💜😔😎😇🌹🤦🎉💞✌✨🤷😱😌🌸🙌😋💗💚😏💛🙂💓🤩😄😀🖤😃💯🙈👇🎶😒🤭❣😜💋👀😪😑💥🙋😞😩😡🤪👊🥳😥🤤👉💃😳✋😚😝😴🌟😬🙃🍀🌷😻😓⭐✅🥺🌈😈🤘💦✔😣🏃💐☹🎊💘😠☝😕🌺🎂🌻😐🖕💝🙊😹🗣💫💀👑🎵🤞😛🔴😤🌼😫⚽🤙☕🏆🤫👈😮🙆🍻🍃🐶💁😲🌿🧡🎁⚡🌞🎈❌✊👋😰🤨😶🤝🚶💰🍓💢🤟🙁🚨💨🤬✈🎀🍺🤓😙💟🌱😖👶🥴▶➡❓💎💸⬇😨🌚🦋😷🕺⚠🙅😟😵👎🤲🤠🤧📌🔵💅🧐🐾🍒😗🤑🌊🤯🐷☎💧😯💆👆🎤🙇🍑❄🌴💣🐸💌📍🥀🤢👅💡💩👐📸👻🤐🤮🎼🥵🚩🍎🍊👼💍📣🥂');
+const alphabetBytesToChars = /** @type {string[]} */ (alphabet.reduce((p, c, i) => { p[i] = c; return p }, /** @type {string[]} */([])));
+const alphabetCharsToBytes = /** @type {number[]} */ (alphabet.reduce((p, c, i) => { p[/** @type {number} */ (c.codePointAt(0))] = i; return p }, /** @type {number[]} */([])));
 
 /**
- * Returns a `Uint8Array` of the requested size. Referenced memory will
- * be initialized to 0.
+ * @param {Uint8Array} data
+ * @returns {string}
  */
-function alloc(size = 0) {
-    if (globalThis.Buffer?.alloc != null) {
-        return asUint8Array(globalThis.Buffer.alloc(size));
-    }
-    return new Uint8Array(size);
+function encode$1 (data) {
+  return data.reduce((p, c) => {
+    p += alphabetBytesToChars[c];
+    return p
+  }, '')
 }
+
 /**
- * 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`.
+ * @param {string} str
+ * @returns {Uint8Array}
  */
-function allocUnsafe(size = 0) {
-    if (globalThis.Buffer?.allocUnsafe != null) {
-        return asUint8Array(globalThis.Buffer.allocUnsafe(size));
+function decode$1 (str) {
+  const byts = [];
+  for (const char of str) {
+    const byt = alphabetCharsToBytes[/** @type {number} */ (char.codePointAt(0))];
+    if (byt === undefined) {
+      throw new Error(`Non-base256emoji character: ${char}`)
     }
-    return new Uint8Array(size);
+    byts.push(byt);
+  }
+  return new Uint8Array(byts)
 }
 
-function createCodec(name, prefix, encode, decode) {
-    return {
-        name,
-        prefix,
-        encoder: {
-            name,
-            prefix,
-            encode
-        },
-        decoder: {
-            decode
-        }
-    };
-}
-const string = createCodec('utf8', 'u', (buf) => {
-    const decoder = new TextDecoder('utf8');
-    return 'u' + decoder.decode(buf);
-}, (str) => {
-    const encoder = new TextEncoder();
-    return encoder.encode(str.substring(1));
+const base256emoji = from({
+  prefix: '🚀',
+  name: 'base256emoji',
+  encode: encode$1,
+  decode: decode$1
 });
-const ascii = createCodec('ascii', 'a', (buf) => {
-    let string = 'a';
-    for (let i = 0; i < buf.length; i++) {
-        string += String.fromCharCode(buf[i]);
-    }
-    return string;
-}, (str) => {
-    str = str.substring(1);
-    const buf = allocUnsafe(str.length);
-    for (let i = 0; i < str.length; i++) {
-        buf[i] = str.charCodeAt(i);
-    }
-    return buf;
+
+var base256emoji$1 = /*#__PURE__*/Object.freeze({
+    __proto__: null,
+    base256emoji: base256emoji
 });
-const BASES = {
-    utf8: string,
-    'utf-8': string,
-    hex: bases.base16,
-    latin1: ascii,
-    ascii,
-    binary: ascii,
-    ...bases
-};
+
+// @ts-check
 
 /**
- * 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.
+ * @template T
+ * @typedef {import('./interface.js').ByteView<T>} ByteView
  */
-function toString$1(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);
+
+new TextEncoder();
+new TextDecoder();
+
+// @ts-check
+
+
+const bases = { ...identityBase, ...base2$1, ...base8$1, ...base10$1, ...base16$1, ...base32$1, ...base36$1, ...base58, ...base64$1, ...base256emoji$1 };
+
+/** Check if `input` is IPv4. */
+function isIPv4(input) {
+    return Boolean(parseIPv4(input));
+}
+/** Check if `input` is IPv6. */
+function isIPv6(input) {
+    return Boolean(parseIPv6(input));
+}
+/** Check if `input` is IPv4 or IPv6. */
+function isIP(input) {
+    return Boolean(parseIP(input));
 }
 
 const isV4 = isIPv4;
@@ -1937,10 +1999,10 @@ const toBytes$1 = function (ip) {
             let v4Buffer;
             if (isv4) {
                 v4Buffer = toBytes$1(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] === '') {
@@ -2086,135 +2148,6 @@ function getProtocol(proto) {
     throw new Error(`invalid protocol id type: ${typeof proto}`);
 }
 
-var encode_1 = encode$1;
-
-var MSB$1 = 0x80
-  , REST$1 = 0x7F
-  , MSBALL = ~REST$1
-  , INT = Math.pow(2, 31);
-
-function encode$1(num, out, offset) {
-  if (Number.MAX_SAFE_INTEGER && num > Number.MAX_SAFE_INTEGER) {
-    encode$1.bytes = 0;
-    throw new RangeError('Could not encode varint')
-  }
-  out = out || [];
-  offset = offset || 0;
-  var oldOffset = offset;
-
-  while(num >= INT) {
-    out[offset++] = (num & 0xFF) | MSB$1;
-    num /= 128;
-  }
-  while(num & MSBALL) {
-    out[offset++] = (num & 0xFF) | MSB$1;
-    num >>>= 7;
-  }
-  out[offset] = num | 0;
-  
-  encode$1.bytes = offset - oldOffset + 1;
-  
-  return out
-}
-
-var decode$1 = read;
-
-var MSB = 0x80
-  , REST = 0x7F;
-
-function read(buf, offset) {
-  var res    = 0
-    , offset = offset || 0
-    , shift  = 0
-    , counter = offset
-    , b
-    , l = buf.length;
-
-  do {
-    if (counter >= l || shift > 49) {
-      read.bytes = 0;
-      throw new RangeError('Could not decode varint')
-    }
-    b = buf[counter++];
-    res += shift < 28
-      ? (b & REST) << shift
-      : (b & REST) * Math.pow(2, shift);
-    shift += 7;
-  } while (b >= MSB)
-
-  read.bytes = counter - offset;
-
-  return res
-}
-
-var N1$1 = Math.pow(2,  7);
-var N2$1 = Math.pow(2, 14);
-var N3$1 = Math.pow(2, 21);
-var N4$1 = Math.pow(2, 28);
-var N5$1 = Math.pow(2, 35);
-var N6$1 = Math.pow(2, 42);
-var N7$1 = Math.pow(2, 49);
-var N8$1 = Math.pow(2, 56);
-var N9$1 = Math.pow(2, 63);
-
-var length = function (value) {
-  return (
-    value < N1$1 ? 1
-  : value < N2$1 ? 2
-  : value < N3$1 ? 3
-  : value < N4$1 ? 4
-  : value < N5$1 ? 5
-  : value < N6$1 ? 6
-  : value < N7$1 ? 7
-  : value < N8$1 ? 8
-  : value < N9$1 ? 9
-  :              10
-  )
-};
-
-var varint = {
-    encode: encode_1
-  , decode: decode$1
-  , encodingLength: length
-};
-
-var varint$1 = /*@__PURE__*/getDefaultExportFromCjs(varint);
-
-/**
- * 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$1(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 a new Uint8Array created by concatenating the passed ArrayLikes
- */
-function concat$1(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);
-}
-
 /**
  * @packageDocumentation
  *
@@ -2256,7 +2189,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) {
@@ -2328,7 +2261,7 @@ function bytes2port(buf) {
 function str2bytes(str) {
     const buf = fromString$1(str);
     const size = Uint8Array.from(varint$1.encode(buf.length));
-    return concat$1([size, buf], size.length + buf.length);
+    return concat([size, buf], size.length + buf.length);
 }
 function bytes2str(buf) {
     const size = varint$1.decode(buf);
@@ -2336,24 +2269,24 @@ 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;
     if (hash[0] === 'Q' || hash[0] === '1') {
-        mh = decode$2(base58btc.decode(`z${hash}`)).bytes;
+        mh = decode$3(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(varint$1.encode(mh.length));
-    return concat$1([size, mh], size.length + mh.length);
+    return concat([size, mh], size.length + mh.length);
 }
 function mb2bytes(mbstr) {
     const mb = anybaseDecoder.decode(mbstr);
     const size = Uint8Array.from(varint$1.encode(mb.length));
-    return concat$1([size, mb], size.length + mb.length);
+    return concat([size, mb], size.length + mb.length);
 }
 function bytes2mb(buf) {
     const size = varint$1.decode(buf);
@@ -2361,7 +2294,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
@@ -2372,7 +2305,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(':');
@@ -2390,7 +2323,7 @@ function onion2bytes(str) {
         throw new Error('Port number is not in range(1, 65536)');
     }
     const portBuf = port2bytes(port);
-    return concat$1([buf, portBuf], buf.length + portBuf.length);
+    return concat([buf, portBuf], buf.length + portBuf.length);
 }
 function onion32bytes(str) {
     const addr = str.split(':');
@@ -2408,30 +2341,37 @@ function onion32bytes(str) {
         throw new Error('Port number is not in range(1, 65536)');
     }
     const portBuf = port2bytes(port);
-    return concat$1([buf, portBuf], buf.length + portBuf.length);
+    return concat([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}`;
 }
 
-/**
- * string -> [[str name, str addr]... ]
- */
-function stringToStringTuples(str) {
+function stringToMultiaddrParts(str) {
+    str = cleanPath(str);
     const tuples = [];
-    const parts = str.split('/').slice(1); // skip first empty elem
+    const stringTuples = [];
+    let path = null;
+    const parts = str.split('/').slice(1);
     if (parts.length === 1 && parts[0] === '') {
-        return [];
+        return {
+            bytes: new Uint8Array(),
+            string: '/',
+            tuples: [],
+            stringTuples: [],
+            path: null
+        };
     }
     for (let p = 0; p < parts.length; p++) {
         const part = parts[p];
         const proto = getProtocol(part);
         if (proto.size === 0) {
-            tuples.push([part]);
+            tuples.push([proto.code]);
+            stringTuples.push([proto.code]);
             // eslint-disable-next-line no-continue
             continue;
         }
@@ -2441,18 +2381,67 @@ function stringToStringTuples(str) {
         }
         // if it's a path proto, take the rest
         if (proto.path === true) {
-            tuples.push([
-                part,
-                // should we need to check each path part to see if it's a proto?
-                // This would allow for other protocols to be added after a unix path,
-                // however it would have issues if the path had a protocol name in the path
-                cleanPath(parts.slice(p).join('/'))
-            ]);
+            // should we need to check each path part to see if it's a proto?
+            // This would allow for other protocols to be added after a unix path,
+            // however it would have issues if the path had a protocol name in the path
+            path = cleanPath(parts.slice(p).join('/'));
+            tuples.push([proto.code, convertToBytes(proto.code, path)]);
+            stringTuples.push([proto.code, path]);
+            break;
+        }
+        const bytes = convertToBytes(proto.code, parts[p]);
+        tuples.push([proto.code, bytes]);
+        stringTuples.push([proto.code, convertToString(proto.code, bytes)]);
+    }
+    return {
+        string: stringTuplesToString(stringTuples),
+        bytes: tuplesToBytes(tuples),
+        tuples,
+        stringTuples,
+        path
+    };
+}
+function bytesToMultiaddrParts(bytes) {
+    const tuples = [];
+    const stringTuples = [];
+    let path = null;
+    let i = 0;
+    while (i < bytes.length) {
+        const code = varint$1.decode(bytes, i);
+        const n = varint$1.decode.bytes ?? 0;
+        const p = getProtocol(code);
+        const size = sizeForAddr(p, bytes.slice(i + n));
+        if (size === 0) {
+            tuples.push([code]);
+            stringTuples.push([code]);
+            i += n;
+            // eslint-disable-next-line no-continue
+            continue;
+        }
+        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$2(bytes, 'base16'));
+        }
+        // ok, tuple seems good.
+        tuples.push([code, addr]);
+        const stringAddr = convertToString(code, addr);
+        stringTuples.push([code, stringAddr]);
+        if (p.path === true) {
+            // should we need to check each path part to see if it's a proto?
+            // This would allow for other protocols to be added after a unix path,
+            // however it would have issues if the path had a protocol name in the path
+            path = stringAddr;
             break;
         }
-        tuples.push([part, parts[p]]);
     }
-    return tuples;
+    return {
+        bytes: Uint8Array.from(bytes),
+        string: stringTuplesToString(stringTuples),
+        tuples,
+        stringTuples,
+        path
+    };
 }
 /**
  * [[str name, str addr]... ] -> string
@@ -2460,7 +2449,7 @@ function stringToStringTuples(str) {
 function stringTuplesToString(tuples) {
     const parts = [];
     tuples.map((tup) => {
-        const proto = protoFromTuple(tup);
+        const proto = getProtocol(tup[0]);
         parts.push(proto.name);
         if (tup.length > 1 && tup[1] != null) {
             parts.push(tup[1]);
@@ -2469,47 +2458,18 @@ function stringTuplesToString(tuples) {
     });
     return cleanPath(parts.join('/'));
 }
-/**
- * [[str name, str addr]... ] -> [[int code, Uint8Array]... ]
- */
-function stringTuplesToTuples(tuples) {
-    return tuples.map((tup) => {
-        if (!Array.isArray(tup)) {
-            tup = [tup];
-        }
-        const proto = protoFromTuple(tup);
-        if (tup.length > 1) {
-            return [proto.code, convertToBytes(proto.code, tup[1])];
-        }
-        return [proto.code];
-    });
-}
-/**
- * Convert tuples to string tuples
- *
- * [[int code, Uint8Array]... ] -> [[int code, str addr]... ]
- */
-function tuplesToStringTuples(tuples) {
-    return tuples.map(tup => {
-        const proto = protoFromTuple(tup);
-        if (tup[1] != null) {
-            return [proto.code, convertToString(proto.code, tup[1])];
-        }
-        return [proto.code];
-    });
-}
 /**
  * [[int code, Uint8Array ]... ] -> Uint8Array
  */
 function tuplesToBytes(tuples) {
-    return fromBytes(concat$1(tuples.map((tup) => {
-        const proto = protoFromTuple(tup);
+    return concat(tuples.map((tup) => {
+        const proto = getProtocol(tup[0]);
         let buf = Uint8Array.from(varint$1.encode(proto.code));
         if (tup.length > 1 && tup[1] != null) {
-            buf = concat$1([buf, tup[1]]); // add address buffer
+            buf = concat([buf, tup[1]]); // add address buffer
         }
         return buf;
-    })));
+    }));
 }
 /**
  * For the passed address, return the serialized size
@@ -2526,115 +2486,12 @@ function sizeForAddr(p, addr) {
         return size + (varint$1.decode.bytes ?? 0);
     }
 }
-function bytesToTuples(buf) {
-    const tuples = [];
-    let i = 0;
-    while (i < buf.length) {
-        const code = varint$1.decode(buf, i);
-        const n = varint$1.decode.bytes ?? 0;
-        const p = getProtocol(code);
-        const size = sizeForAddr(p, buf.slice(i + n));
-        if (size === 0) {
-            tuples.push([code]);
-            i += n;
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        const addr = buf.slice(i + n, i + n + size);
-        i += (size + n);
-        if (i > buf.length) { // did not end _exactly_ at buffer.length
-            throw ParseError('Invalid address Uint8Array: ' + toString$1(buf, 'base16'));
-        }
-        // ok, tuple seems good.
-        tuples.push([code, addr]);
-    }
-    return tuples;
-}
-/**
- * Uint8Array -> String
- */
-function bytesToString(buf) {
-    const a = bytesToTuples(buf);
-    const b = tuplesToStringTuples(a);
-    return stringTuplesToString(b);
-}
-/**
- * String -> Uint8Array
- */
-function stringToBytes(str) {
-    str = cleanPath(str);
-    const a = stringToStringTuples(str);
-    const b = stringTuplesToTuples(a);
-    return tuplesToBytes(b);
-}
-/**
- * String -> Uint8Array
- */
-function fromString(str) {
-    return stringToBytes(str);
-}
-/**
- * Uint8Array -> Uint8Array
- */
-function fromBytes(buf) {
-    const err = validateBytes(buf);
-    if (err != null) {
-        throw err;
-    }
-    return Uint8Array.from(buf); // copy
-}
-function validateBytes(buf) {
-    try {
-        bytesToTuples(buf); // try to parse. will throw if breaks
-    }
-    catch (err) {
-        return err;
-    }
-}
 function cleanPath(str) {
     return '/' + str.trim().split('/').filter((a) => a).join('/');
 }
 function ParseError(str) {
     return new Error('Error parsing address: ' + str);
 }
-function protoFromTuple(tup) {
-    const proto = getProtocol(tup[0]);
-    return proto;
-}
-
-/**
- * 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
-    }
-}
-
-/**
- * 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;
-}
 
 /**
  * @packageDocumentation
@@ -2649,18 +2506,6 @@ function equals(a, b) {
  * const ma = multiaddr('/ip4/127.0.0.1/tcp/1234')
  * ```
  */
-var __classPrivateFieldGet = (undefined && undefined.__classPrivateFieldGet) || function (receiver, state, kind, f) {
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
-    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
-};
-var __classPrivateFieldSet = (undefined && undefined.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
-    if (kind === "m") throw new TypeError("Private method is not writable");
-    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
-    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
-    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
-};
-var _DefaultMultiaddr_string, _DefaultMultiaddr_tuples, _DefaultMultiaddr_stringTuples, _DefaultMultiaddr_path, _a;
 const inspect = Symbol.for('nodejs.util.inspect.custom');
 const DNS_CODES = [
     getProtocol('dns').code,
@@ -2694,37 +2539,41 @@ function isMultiaddr(value) {
  * Creates a {@link Multiaddr} from a {@link MultiaddrInput}
  */
 class DefaultMultiaddr {
+    bytes;
+    #string;
+    #tuples;
+    #stringTuples;
+    #path;
+    [symbol$1] = true;
     constructor(addr) {
-        _DefaultMultiaddr_string.set(this, void 0);
-        _DefaultMultiaddr_tuples.set(this, void 0);
-        _DefaultMultiaddr_stringTuples.set(this, void 0);
-        _DefaultMultiaddr_path.set(this, void 0);
-        this[_a] = true;
         // default
         if (addr == null) {
             addr = '';
         }
+        let parts;
         if (addr instanceof Uint8Array) {
-            this.bytes = fromBytes(addr);
+            parts = bytesToMultiaddrParts(addr);
         }
         else if (typeof addr === 'string') {
             if (addr.length > 0 && addr.charAt(0) !== '/') {
                 throw new Error(`multiaddr "${addr}" must start with a "/"`);
             }
-            this.bytes = fromString(addr);
+            parts = stringToMultiaddrParts(addr);
         }
         else if (isMultiaddr(addr)) { // Multiaddr
-            this.bytes = fromBytes(addr.bytes); // validate + copy buffer
+            parts = bytesToMultiaddrParts(addr.bytes);
         }
         else {
             throw new Error('addr must be a string, Buffer, or another Multiaddr');
         }
+        this.bytes = parts.bytes;
+        this.#string = parts.string;
+        this.#tuples = parts.tuples;
+        this.#stringTuples = parts.stringTuples;
+        this.#path = parts.path;
     }
     toString() {
-        if (__classPrivateFieldGet(this, _DefaultMultiaddr_string, "f") == null) {
-            __classPrivateFieldSet(this, _DefaultMultiaddr_string, bytesToString(this.bytes), "f");
-        }
-        return __classPrivateFieldGet(this, _DefaultMultiaddr_string, "f");
+        return this.#string;
     }
     toJSON() {
         return this.toString();
@@ -2774,36 +2623,19 @@ class DefaultMultiaddr {
         return opts;
     }
     protos() {
-        return this.protoCodes().map(code => Object.assign({}, getProtocol(code)));
+        return this.#tuples.map(([code]) => Object.assign({}, getProtocol(code)));
     }
     protoCodes() {
-        const codes = [];
-        const buf = this.bytes;
-        let i = 0;
-        while (i < buf.length) {
-            const code = varint$1.decode(buf, i);
-            const n = varint$1.decode.bytes ?? 0;
-            const p = getProtocol(code);
-            const size = sizeForAddr(p, buf.slice(i + n));
-            i += (size + n);
-            codes.push(code);
-        }
-        return codes;
+        return this.#tuples.map(([code]) => code);
     }
     protoNames() {
-        return this.protos().map(proto => proto.name);
+        return this.#tuples.map(([code]) => getProtocol(code).name);
     }
     tuples() {
-        if (__classPrivateFieldGet(this, _DefaultMultiaddr_tuples, "f") == null) {
-            __classPrivateFieldSet(this, _DefaultMultiaddr_tuples, bytesToTuples(this.bytes), "f");
-        }
-        return __classPrivateFieldGet(this, _DefaultMultiaddr_tuples, "f");
+        return this.#tuples;
     }
     stringTuples() {
-        if (__classPrivateFieldGet(this, _DefaultMultiaddr_stringTuples, "f") == null) {
-            __classPrivateFieldSet(this, _DefaultMultiaddr_stringTuples, tuplesToStringTuples(this.tuples()), "f");
-        }
-        return __classPrivateFieldGet(this, _DefaultMultiaddr_stringTuples, "f");
+        return this.#stringTuples;
     }
     encapsulate(addr) {
         addr = new DefaultMultiaddr(addr);
@@ -2829,23 +2661,28 @@ class DefaultMultiaddr {
     }
     getPeerId() {
         try {
-            const tuples = this.stringTuples().filter((tuple) => {
-                if (tuple[0] === names.ipfs.code) {
-                    return true;
+            let tuples = [];
+            this.stringTuples().forEach(([code, name]) => {
+                if (code === names.p2p.code) {
+                    tuples.push([code, name]);
+                }
+                // if this is a p2p-circuit address, return the target peer id if present
+                // not the peer id of the relay
+                if (code === names['p2p-circuit'].code) {
+                    tuples = [];
                 }
-                return false;
             });
-            // Get the last ipfs tuple ['ipfs', 'peerid string']
+            // Get the last ipfs tuple ['p2p', 'peerid string']
             const tuple = tuples.pop();
             if (tuple?.[1] != null) {
                 const peerIdStr = tuple[1];
                 // 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;
         }
@@ -2854,26 +2691,7 @@ class DefaultMultiaddr {
         }
     }
     getPath() {
-        // on initialization, this.#path is undefined
-        // after the first call, it is either a string or null
-        if (__classPrivateFieldGet(this, _DefaultMultiaddr_path, "f") === undefined) {
-            try {
-                __classPrivateFieldSet(this, _DefaultMultiaddr_path, this.stringTuples().filter((tuple) => {
-                    const proto = getProtocol(tuple[0]);
-                    if (proto.path === true) {
-                        return true;
-                    }
-                    return false;
-                })[0][1], "f");
-                if (__classPrivateFieldGet(this, _DefaultMultiaddr_path, "f") == null) {
-                    __classPrivateFieldSet(this, _DefaultMultiaddr_path, null, "f");
-                }
-            }
-            catch {
-                __classPrivateFieldSet(this, _DefaultMultiaddr_path, null, "f");
-            }
-        }
-        return __classPrivateFieldGet(this, _DefaultMultiaddr_path, "f");
+        return this.#path;
     }
     equals(addr) {
         return equals(this.bytes, addr.bytes);
@@ -2927,8 +2745,8 @@ class DefaultMultiaddr {
      * // 'Multiaddr(/ip4/127.0.0.1/tcp/4001)'
      * ```
      */
-    [(_DefaultMultiaddr_string = new WeakMap(), _DefaultMultiaddr_tuples = new WeakMap(), _DefaultMultiaddr_stringTuples = new WeakMap(), _DefaultMultiaddr_path = new WeakMap(), _a = symbol$1, inspect)]() {
-        return `Multiaddr(${bytesToString(this.bytes)})`;
+    [inspect]() {
+        return `Multiaddr(${this.#string})`;
     }
 }
 /**
@@ -2948,41 +2766,6 @@ function multiaddr(addr) {
     return new DefaultMultiaddr(addr);
 }
 
-var Protocols;
-(function (Protocols) {
-    Protocols["Relay"] = "relay";
-    Protocols["Store"] = "store";
-    Protocols["LightPush"] = "lightpush";
-    Protocols["Filter"] = "filter";
-})(Protocols || (Protocols = {}));
-var SendError;
-(function (SendError) {
-    SendError["GENERIC_FAIL"] = "Generic error";
-    SendError["ENCODE_FAILED"] = "Failed to encode";
-    SendError["DECODE_FAILED"] = "Failed to decode";
-    SendError["SIZE_TOO_BIG"] = "Size is too big";
-    SendError["NO_RPC_RESPONSE"] = "No RPC response";
-})(SendError || (SendError = {}));
-
-var PageDirection$1;
-(function (PageDirection) {
-    PageDirection["BACKWARD"] = "backward";
-    PageDirection["FORWARD"] = "forward";
-})(PageDirection$1 || (PageDirection$1 = {}));
-
-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 = {}));
-
 /**
  * Adds types to the EventTarget class. Hopefully this won't be necessary forever.
  *
@@ -3066,16 +2849,34 @@ class KeepAliveManager {
         this.options = options;
         this.relay = relay;
     }
-    start(peerId, libp2pPing) {
-        // Just in case a timer already exist for this peer
+    start(peerId, libp2pPing, peerStore) {
+        // Just in case a timer already exists for this peer
         this.stop(peerId);
         const { pingKeepAlive: pingPeriodSecs, relayKeepAlive: relayPeriodSecs } = this.options;
         const peerIdStr = peerId.toString();
         if (pingPeriodSecs !== 0) {
             const interval = setInterval(() => {
-                libp2pPing.ping(peerId).catch((e) => {
-                    log$6(`Ping failed (${peerIdStr})`, e);
-                });
+                void (async () => {
+                    try {
+                        // ping the peer for keep alive
+                        // also update the peer store with the latency
+                        const ping = await libp2pPing.ping(peerId);
+                        log$6(`Ping succeeded (${peerIdStr})`, ping);
+                        try {
+                            await peerStore.patch(peerId, {
+                                metadata: {
+                                    ping: utf8ToBytes$1(ping.toString())
+                                }
+                            });
+                        }
+                        catch (e) {
+                            log$6("Failed to update ping", e);
+                        }
+                    }
+                    catch (e) {
+                        log$6(`Ping failed (${peerIdStr})`, e);
+                    }
+                })();
             }, pingPeriodSecs * 1000);
             this.pingKeepAliveTimers.set(peerIdStr, interval);
         }
@@ -3083,7 +2884,7 @@ class KeepAliveManager {
         if (relay && relayPeriodSecs !== 0) {
             const encoder = createEncoder({
                 contentTopic: RelayPingContentTopic,
-                ephemeral: true,
+                ephemeral: true
             });
             const interval = setInterval(() => {
                 log$6("Sending Waku Relay ping message");
@@ -3108,7 +2909,7 @@ class KeepAliveManager {
     stopAll() {
         for (const timer of [
             ...Object.values(this.pingKeepAliveTimers),
-            ...Object.values(this.relayKeepAliveTimers),
+            ...Object.values(this.relayKeepAliveTimers)
         ]) {
             clearInterval(timer);
         }
@@ -3169,12 +2970,12 @@ class ConnectionManager extends EventEmitter {
         return {
             DISCOVERED: {
                 [Tags.BOOTSTRAP]: peersDiscoveredByBootstrap,
-                [Tags.PEER_EXCHANGE]: peersDiscoveredByPeerExchange,
+                [Tags.PEER_EXCHANGE]: peersDiscoveredByPeerExchange
             },
             CONNECTED: {
                 [Tags.BOOTSTRAP]: peersConnectedByBootstrap,
-                [Tags.PEER_EXCHANGE]: peersConnectedByPeerExchange,
-            },
+                [Tags.PEER_EXCHANGE]: peersConnectedByPeerExchange
+            }
         };
     }
     constructor(libp2p, keepAliveOptions, relay, options) {
@@ -3184,7 +2985,7 @@ class ConnectionManager extends EventEmitter {
             maxDialAttemptsForPeer: DEFAULT_MAX_DIAL_ATTEMPTS_FOR_PEER,
             maxBootstrapPeersAllowed: DEFAULT_MAX_BOOTSTRAP_PEERS_ALLOWED,
             maxParallelDials: DEFAULT_MAX_PARALLEL_DIALS,
-            ...options,
+            ...options
         };
         this.keepAliveManager = new KeepAliveManager(keepAliveOptions, relay);
         this.run()
@@ -3225,42 +3026,55 @@ class ConnectionManager extends EventEmitter {
     async dialPeer(peerId) {
         this.currentActiveDialCount += 1;
         let dialAttempt = 0;
-        while (dialAttempt <= this.options.maxDialAttemptsForPeer) {
+        while (dialAttempt < this.options.maxDialAttemptsForPeer) {
             try {
-                log$5(`Dialing peer ${peerId.toString()}`);
+                log$5(`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
                 // don't add duplicate tags
-                this.libp2p
-                    .getConnections(peerId)
-                    .forEach((conn) => (conn.tags = Array.from(new Set([...conn.tags, ...tags]))));
+                this.libp2p.getConnections(peerId).forEach((conn) => {
+                    conn.tags = Array.from(new Set([...conn.tags, ...tags]));
+                });
                 this.dialAttemptsForPeer.delete(peerId.toString());
-                return;
+                // Dialing succeeded, break the loop
+                break;
             }
-            catch (e) {
-                const error = e;
-                this.dialErrorsForPeer.set(peerId.toString(), error);
-                log$5(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
-                dialAttempt = this.dialAttemptsForPeer.get(peerId.toString()) ?? 1;
-                this.dialAttemptsForPeer.set(peerId.toString(), dialAttempt + 1);
-                if (dialAttempt <= this.options.maxDialAttemptsForPeer) {
-                    log$5(`Reattempting dial (${dialAttempt})`);
+            catch (error) {
+                if (error instanceof AggregateError) {
+                    // Handle AggregateError
+                    log$5(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
                 }
+                else {
+                    // Handle generic error
+                    log$5(`Error dialing peer ${peerId.toString()} - ${error.message}`);
+                }
+                this.dialErrorsForPeer.set(peerId.toString(), error);
+                dialAttempt++;
+                this.dialAttemptsForPeer.set(peerId.toString(), dialAttempt);
             }
         }
-        try {
-            log$5(`Deleting undialable peer ${peerId.toString()} from peer store. Error: ${JSON.stringify(this.dialErrorsForPeer.get(peerId.toString()).errors[0])}
-        }`);
-            this.dialErrorsForPeer.delete(peerId.toString());
-            return await this.libp2p.peerStore.delete(peerId);
-        }
-        catch (error) {
-            throw `Error deleting undialable peer ${peerId.toString()} from peer store - ${error}`;
-        }
-        finally {
-            this.currentActiveDialCount -= 1;
-            this.processDialQueue();
+        // Always decrease the active dial count and process the dial queue
+        this.currentActiveDialCount--;
+        this.processDialQueue();
+        // If max dial attempts reached and dialing failed, delete the peer
+        if (dialAttempt === this.options.maxDialAttemptsForPeer) {
+            try {
+                const error = this.dialErrorsForPeer.get(peerId.toString());
+                let errorMessage;
+                if (error instanceof AggregateError) {
+                    errorMessage = JSON.stringify(error.errors[0]);
+                }
+                else {
+                    errorMessage = error.message;
+                }
+                log$5(`Deleting undialable peer ${peerId.toString()} from peer store. Error: ${errorMessage}`);
+                this.dialErrorsForPeer.delete(peerId.toString());
+                await this.libp2p.peerStore.delete(peerId);
+            }
+            catch (error) {
+                throw new Error(`Error deleting undialable peer ${peerId.toString()} from peer store - ${error}`);
+            }
         }
     }
     async dropConnection(peerId) {
@@ -3321,16 +3135,11 @@ class ConnectionManager extends EventEmitter {
             void (async () => {
                 const { id: peerId } = evt.detail;
                 const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(Tags.BOOTSTRAP);
-                if (isBootstrap) {
-                    this.dispatchEvent(new CustomEvent(EPeersByDiscoveryEvents.PEER_DISCOVERY_BOOTSTRAP, {
-                        detail: peerId,
-                    }));
-                }
-                else {
-                    this.dispatchEvent(new CustomEvent(EPeersByDiscoveryEvents.PEER_DISCOVERY_PEER_EXCHANGE, {
-                        detail: peerId,
-                    }));
-                }
+                this.dispatchEvent(new CustomEvent(isBootstrap
+                    ? EPeersByDiscoveryEvents.PEER_DISCOVERY_BOOTSTRAP
+                    : EPeersByDiscoveryEvents.PEER_DISCOVERY_PEER_EXCHANGE, {
+                    detail: peerId
+                }));
                 try {
                     await this.attemptDial(peerId);
                 }
@@ -3342,7 +3151,7 @@ class ConnectionManager extends EventEmitter {
         "peer:connect": (evt) => {
             void (async () => {
                 const peerId = evt.detail;
-                this.keepAliveManager.start(peerId, this.libp2p.services.ping);
+                this.keepAliveManager.start(peerId, this.libp2p.services.ping, this.libp2p.peerStore);
                 const isBootstrap = (await this.getTagNamesForPeer(peerId)).includes(Tags.BOOTSTRAP);
                 if (isBootstrap) {
                     const bootstrapConnections = this.libp2p
@@ -3354,13 +3163,13 @@ class ConnectionManager extends EventEmitter {
                     }
                     else {
                         this.dispatchEvent(new CustomEvent(EPeersByDiscoveryEvents.PEER_CONNECT_BOOTSTRAP, {
-                            detail: peerId,
+                            detail: peerId
                         }));
                     }
                 }
                 else {
                     this.dispatchEvent(new CustomEvent(EPeersByDiscoveryEvents.PEER_CONNECT_PEER_EXCHANGE, {
-                        detail: peerId,
+                        detail: peerId
                     }));
                 }
             })();
@@ -3369,7 +3178,7 @@ class ConnectionManager extends EventEmitter {
             return (evt) => {
                 this.keepAliveManager.stop(evt.detail);
             };
-        },
+        }
     };
     /**
      * Checks if the peer is dialable based on the following conditions:
@@ -3569,13 +3378,13 @@ const FRAME_RATE = 60;
  * @param iteratorOptions - optional configuration for iterator;
  * @returns iterator and stop function to terminate it.
  */
-async function toAsyncIterator(receiver, decoder, options, iteratorOptions) {
+async function toAsyncIterator(receiver, decoder, iteratorOptions) {
     const iteratorDelay = iteratorOptions?.iteratorDelay ?? FRAME_RATE;
     const messages = [];
     let unsubscribe;
     unsubscribe = await receiver.subscribe(decoder, (message) => {
         messages.push(message);
-    }, options);
+    });
     const isWithTimeout = Number.isInteger(iteratorOptions?.timeoutMs);
     const timeoutMs = iteratorOptions?.timeoutMs ?? 0;
     const startTime = Date.now();
@@ -3602,7 +3411,7 @@ async function toAsyncIterator(receiver, decoder, options, iteratorOptions) {
                 await unsubscribe();
                 unsubscribe = undefined;
             }
-        },
+        }
     };
 }
 function wait(ms) {
@@ -3811,7 +3620,7 @@ class Uint8ArrayList {
      */
     slice(beginInclusive, endExclusive) {
         const { bufs, length } = this._subList(beginInclusive, endExclusive);
-        return concat$1(bufs, length);
+        return concat(bufs, length);
     }
     /**
      * Returns a alloc from the given start and end element index.
@@ -3824,7 +3633,7 @@ class Uint8ArrayList {
         if (bufs.length === 1) {
             return bufs[0];
         }
-        return concat$1(bufs, length);
+        return concat(bufs, length);
     }
     /**
      * Returns a allocList from the given start and end element index.
@@ -4626,8 +4435,24 @@ decode.fromReader = (reader, options) => {
     });
 };
 
+function pDefer() {
+	const deferred = {};
+
+	deferred.promise = new Promise((resolve, reject) => {
+		deferred.resolve = resolve;
+		deferred.reject = reject;
+	});
+
+	return deferred;
+}
+
 // ported from https://www.npmjs.com/package/fast-fifo
 class FixedFIFO {
+    buffer;
+    mask;
+    top;
+    btm;
+    next;
     constructor(hwm) {
         if (!(hwm > 0) || ((hwm - 1) & hwm) !== 0) {
             throw new Error('Max size for a FixedFIFO should be a power of two');
@@ -4660,6 +4485,10 @@ class FixedFIFO {
     }
 }
 class FIFO {
+    size;
+    hwm;
+    head;
+    tail;
     constructor(options = {}) {
         this.hwm = options.splitLimit ?? 16;
         this.head = new FixedFIFO(this.hwm);
@@ -4748,6 +4577,15 @@ class FIFO {
  * // [ [1, 2, 3] ]
  * ```
  */
+let AbortError$1 = class AbortError extends Error {
+    type;
+    code;
+    constructor(message, code) {
+        super(message ?? 'The operation was aborted');
+        this.type = 'aborted';
+        this.code = code ?? 'ABORT_ERR';
+    }
+};
 function pushable(options = {}) {
     const getNext = (buffer) => {
         const next = buffer.shift();
@@ -4759,7 +4597,7 @@ function pushable(options = {}) {
         }
         return {
             done: next.done === true,
-            // @ts-expect-error
+            // @ts-expect-error if done is false, value will be present
             value: next.value
         };
     };
@@ -4772,26 +4610,39 @@ function _pushable(getNext, options) {
     let pushable;
     let onNext;
     let ended;
+    let drain = pDefer();
     const waitNext = async () => {
-        if (!buffer.isEmpty()) {
-            return getNext(buffer);
+        try {
+            if (!buffer.isEmpty()) {
+                return getNext(buffer);
+            }
+            if (ended) {
+                return { done: true };
+            }
+            return await new Promise((resolve, reject) => {
+                onNext = (next) => {
+                    onNext = null;
+                    buffer.push(next);
+                    try {
+                        resolve(getNext(buffer));
+                    }
+                    catch (err) {
+                        reject(err);
+                    }
+                    return pushable;
+                };
+            });
         }
-        if (ended) {
-            return { done: true };
+        finally {
+            if (buffer.isEmpty()) {
+                // settle promise in the microtask queue to give consumers a chance to
+                // await after calling .push
+                queueMicrotask(() => {
+                    drain.resolve();
+                    drain = pDefer();
+                });
+            }
         }
-        return await new Promise((resolve, reject) => {
-            onNext = (next) => {
-                onNext = null;
-                buffer.push(next);
-                try {
-                    resolve(getNext(buffer));
-                }
-                catch (err) {
-                    reject(err);
-                }
-                return pushable;
-            };
-        });
     };
     const bufferNext = (next) => {
         if (onNext != null) {
@@ -4842,6 +4693,34 @@ function _pushable(getNext, options) {
         end,
         get readableLength() {
             return buffer.size;
+        },
+        onEmpty: async (options) => {
+            const signal = options?.signal;
+            signal?.throwIfAborted();
+            if (buffer.isEmpty()) {
+                return;
+            }
+            let cancel;
+            let listener;
+            if (signal != null) {
+                cancel = new Promise((resolve, reject) => {
+                    listener = () => {
+                        reject(new AbortError$1());
+                    };
+                    signal.addEventListener('abort', listener);
+                });
+            }
+            try {
+                await Promise.race([
+                    drain.promise,
+                    cancel
+                ]);
+            }
+            finally {
+                if (listener != null && signal != null) {
+                    signal?.removeEventListener('abort', listener);
+                }
+            }
         }
     };
     if (onEnd == null) {
@@ -5111,7 +4990,7 @@ class FilterSubscribeRpc {
             requestId: v4(),
             filterSubscribeType: FilterSubscribeRequest.FilterSubscribeType.SUBSCRIBE,
             pubsubTopic,
-            contentTopics,
+            contentTopics
         });
     }
     static createUnsubscribeRequest(pubsubTopic, contentTopics) {
@@ -5119,7 +4998,7 @@ class FilterSubscribeRpc {
             requestId: v4(),
             filterSubscribeType: FilterSubscribeRequest.FilterSubscribeType.UNSUBSCRIBE,
             pubsubTopic,
-            contentTopics,
+            contentTopics
         });
     }
     static createUnsubscribeAllRequest(pubsubTopic) {
@@ -5127,7 +5006,7 @@ class FilterSubscribeRpc {
             requestId: v4(),
             filterSubscribeType: FilterSubscribeRequest.FilterSubscribeType.UNSUBSCRIBE_ALL,
             pubsubTopic,
-            contentTopics: [],
+            contentTopics: []
         });
     }
     static createSubscriberPingRequest() {
@@ -5135,7 +5014,7 @@ class FilterSubscribeRpc {
             requestId: v4(),
             filterSubscribeType: FilterSubscribeRequest.FilterSubscribeType.SUBSCRIBER_PING,
             pubsubTopic: "",
-            contentTopics: [],
+            contentTopics: []
         });
     }
     static decode(bytes) {
@@ -5184,7 +5063,7 @@ class FilterSubscribeResponse {
 const log$3 = debug("waku:filter:v2");
 const FilterCodecs = {
     SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
-    PUSH: "/vac/waku/filter-push/2.0.0-beta1",
+    PUSH: "/vac/waku/filter-push/2.0.0-beta1"
 };
 class Subscription {
     peer;
@@ -5227,7 +5106,7 @@ class Subscription {
             // Decoder that decode to different implementations of `IDecodedMessage`
             const subscriptionCallback = {
                 decoders,
-                callback,
+                callback
             };
             // The callback and decoder may override previous values, this is on
             // purpose as the user may call `subscribe` to refresh the subscription
@@ -5292,6 +5171,7 @@ class Subscription {
 class Filter extends BaseProtocol {
     options;
     activeSubscriptions = new Map();
+    NUM_PEERS_PROTOCOL = 1;
     getActiveSubscription(pubSubTopic, peerIdStr) {
         return this.activeSubscriptions.get(`${pubSubTopic}_${peerIdStr}`);
     }
@@ -5307,15 +5187,18 @@ class Filter extends BaseProtocol {
         this.activeSubscriptions = new Map();
         this.options = options ?? {};
     }
-    async createSubscription(pubSubTopic, peerId) {
+    async createSubscription(pubSubTopic) {
         const _pubSubTopic = pubSubTopic ?? this.options.pubSubTopic ?? DefaultPubSubTopic;
-        const peer = await this.getPeer(peerId);
+        const peer = (await this.getPeers({
+            maxBootstrapPeers: 1,
+            numPeers: this.NUM_PEERS_PROTOCOL
+        }))[0];
         const subscription = this.getActiveSubscription(_pubSubTopic, peer.id.toString()) ??
-            this.setActiveSubscription(_pubSubTopic, peer.id.toString(), new Subscription(_pubSubTopic, peer, this.newStream.bind(this, peer)));
+            this.setActiveSubscription(_pubSubTopic, peer.id.toString(), new Subscription(_pubSubTopic, peer, this.getStream.bind(this, peer)));
         return subscription;
     }
-    toSubscriptionIterator(decoders, opts) {
-        return toAsyncIterator(this, decoders, opts);
+    toSubscriptionIterator(decoders) {
+        return toAsyncIterator(this, decoders);
     }
     /**
      * This method is used to satisfy the `IReceiver` interface.
@@ -5332,8 +5215,8 @@ class Filter extends BaseProtocol {
      * This method should not be used directly.
      * Instead, use `createSubscription` to create a new subscription.
      */
-    async subscribe(decoders, callback, opts) {
-        const subscription = await this.createSubscription(undefined, opts?.peerId);
+    async subscribe(decoders, callback) {
+        const subscription = await this.createSubscription();
         await subscription.subscribe(decoders, callback);
         const contentTopics = Array.from(groupByContentTopic(Array.isArray(decoders) ? decoders : [decoders]).keys());
         return async () => {
@@ -5384,27 +5267,21 @@ async function pushMessage(subscriptionCallback, pubSubTopic, message) {
         log$3("Message has no content topic, skipping");
         return;
     }
-    let didDecodeMsg = false;
-    // We don't want to wait for decoding failure, just attempt to decode
-    // all messages and do the call back on the one that works
-    // noinspection ES6MissingAwait
-    for (const dec of decoders) {
-        if (didDecodeMsg)
-            break;
-        const decoded = await dec.fromProtoObj(pubSubTopic, message);
-        if (!decoded) {
-            log$3("Not able to decode message");
-            continue;
-        }
-        // This is just to prevent more decoding attempt
-        // TODO: Could be better if we were to abort promises
-        didDecodeMsg = Boolean(decoded);
-        await callback(decoded);
+    try {
+        const decodePromises = decoders.map((dec) => dec
+            .fromProtoObj(pubSubTopic, message)
+            .then((decoded) => decoded || Promise.reject("Decoding failed")));
+        const decodedMessage = await Promise.any(decodePromises);
+        await callback(decodedMessage);
+    }
+    catch (e) {
+        log$3("Error decoding message", e);
     }
 }
 
 var index$2 = /*#__PURE__*/Object.freeze({
     __proto__: null,
+    FilterCodecs: FilterCodecs,
     wakuFilter: wakuFilter
 });
 
@@ -5418,9 +5295,9 @@ class PushRpc {
             requestId: v4(),
             request: {
                 message: message,
-                pubsubTopic: pubSubTopic,
+                pubsubTopic: pubSubTopic
             },
-            response: undefined,
+            response: undefined
         });
     }
     static decode(bytes) {
@@ -5445,60 +5322,89 @@ const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
  */
 class LightPush extends BaseProtocol {
     options;
+    NUM_PEERS_PROTOCOL = 1;
     constructor(libp2p, options) {
         super(LightPushCodec, libp2p.components);
         this.options = options || {};
     }
-    async send(encoder, message, opts) {
-        const { pubSubTopic = DefaultPubSubTopic } = this.options;
-        const peer = await this.getPeer(opts?.peerId);
-        const stream = await this.newStream(peer);
-        const recipients = [];
-        let error = undefined;
+    async preparePushMessage(encoder, message, pubSubTopic) {
         try {
             if (!isSizeValid(message.payload)) {
-                log$2("Failed to send waku light push: message is bigger that 1MB");
-                return {
-                    recipients,
-                    error: SendError.SIZE_TOO_BIG,
-                };
+                log$2("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("Failed to encode to protoMessage, aborting push");
                 return {
-                    recipients,
-                    error: SendError.ENCODE_FAILED,
+                    query: null,
+                    error: SendError.ENCODE_FAILED
                 };
             }
             const query = PushRpc.createRequest(protoMessage, pubSubTopic);
-            const res = await pipe([query.encode()], encode, stream, decode, async (source) => await all(source));
+            return { query, error: null };
+        }
+        catch (error) {
+            log$2("Failed to prepare push message", error);
+            return {
+                query: null,
+                error: SendError.GENERIC_FAIL
+            };
+        }
+    }
+    async send(encoder, message) {
+        const { pubSubTopic = DefaultPubSubTopic } = this.options;
+        const recipients = [];
+        const { query, error: preparationError } = await this.preparePushMessage(encoder, message, pubSubTopic);
+        if (preparationError || !query) {
+            return {
+                recipients,
+                errors: [preparationError]
+            };
+        }
+        const peers = await this.getPeers({
+            maxBootstrapPeers: 1,
+            numPeers: this.NUM_PEERS_PROTOCOL
+        });
+        const promises = peers.map(async (peer) => {
+            let error;
+            const stream = await this.getStream(peer);
             try {
-                const bytes = new Uint8ArrayList();
-                res.forEach((chunk) => {
-                    bytes.append(chunk);
-                });
-                const response = PushRpc.decode(bytes).response;
-                if (response?.isSuccess) {
-                    recipients.push(peer.id);
+                const res = await pipe([query.encode()], encode, stream, decode, async (source) => await all(source));
+                try {
+                    const bytes = new Uint8ArrayList();
+                    res.forEach((chunk) => {
+                        bytes.append(chunk);
+                    });
+                    const response = PushRpc.decode(bytes).response;
+                    if (response?.isSuccess) {
+                        recipients.some((recipient) => recipient.equals(peer.id)) ||
+                            recipients.push(peer.id);
+                    }
+                    else {
+                        log$2("No response in PushRPC");
+                        error = SendError.NO_RPC_RESPONSE;
+                    }
                 }
-                else {
-                    log$2("No response in PushRPC");
-                    error = SendError.NO_RPC_RESPONSE;
+                catch (err) {
+                    log$2("Failed to decode push reply", err);
+                    error = SendError.DECODE_FAILED;
                 }
             }
             catch (err) {
-                log$2("Failed to decode push reply", err);
-                error = SendError.DECODE_FAILED;
+                log$2("Failed to send waku light push request", err);
+                error = SendError.GENERIC_FAIL;
             }
-        }
-        catch (err) {
-            log$2("Failed to send waku light push request", err);
-            error = SendError.GENERIC_FAIL;
-        }
+            return { recipients, error };
+        });
+        const results = await Promise.allSettled(promises);
+        const errors = results
+            .filter((result) => result.status === "fulfilled")
+            .map((result) => result.value.error)
+            .filter((error) => error !== undefined);
         return {
-            error,
             recipients,
+            errors
         };
     }
 }
@@ -5513,25 +5419,11 @@ var index$1 = /*#__PURE__*/Object.freeze({
     wakuLightPush: wakuLightPush
 });
 
-function number(n) {
-    if (!Number.isSafeInteger(n) || n < 0)
-        throw new Error(`Wrong positive integer: ${n}`);
-}
-function bool(b) {
-    if (typeof b !== 'boolean')
-        throw new Error(`Expected boolean, not ${b}`);
-}
 function bytes(b, ...lengths) {
     if (!(b instanceof Uint8Array))
-        throw new TypeError('Expected Uint8Array');
+        throw new Error('Expected Uint8Array');
     if (lengths.length > 0 && !lengths.includes(b.length))
-        throw new TypeError(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
-}
-function hash(hash) {
-    if (typeof hash !== 'function' || typeof hash.create !== 'function')
-        throw new Error('Hash should be wrapped by utils.wrapConstructor');
-    number(hash.outputLen);
-    number(hash.blockLen);
+        throw new Error(`Expected Uint8Array of length ${lengths}, not of length=${b.length}`);
 }
 function exists(instance, checkFinished = true) {
     if (instance.destroyed)
@@ -5546,16 +5438,15 @@ function output(out, instance) {
         throw new Error(`digestInto() expects output buffer of length at least ${min}`);
     }
 }
-const assert = {
-    number,
-    bool,
-    bytes,
-    hash,
-    exists,
-    output,
-};
 
 /*! 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
@@ -5565,18 +5456,24 @@ const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
 const isLE = new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
 if (!isLE)
     throw new Error('Non little-endian hardware is not supported');
-Array.from({ length: 256 }, (v, i) => i.toString(16).padStart(2, '0'));
-function utf8ToBytes$1(str) {
-    if (typeof str !== 'string') {
-        throw new TypeError(`utf8ToBytes expected string, got ${typeof str}`);
-    }
-    return new TextEncoder().encode(str);
+/**
+ * @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$1(data);
-    if (!(data instanceof Uint8Array))
-        throw new TypeError(`Expected input type is Uint8Array (got ${typeof data})`);
+        data = utf8ToBytes(data);
+    if (!u8a(data))
+        throw new Error(`expected Uint8Array, got ${typeof data}`);
     return data;
 }
 // For runtime check if class implements interface
@@ -5586,12 +5483,12 @@ class Hash {
         return this._cloneInto();
     }
 }
-function wrapConstructor(hashConstructor) {
-    const hashC = (message) => hashConstructor().update(toBytes(message)).digest();
-    const tmp = hashConstructor();
+function wrapConstructor(hashCons) {
+    const hashC = (msg) => hashCons().update(toBytes(msg)).digest();
+    const tmp = hashCons();
     hashC.outputLen = tmp.outputLen;
     hashC.blockLen = tmp.blockLen;
-    hashC.create = () => hashConstructor();
+    hashC.create = () => hashCons();
     return hashC;
 }
 
@@ -5624,7 +5521,7 @@ class SHA2 extends Hash {
         this.view = createView(this.buffer);
     }
     update(data) {
-        assert.exists(this);
+        exists(this);
         const { view, buffer, blockLen } = this;
         data = toBytes(data);
         const len = data.length;
@@ -5650,8 +5547,8 @@ class SHA2 extends Hash {
         return this;
     }
     digestInto(out) {
-        assert.exists(this);
-        assert.output(out, this);
+        exists(this);
+        output(out, this);
         this.finished = true;
         // Padding
         // We can avoid allocation of buffer for padding completely if it
@@ -5707,6 +5604,8 @@ class SHA2 extends Hash {
     }
 }
 
+// SHA2-256 need to try 2^128 hashes to execute birthday attack.
+// BTC network is doing 2^67 hashes/sec as per early 2023.
 // Choice: a ? b : c
 const Chi = (a, b, c) => (a & b) ^ (~a & c);
 // Majority function, true if any two inpust is true
@@ -5714,7 +5613,7 @@ 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 = new Uint32Array([
+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,
@@ -5726,12 +5625,12 @@ const SHA256_K = new Uint32Array([
 ]);
 // Initial state (first 32 bits of the fractional parts of the square roots of the first 8 primes 2..19):
 // prettier-ignore
-const IV = new Uint32Array([
+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 = new Uint32Array(64);
+const SHA256_W = /* @__PURE__ */ new Uint32Array(64);
 class SHA256 extends SHA2 {
     constructor() {
         super(64, 32, 8, false);
@@ -5807,45 +5706,11 @@ class SHA256 extends SHA2 {
         this.buffer.fill(0);
     }
 }
-// Constants from https://nvlpubs.nist.gov/nistpubs/FIPS/NIST.FIPS.180-4.pdf
-class SHA224 extends SHA256 {
-    constructor() {
-        super();
-        this.A = 0xc1059ed8 | 0;
-        this.B = 0x367cd507 | 0;
-        this.C = 0x3070dd17 | 0;
-        this.D = 0xf70e5939 | 0;
-        this.E = 0xffc00b31 | 0;
-        this.F = 0x68581511 | 0;
-        this.G = 0x64f98fa7 | 0;
-        this.H = 0xbefa4fa4 | 0;
-        this.outputLen = 28;
-    }
-}
 /**
  * SHA2-256 hash function
  * @param message - data that would be hashed
  */
-const sha256 = wrapConstructor(() => new SHA256());
-wrapConstructor(() => new SHA224());
-
-/**
- * Encode utf-8 string to byte array.
- */
-const utf8ToBytes = (s) => fromString$1(s, "utf8");
-/**
- * Concatenate using Uint8Arrays as `Buffer` has a different behavior with `DataView`
- */
-function concat(byteArrays, totalLength) {
-    const len = totalLength ?? byteArrays.reduce((acc, curr) => acc + curr.length, 0);
-    const res = new Uint8Array(len);
-    let offset = 0;
-    for (const bytes of byteArrays) {
-        res.set(bytes, offset);
-        offset += bytes.length;
-    }
-    return res;
-}
+const sha256 = /* @__PURE__ */ wrapConstructor(() => new SHA256());
 
 const EmptyMessage = {
     payload: new Uint8Array(),
@@ -5854,7 +5719,7 @@ const EmptyMessage = {
     timestamp: undefined,
     meta: undefined,
     rateLimitProof: undefined,
-    ephemeral: undefined,
+    ephemeral: undefined
 };
 function toProtoMessage(wire) {
     return { ...EmptyMessage, ...wire };
@@ -5888,7 +5753,7 @@ class HistoryRpc {
         const pagingInfo = {
             pageSize: BigInt(params.pageSize),
             cursor: params.cursor,
-            direction,
+            direction
         };
         let startTime, endTime;
         if (params.startTime) {
@@ -5906,9 +5771,9 @@ class HistoryRpc {
                 contentFilters,
                 pagingInfo,
                 startTime,
-                endTime,
+                endTime
             },
-            response: undefined,
+            response: undefined
         });
     }
     decode(bytes) {
@@ -5941,10 +5806,45 @@ const DefaultPageSize = 10;
  */
 class Store extends BaseProtocol {
     options;
+    NUM_PEERS_PROTOCOL = 1;
     constructor(libp2p, options) {
         super(StoreCodec, libp2p.components);
         this.options = options ?? {};
     }
+    /**
+     * Processes messages based on the provided callback and options.
+     * @private
+     */
+    async processMessages(messages, callback, options) {
+        let abort = false;
+        const messagesOrUndef = await Promise.all(messages);
+        let processedMessages = messagesOrUndef.filter(isDefined);
+        if (this.shouldReverseOrder(options)) {
+            processedMessages = processedMessages.reverse();
+        }
+        await Promise.all(processedMessages.map(async (msg) => {
+            if (msg && !abort) {
+                abort = Boolean(await callback(msg));
+            }
+        }));
+        return abort;
+    }
+    /**
+     * Determines whether to reverse the order of messages based on the provided options.
+     *
+     * Messages in pages are ordered from oldest (first) to most recent (last).
+     * https://github.com/vacp2p/rfc/issues/533
+     *
+     * @private
+     */
+    shouldReverseOrder(options) {
+        return (typeof options?.pageDirection === "undefined" ||
+            options?.pageDirection === PageDirection.BACKWARD);
+    }
+    /**
+     * @deprecated Use `queryWithOrderedCallback` instead
+     **/
+    queryOrderedCallback = this.queryWithOrderedCallback;
     /**
      * Do a query to a Waku Store to retrieve historical/missed messages.
      *
@@ -5962,31 +5862,16 @@ class Store extends BaseProtocol {
      * or if an error is encountered when processing the reply,
      * or if two decoders with the same content topic are passed.
      */
-    async queryOrderedCallback(decoders, callback, options) {
-        let abort = false;
+    async queryWithOrderedCallback(decoders, callback, options) {
         for await (const promises of this.queryGenerator(decoders, options)) {
-            if (abort)
+            if (await this.processMessages(promises, callback, options))
                 break;
-            const messagesOrUndef = await Promise.all(promises);
-            let messages = messagesOrUndef.filter(isDefined);
-            // Messages in pages are ordered from oldest (first) to most recent (last).
-            // https://github.com/vacp2p/rfc/issues/533
-            if (typeof options?.pageDirection === "undefined" ||
-                options?.pageDirection === PageDirection.BACKWARD) {
-                messages = messages.reverse();
-            }
-            await Promise.all(messages.map(async (msg) => {
-                if (msg && !abort) {
-                    abort = Boolean(await callback(msg));
-                }
-            }));
         }
     }
     /**
      * Do a query to a Waku Store to retrieve historical/missed messages.
-     *
      * The callback function takes a `Promise<WakuMessage>` in input,
-     * useful if messages needs to be decrypted and performance matters.
+     * useful if messages need to be decrypted and performance matters.
      *
      * The order of the messages passed to the callback is as follows:
      * - within a page, messages are expected to be ordered from oldest to most recent
@@ -6000,18 +5885,18 @@ class Store extends BaseProtocol {
      * or if an error is encountered when processing the reply,
      * or if two decoders with the same content topic are passed.
      */
-    async queryCallbackOnPromise(decoders, callback, options) {
+    async queryWithPromiseCallback(decoders, callback, options) {
         let abort = false;
-        let promises = [];
         for await (const page of this.queryGenerator(decoders, options)) {
-            const _promises = page.map(async (msg) => {
-                if (!abort) {
-                    abort = Boolean(await callback(msg));
-                }
+            const _promises = page.map(async (msgPromise) => {
+                if (abort)
+                    return;
+                abort = Boolean(await callback(msgPromise));
             });
-            promises = promises.concat(_promises);
+            await Promise.all(_promises);
+            if (abort)
+                break;
         }
-        await Promise.all(promises);
     }
     /**
      * Do a query to a Waku Store to retrieve historical/missed messages.
@@ -6023,9 +5908,6 @@ class Store extends BaseProtocol {
      * as follows:
      * - within a page, messages SHOULD be ordered from oldest to most recent
      * - pages direction depends on { @link QueryOptions.pageDirection }
-     *
-     * However, there is no way to guarantee the behavior of the remote node.
-     *
      * @throws If not able to reach a Waku Store peer to query,
      * or if an error is encountered when processing the reply,
      * or if two decoders with the same content topic are passed.
@@ -6048,14 +5930,14 @@ class Store extends BaseProtocol {
         const queryOpts = Object.assign({
             pubSubTopic: pubSubTopic,
             pageDirection: PageDirection.BACKWARD,
-            pageSize: DefaultPageSize,
+            pageSize: DefaultPageSize
         }, options, { contentTopics, startTime, endTime });
-        log$1("Querying history with the following options", {
-            ...options,
-            peerId: options?.peerId?.toString(),
-        });
-        const peer = await this.getPeer(options?.peerId);
-        for await (const messages of paginate(this.newStream.bind(this, peer), queryOpts, decodersAsMap, options?.cursor)) {
+        log$1("Querying history with the following options", options);
+        const peer = (await this.getPeers({
+            numPeers: this.NUM_PEERS_PROTOCOL,
+            maxBootstrapPeers: 1
+        }))[0];
+        for await (const messages of paginate(this.getStream.bind(this, peer), queryOpts, decodersAsMap, options?.cursor)) {
             yield messages;
         }
     }
@@ -6126,14 +6008,14 @@ async function createCursor(message, pubsubTopic = DefaultPubSubTopic) {
         !message.contentTopic) {
         throw new Error("Message is missing required fields");
     }
-    const contentTopicBytes = utf8ToBytes(message.contentTopic);
-    const digest = sha256(concat([contentTopicBytes, message.payload]));
+    const contentTopicBytes = utf8ToBytes$1(message.contentTopic);
+    const digest = sha256(concat$1([contentTopicBytes, message.payload]));
     const messageTime = BigInt(message.timestamp.getTime()) * BigInt(1000000);
     return {
         digest,
         pubsubTopic,
         senderTime: messageTime,
-        receiverTime: messageTime,
+        receiverTime: messageTime
     };
 }
 function wakuStore(init = {}) {
@@ -6467,4 +6349,4 @@ function getEnabledProtocols(waku) {
     return protocols;
 }
 
-export { ConnectionManager, DefaultPubSubTopic, DefaultUserAgent, KeepAliveManager, LightPushCodec, PageDirection, StoreCodec, 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 };
+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 };