@waku/core 0.0.34-c41b319.0 → 0.0.34-c43cec2.0

package/bundle/index.js

@@ -1,518 +1,8 @@
-import { v as version_0, a as allocUnsafe, b as alloc, e as encodingLength$1, c as encode$2, d as decode$4, M as MessagePush, F as FilterSubscribeRequest, f as FilterSubscribeResponse$1, P as PushRpc$1, g as PushResponse, S as StoreQueryRequest$1, h as StoreQueryResponse$1, t as toString$1, i as bases, j as fromString, u as utf8ToBytes, k as createEncoder, p as pubsubTopicToSingleShardInfo, l as bytesToUtf8, s as shardInfoToPubsubTopics, W as WakuMetadataRequest, m as pubsubTopicsToShardInfo, n as WakuMetadataResponse } from './version_0-ANFNAdFD.js';
-export { o as createDecoder } from './version_0-ANFNAdFD.js';
-import { c as coerce, e as equals$2, b as base36, a as base32, d as base58btc, L as Logger, P as ProtocolError, T as Tags, E as EPeersByDiscoveryEvents, f as EConnectionStateEvents } from './index-Db7LxDrL.js';
-import { B as BaseProtocol } from './base_protocol-CCK9RCtH.js';
-export { S as StreamManager } from './base_protocol-CCK9RCtH.js';
-
-/* eslint-disable */
-var encode_1 = encode$1;
-var MSB = 0x80, MSBALL = -128, INT = Math.pow(2, 31);
-/**
- * @param {number} num
- * @param {number[]} out
- * @param {number} offset
- */
-function encode$1(num, out, offset) {
-    out = out || [];
-    offset = offset || 0;
-    var oldOffset = offset;
-    while (num >= INT) {
-        out[offset++] = (num & 0xFF) | MSB;
-        num /= 128;
-    }
-    while (num & MSBALL) {
-        out[offset++] = (num & 0xFF) | MSB;
-        num >>>= 7;
-    }
-    out[offset] = num | 0;
-    // @ts-ignore
-    encode$1.bytes = offset - oldOffset + 1;
-    return out;
-}
-var decode$3 = read;
-var MSB$1 = 0x80, REST$1 = 0x7F;
-/**
- * @param {string | any[]} buf
- * @param {number} offset
- */
-function read(buf, offset) {
-    var res = 0, offset = offset || 0, shift = 0, counter = offset, b, l = buf.length;
-    do {
-        if (counter >= l) {
-            // @ts-ignore
-            read.bytes = 0;
-            throw new RangeError('Could not decode varint');
-        }
-        b = buf[counter++];
-        res += shift < 28
-            ? (b & REST$1) << shift
-            : (b & REST$1) * Math.pow(2, shift);
-        shift += 7;
-    } while (b >= MSB$1);
-    // @ts-ignore
-    read.bytes = counter - offset;
-    return res;
-}
-var N1 = Math.pow(2, 7);
-var N2 = Math.pow(2, 14);
-var N3 = Math.pow(2, 21);
-var N4 = Math.pow(2, 28);
-var N5 = Math.pow(2, 35);
-var N6 = Math.pow(2, 42);
-var N7 = Math.pow(2, 49);
-var N8 = Math.pow(2, 56);
-var N9 = Math.pow(2, 63);
-var length = function (/** @type {number} */ value) {
-    return (value < N1 ? 1
-        : value < N2 ? 2
-            : value < N3 ? 3
-                : value < N4 ? 4
-                    : value < N5 ? 5
-                        : value < N6 ? 6
-                            : value < N7 ? 7
-                                : value < N8 ? 8
-                                    : value < N9 ? 9
-                                        : 10);
-};
-var varint = {
-    encode: encode_1,
-    decode: decode$3,
-    encodingLength: length
-};
-var _brrp_varint = varint;
-
-function decode$2(data, offset = 0) {
-    const code = _brrp_varint.decode(data, offset);
-    return [code, _brrp_varint.decode.bytes];
-}
-function encodeTo(int, target, offset = 0) {
-    _brrp_varint.encode(int, target, offset);
-    return target;
-}
-function encodingLength(int) {
-    return _brrp_varint.encodingLength(int);
-}
-
-/**
- * Creates a multihash digest.
- */
-function create(code, digest) {
-    const size = digest.byteLength;
-    const sizeOffset = encodingLength(code);
-    const digestOffset = sizeOffset + encodingLength(size);
-    const bytes = new Uint8Array(digestOffset + size);
-    encodeTo(code, bytes, 0);
-    encodeTo(size, bytes, sizeOffset);
-    bytes.set(digest, digestOffset);
-    return new Digest(code, size, digest, bytes);
-}
-/**
- * Turns bytes representation of multihash digest into an instance.
- */
-function decode$1(multihash) {
-    const bytes = coerce(multihash);
-    const [code, sizeOffset] = decode$2(bytes);
-    const [size, digestOffset] = decode$2(bytes.subarray(sizeOffset));
-    const digest = bytes.subarray(sizeOffset + digestOffset);
-    if (digest.byteLength !== size) {
-        throw new Error('Incorrect length');
-    }
-    return new Digest(code, size, digest, bytes);
-}
-function equals$1(a, b) {
-    if (a === b) {
-        return true;
-    }
-    else {
-        const data = b;
-        return (a.code === data.code &&
-            a.size === data.size &&
-            data.bytes instanceof Uint8Array &&
-            equals$2(a.bytes, data.bytes));
-    }
-}
-/**
- * Represents a multihash digest which carries information about the
- * hashing algorithm and an actual hash digest.
- */
-class Digest {
-    code;
-    size;
-    digest;
-    bytes;
-    /**
-     * Creates a multihash digest.
-     */
-    constructor(code, size, digest, bytes) {
-        this.code = code;
-        this.size = size;
-        this.digest = digest;
-        this.bytes = bytes;
-    }
-}
-
-function format(link, base) {
-    const { bytes, version } = link;
-    switch (version) {
-        case 0:
-            return toStringV0(bytes, baseCache(link), base ?? base58btc.encoder);
-        default:
-            return toStringV1(bytes, baseCache(link), (base ?? base32.encoder));
-    }
-}
-const cache = new WeakMap();
-function baseCache(cid) {
-    const baseCache = cache.get(cid);
-    if (baseCache == null) {
-        const baseCache = new Map();
-        cache.set(cid, baseCache);
-        return baseCache;
-    }
-    return baseCache;
-}
-class CID {
-    code;
-    version;
-    multihash;
-    bytes;
-    '/';
-    /**
-     * @param version - Version of the CID
-     * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-     * @param multihash - (Multi)hash of the of the content.
-     */
-    constructor(version, code, multihash, bytes) {
-        this.code = code;
-        this.version = version;
-        this.multihash = multihash;
-        this.bytes = bytes;
-        // flag to serializers that this is a CID and
-        // should be treated specially
-        this['/'] = bytes;
-    }
-    /**
-     * Signalling `cid.asCID === cid` has been replaced with `cid['/'] === cid.bytes`
-     * please either use `CID.asCID(cid)` or switch to new signalling mechanism
-     *
-     * @deprecated
-     */
-    get asCID() {
-        return this;
-    }
-    // ArrayBufferView
-    get byteOffset() {
-        return this.bytes.byteOffset;
-    }
-    // ArrayBufferView
-    get byteLength() {
-        return this.bytes.byteLength;
-    }
-    toV0() {
-        switch (this.version) {
-            case 0: {
-                return this;
-            }
-            case 1: {
-                const { code, multihash } = this;
-                if (code !== DAG_PB_CODE) {
-                    throw new Error('Cannot convert a non dag-pb CID to CIDv0');
-                }
-                // sha2-256
-                if (multihash.code !== SHA_256_CODE) {
-                    throw new Error('Cannot convert non sha2-256 multihash CID to CIDv0');
-                }
-                return (CID.createV0(multihash));
-            }
-            default: {
-                throw Error(`Can not convert CID version ${this.version} to version 0. This is a bug please report`);
-            }
-        }
-    }
-    toV1() {
-        switch (this.version) {
-            case 0: {
-                const { code, digest } = this.multihash;
-                const multihash = create(code, digest);
-                return (CID.createV1(this.code, multihash));
-            }
-            case 1: {
-                return this;
-            }
-            default: {
-                throw Error(`Can not convert CID version ${this.version} to version 1. This is a bug please report`);
-            }
-        }
-    }
-    equals(other) {
-        return CID.equals(this, other);
-    }
-    static equals(self, other) {
-        const unknown = other;
-        return (unknown != null &&
-            self.code === unknown.code &&
-            self.version === unknown.version &&
-            equals$1(self.multihash, unknown.multihash));
-    }
-    toString(base) {
-        return format(this, base);
-    }
-    toJSON() {
-        return { '/': format(this) };
-    }
-    link() {
-        return this;
-    }
-    [Symbol.toStringTag] = 'CID';
-    // Legacy
-    [Symbol.for('nodejs.util.inspect.custom')]() {
-        return `CID(${this.toString()})`;
-    }
-    /**
-     * Takes any input `value` and returns a `CID` instance if it was
-     * a `CID` otherwise returns `null`. If `value` is instanceof `CID`
-     * it will return value back. If `value` is not instance of this CID
-     * class, but is compatible CID it will return new instance of this
-     * `CID` class. Otherwise returns null.
-     *
-     * This allows two different incompatible versions of CID library to
-     * co-exist and interop as long as binary interface is compatible.
-     */
-    static asCID(input) {
-        if (input == null) {
-            return null;
-        }
-        const value = input;
-        if (value instanceof CID) {
-            // If value is instance of CID then we're all set.
-            return value;
-        }
-        else if ((value['/'] != null && value['/'] === value.bytes) || value.asCID === value) {
-            // If value isn't instance of this CID class but `this.asCID === this` or
-            // `value['/'] === value.bytes` is true it is CID instance coming from a
-            // different implementation (diff version or duplicate). In that case we
-            // rebase it to this `CID` implementation so caller is guaranteed to get
-            // instance with expected API.
-            const { version, code, multihash, bytes } = value;
-            return new CID(version, code, multihash, bytes ?? encodeCID(version, code, multihash.bytes));
-        }
-        else if (value[cidSymbol] === true) {
-            // If value is a CID from older implementation that used to be tagged via
-            // symbol we still rebase it to the this `CID` implementation by
-            // delegating that to a constructor.
-            const { version, multihash, code } = value;
-            const digest = decode$1(multihash);
-            return CID.create(version, code, digest);
-        }
-        else {
-            // Otherwise value is not a CID (or an incompatible version of it) in
-            // which case we return `null`.
-            return null;
-        }
-    }
-    /**
-     * @param version - Version of the CID
-     * @param code - Code of the codec content is encoded in, see https://github.com/multiformats/multicodec/blob/master/table.csv
-     * @param digest - (Multi)hash of the of the content.
-     */
-    static create(version, code, digest) {
-        if (typeof code !== 'number') {
-            throw new Error('String codecs are no longer supported');
-        }
-        if (!(digest.bytes instanceof Uint8Array)) {
-            throw new Error('Invalid digest');
-        }
-        switch (version) {
-            case 0: {
-                if (code !== DAG_PB_CODE) {
-                    throw new Error(`Version 0 CID must use dag-pb (code: ${DAG_PB_CODE}) block encoding`);
-                }
-                else {
-                    return new CID(version, code, digest, digest.bytes);
-                }
-            }
-            case 1: {
-                const bytes = encodeCID(version, code, digest.bytes);
-                return new CID(version, code, digest, bytes);
-            }
-            default: {
-                throw new Error('Invalid version');
-            }
-        }
-    }
-    /**
-     * Simplified version of `create` for CIDv0.
-     */
-    static createV0(digest) {
-        return CID.create(0, DAG_PB_CODE, digest);
-    }
-    /**
-     * Simplified version of `create` for CIDv1.
-     *
-     * @param code - Content encoding format code.
-     * @param digest - Multihash of the content.
-     */
-    static createV1(code, digest) {
-        return CID.create(1, code, digest);
-    }
-    /**
-     * Decoded a CID from its binary representation. The byte array must contain
-     * only the CID with no additional bytes.
-     *
-     * An error will be thrown if the bytes provided do not contain a valid
-     * binary representation of a CID.
-     */
-    static decode(bytes) {
-        const [cid, remainder] = CID.decodeFirst(bytes);
-        if (remainder.length !== 0) {
-            throw new Error('Incorrect length');
-        }
-        return cid;
-    }
-    /**
-     * Decoded a CID from its binary representation at the beginning of a byte
-     * array.
-     *
-     * Returns an array with the first element containing the CID and the second
-     * element containing the remainder of the original byte array. The remainder
-     * will be a zero-length byte array if the provided bytes only contained a
-     * binary CID representation.
-     */
-    static decodeFirst(bytes) {
-        const specs = CID.inspectBytes(bytes);
-        const prefixSize = specs.size - specs.multihashSize;
-        const multihashBytes = coerce(bytes.subarray(prefixSize, prefixSize + specs.multihashSize));
-        if (multihashBytes.byteLength !== specs.multihashSize) {
-            throw new Error('Incorrect length');
-        }
-        const digestBytes = multihashBytes.subarray(specs.multihashSize - specs.digestSize);
-        const digest = new Digest(specs.multihashCode, specs.digestSize, digestBytes, multihashBytes);
-        const cid = specs.version === 0
-            ? CID.createV0(digest)
-            : CID.createV1(specs.codec, digest);
-        return [cid, bytes.subarray(specs.size)];
-    }
-    /**
-     * Inspect the initial bytes of a CID to determine its properties.
-     *
-     * Involves decoding up to 4 varints. Typically this will require only 4 to 6
-     * bytes but for larger multicodec code values and larger multihash digest
-     * lengths these varints can be quite large. It is recommended that at least
-     * 10 bytes be made available in the `initialBytes` argument for a complete
-     * inspection.
-     */
-    static inspectBytes(initialBytes) {
-        let offset = 0;
-        const next = () => {
-            const [i, length] = decode$2(initialBytes.subarray(offset));
-            offset += length;
-            return i;
-        };
-        let version = next();
-        let codec = DAG_PB_CODE;
-        if (version === 18) {
-            // CIDv0
-            version = 0;
-            offset = 0;
-        }
-        else {
-            codec = next();
-        }
-        if (version !== 0 && version !== 1) {
-            throw new RangeError(`Invalid CID version ${version}`);
-        }
-        const prefixSize = offset;
-        const multihashCode = next(); // multihash code
-        const digestSize = next(); // multihash length
-        const size = offset + digestSize;
-        const multihashSize = size - prefixSize;
-        return { version, codec, multihashCode, digestSize, multihashSize, size };
-    }
-    /**
-     * Takes cid in a string representation and creates an instance. If `base`
-     * decoder is not provided will use a default from the configuration. It will
-     * throw an error if encoding of the CID is not compatible with supplied (or
-     * a default decoder).
-     */
-    static parse(source, base) {
-        const [prefix, bytes] = parseCIDtoBytes(source, base);
-        const cid = CID.decode(bytes);
-        if (cid.version === 0 && source[0] !== 'Q') {
-            throw Error('Version 0 CID string must not include multibase prefix');
-        }
-        // Cache string representation to avoid computing it on `this.toString()`
-        baseCache(cid).set(prefix, source);
-        return cid;
-    }
-}
-function parseCIDtoBytes(source, base) {
-    switch (source[0]) {
-        // CIDv0 is parsed differently
-        case 'Q': {
-            const decoder = base ?? base58btc;
-            return [
-                base58btc.prefix,
-                decoder.decode(`${base58btc.prefix}${source}`)
-            ];
-        }
-        case base58btc.prefix: {
-            const decoder = base ?? base58btc;
-            return [base58btc.prefix, decoder.decode(source)];
-        }
-        case base32.prefix: {
-            const decoder = base ?? base32;
-            return [base32.prefix, decoder.decode(source)];
-        }
-        case base36.prefix: {
-            const decoder = base ?? base36;
-            return [base36.prefix, decoder.decode(source)];
-        }
-        default: {
-            if (base == null) {
-                throw Error('To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided');
-            }
-            return [source[0], base.decode(source)];
-        }
-    }
-}
-function toStringV0(bytes, cache, base) {
-    const { prefix } = base;
-    if (prefix !== base58btc.prefix) {
-        throw Error(`Cannot string encode V0 in ${base.name} encoding`);
-    }
-    const cid = cache.get(prefix);
-    if (cid == null) {
-        const cid = base.encode(bytes).slice(1);
-        cache.set(prefix, cid);
-        return cid;
-    }
-    else {
-        return cid;
-    }
-}
-function toStringV1(bytes, cache, base) {
-    const { prefix } = base;
-    const cid = cache.get(prefix);
-    if (cid == null) {
-        const cid = base.encode(bytes);
-        cache.set(prefix, cid);
-        return cid;
-    }
-    else {
-        return cid;
-    }
-}
-const DAG_PB_CODE = 0x70;
-const SHA_256_CODE = 0x12;
-function 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');
+import { v as version_0, a as allocUnsafe, b as alloc, e as encodingLength, c as encode$1, d as decode$1, M as MessagePush, F as FilterSubscribeRequest, f as FilterSubscribeResponse$1, P as PushRpc$1, g as PushResponse, S as StoreQueryRequest$1, h as StoreQueryResponse$1, u as utf8ToBytes, i as createEncoder, p as pubsubTopicToSingleShardInfo, j as bytesToUtf8, s as shardInfoToPubsubTopics, W as WakuMetadataRequest, k as pubsubTopicsToShardInfo, l as WakuMetadataResponse } from './version_0-Che4t3mN.js';
+export { m as createDecoder } from './version_0-Che4t3mN.js';
+import { L as Logger, P as ProtocolError, T as Tags, E as EPeersByDiscoveryEvents, a as EConnectionStateEvents, H as HealthStatus, b as Protocols } from './index-yLOEQnIE.js';
+import { B as BaseProtocol } from './base_protocol-DxFKDXX2.js';
+export { S as StreamManager } from './base_protocol-DxFKDXX2.js';
 
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
@@ -768,7 +258,7 @@ function equals(a, b) {
  *
  * Borrows liberally from [bl](https://www.npmjs.com/package/bl) but only uses native JS types.
  */
-const symbol$1 = Symbol.for('@achingbrain/uint8arraylist');
+const symbol = Symbol.for('@achingbrain/uint8arraylist');
 function findBufAndOffset(bufs, index) {
     if (index == null || index < 0) {
         throw new RangeError('index is out of bounds');
@@ -800,12 +290,12 @@ function findBufAndOffset(bufs, index) {
  * ```
  */
 function isUint8ArrayList(value) {
-    return Boolean(value?.[symbol$1]);
+    return Boolean(value?.[symbol]);
 }
 class Uint8ArrayList {
     bufs;
     length;
-    [symbol$1] = true;
+    [symbol] = true;
     constructor(...data) {
         this.bufs = [];
         this.length = 0;
@@ -1261,9 +751,9 @@ function isAsyncIterable$2(thing) {
 }
 
 const defaultEncoder = (length) => {
-    const lengthLength = encodingLength$1(length);
+    const lengthLength = encodingLength(length);
     const lengthBuf = allocUnsafe(lengthLength);
-    encode$2(length, lengthBuf);
+    encode$1(length, lengthBuf);
     defaultEncoder.bytes = lengthLength;
     return lengthBuf;
 };
@@ -1350,8 +840,8 @@ var ReadMode;
     ReadMode[ReadMode["DATA"] = 1] = "DATA";
 })(ReadMode || (ReadMode = {}));
 const defaultDecoder = (buf) => {
-    const length = decode$4(buf);
-    defaultDecoder.bytes = encodingLength$1(length);
+    const length = decode$1(buf);
+    defaultDecoder.bytes = encodingLength(length);
     return length;
 };
 defaultDecoder.bytes = 0;
@@ -2001,7 +1491,7 @@ var native = {
 };
 
 function v4(options, buf, offset) {
-  if (native.randomUUID && true && !options) {
+  if (native.randomUUID && !buf && !options) {
     return native.randomUUID();
   }
 
@@ -2141,8 +1631,8 @@ class FilterCore extends BaseProtocol {
             log$5.error("Failed to register ", FilterCodecs.PUSH, e);
         });
     }
-    async subscribe(pubsubTopic, peerId, contentTopics) {
-        const stream = await this.getStream(peerId);
+    async subscribe(pubsubTopic, peer, contentTopics) {
+        const stream = await this.getStream(peer);
         const request = FilterSubscribeRpc.createSubscribeRequest(pubsubTopic, contentTopics);
         let res;
         try {
@@ -2154,7 +1644,7 @@ class FilterCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.GENERIC_FAIL,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
@@ -2164,28 +1654,28 @@ class FilterCore extends BaseProtocol {
             return {
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
-                    peerId: peerId
+                    peerId: peer.id
                 },
                 success: null
             };
         }
         return {
             failure: null,
-            success: peerId
+            success: peer.id
         };
     }
-    async unsubscribe(pubsubTopic, peerId, contentTopics) {
+    async unsubscribe(pubsubTopic, peer, contentTopics) {
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.getStream(peer);
         }
         catch (error) {
-            log$5.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
+            log$5.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
             return {
                 success: null,
                 failure: {
                     error: ProtocolError.NO_STREAM_AVAILABLE,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
@@ -2199,24 +1689,24 @@ class FilterCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.GENERIC_FAIL,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
         return {
-            success: peerId,
+            success: peer.id,
             failure: null
         };
     }
-    async unsubscribeAll(pubsubTopic, peerId) {
-        const stream = await this.getStream(peerId);
+    async unsubscribeAll(pubsubTopic, peer) {
+        const stream = await this.getStream(peer);
         const request = FilterSubscribeRpc.createUnsubscribeAllRequest(pubsubTopic);
         const res = await pipe([request.encode()], encode, stream, decode, async (source) => await all(source));
         if (!res || !res.length) {
             return {
                 failure: {
                     error: ProtocolError.NO_RESPONSE,
-                    peerId: peerId
+                    peerId: peer.id
                 },
                 success: null
             };
@@ -2227,28 +1717,28 @@ class FilterCore extends BaseProtocol {
             return {
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
-                    peerId: peerId
+                    peerId: peer.id
                 },
                 success: null
             };
         }
         return {
             failure: null,
-            success: peerId
+            success: peer.id
         };
     }
-    async ping(peerId) {
+    async ping(peer) {
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.getStream(peer);
         }
         catch (error) {
-            log$5.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
+            log$5.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
             return {
                 success: null,
                 failure: {
                     error: ProtocolError.NO_STREAM_AVAILABLE,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
@@ -2263,7 +1753,7 @@ class FilterCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.GENERIC_FAIL,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
@@ -2272,7 +1762,7 @@ class FilterCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.NO_RESPONSE,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
@@ -2283,12 +1773,12 @@ class FilterCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
         return {
-            success: peerId,
+            success: peer.id,
             failure: null
         };
     }
@@ -2424,20 +1914,21 @@ class LightPushCore extends BaseProtocol {
             };
         }
     }
-    async send(encoder, message, peerId) {
+    // TODO(weboko): use peer.id as parameter instead
+    async send(encoder, message, peer) {
         const { query, error: preparationError } = await this.preparePushMessage(encoder, message);
         if (preparationError || !query) {
             return {
                 success: null,
                 failure: {
                     error: preparationError,
-                    peerId
+                    peerId: peer.id
                 }
             };
         }
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.getStream(peer);
         }
         catch (error) {
             log$4.error("Failed to get stream", error);
@@ -2445,7 +1936,7 @@ class LightPushCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.NO_STREAM_AVAILABLE,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
@@ -2459,7 +1950,7 @@ class LightPushCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.GENERIC_FAIL,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
@@ -2477,7 +1968,7 @@ class LightPushCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.DECODE_FAILED,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
@@ -2487,7 +1978,7 @@ class LightPushCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.NO_RESPONSE,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
@@ -2498,7 +1989,7 @@ class LightPushCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: rlnErrorCase,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
@@ -2508,11 +1999,11 @@ class LightPushCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
-                    peerId: peerId
+                    peerId: peer.id
                 }
             };
         }
-        return { success: peerId, failure: null };
+        return { success: peer.id, failure: null };
     }
 }
 
@@ -2616,7 +2107,7 @@ class StoreCore extends BaseProtocol {
         super(StoreCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
     }
-    async *queryPerPage(queryOpts, decoders, peerId) {
+    async *queryPerPage(queryOpts, decoders, peer) {
         if (queryOpts.contentTopics.toString() !==
             Array.from(decoders.keys()).toString()) {
             throw new Error("Internal error, the decoders should match the query's content topics");
@@ -2629,7 +2120,7 @@ class StoreCore extends BaseProtocol {
             });
             let stream;
             try {
-                stream = await this.getStream(peerId);
+                stream = await this.getStream(peer);
             }
             catch (e) {
                 log$3.error("Failed to get stream", e);
@@ -2689,18 +2180,6 @@ var index = /*#__PURE__*/Object.freeze({
     StoreCore: StoreCore
 });
 
-/**
- * All PeerId implementations must use this symbol as the name of a property
- * with a boolean `true` value
- */
-const peerIdSymbol = Symbol.for('@libp2p/peer-id');
-/**
- * Returns true if the passed argument is a PeerId implementation
- */
-function isPeerId(other) {
-    return Boolean(other?.[peerIdSymbol]);
-}
-
 /**
  * Noop for browser compatibility
  */
@@ -2773,1154 +2252,6 @@ class TypedEventEmitter extends EventTarget {
     }
 }
 
-/* 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, mapIPv4ToIPv6 = false) {
-    // strip zone index if it is present
-    if (input.includes("%")) {
-        input = input.split("%")[0];
-    }
-    if (input.length > MAX_IPV6_LENGTH) {
-        return undefined;
-    }
-    const addr = parser.new(input).parseWith(() => parser.readIPAddr());
-    if (!addr) {
-        return undefined;
-    }
-    if (mapIPv4ToIPv6 && addr.length === 4) {
-        return Uint8Array.from([0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xff, 0xff, addr[0], addr[1], addr[2], addr[3]]);
-    }
-    return addr;
-}
-
-/** 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;
-const isV6 = isIPv6;
-// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L7
-// but with buf/offset args removed because we don't use them
-const toBytes = function (ip) {
-    let offset = 0;
-    ip = ip.toString().trim();
-    if (isV4(ip)) {
-        const bytes = new Uint8Array(offset + 4);
-        ip.split(/\./g).forEach((byte) => {
-            bytes[offset++] = parseInt(byte, 10) & 0xff;
-        });
-        return bytes;
-    }
-    if (isV6(ip)) {
-        const sections = ip.split(':', 8);
-        let i;
-        for (i = 0; i < sections.length; i++) {
-            const isv4 = isV4(sections[i]);
-            let v4Buffer;
-            if (isv4) {
-                v4Buffer = toBytes(sections[i]);
-                sections[i] = toString$1(v4Buffer.slice(0, 2), 'base16');
-            }
-            if (v4Buffer != null && ++i < 8) {
-                sections.splice(i, 0, toString$1(v4Buffer.slice(2, 4), 'base16'));
-            }
-        }
-        if (sections[0] === '') {
-            while (sections.length < 8)
-                sections.unshift('0');
-        }
-        else if (sections[sections.length - 1] === '') {
-            while (sections.length < 8)
-                sections.push('0');
-        }
-        else if (sections.length < 8) {
-            for (i = 0; i < sections.length && sections[i] !== ''; i++)
-                ;
-            const argv = [i, 1];
-            for (i = 9 - sections.length; i > 0; i--) {
-                argv.push('0');
-            }
-            sections.splice.apply(sections, argv);
-        }
-        const bytes = new Uint8Array(offset + 16);
-        for (i = 0; i < sections.length; i++) {
-            const word = parseInt(sections[i], 16);
-            bytes[offset++] = (word >> 8) & 0xff;
-            bytes[offset++] = word & 0xff;
-        }
-        return bytes;
-    }
-    throw new Error('invalid ip address');
-};
-// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L63
-const toString = function (buf, offset = 0, length) {
-    offset = ~~offset;
-    length = length ?? (buf.length - offset);
-    const view = new DataView(buf.buffer);
-    if (length === 4) {
-        const result = [];
-        // IPv4
-        for (let i = 0; i < length; i++) {
-            result.push(buf[offset + i]);
-        }
-        return result.join('.');
-    }
-    if (length === 16) {
-        const result = [];
-        // IPv6
-        for (let i = 0; i < length; i += 2) {
-            result.push(view.getUint16(offset + i).toString(16));
-        }
-        return result.join(':')
-            .replace(/(^|:)0(:0)*:0(:|$)/, '$1::$3')
-            .replace(/:{3,4}/, '::');
-    }
-    return '';
-};
-
-const V = -1;
-const names = {};
-const codes = {};
-const table = [
-    [4, 32, 'ip4'],
-    [6, 16, 'tcp'],
-    [33, 16, 'dccp'],
-    [41, 128, 'ip6'],
-    [42, V, 'ip6zone'],
-    [43, 8, 'ipcidr'],
-    [53, V, 'dns', true],
-    [54, V, 'dns4', true],
-    [55, V, 'dns6', true],
-    [56, V, 'dnsaddr', true],
-    [132, 16, 'sctp'],
-    [273, 16, 'udp'],
-    [275, 0, 'p2p-webrtc-star'],
-    [276, 0, 'p2p-webrtc-direct'],
-    [277, 0, 'p2p-stardust'],
-    [280, 0, 'webrtc-direct'],
-    [281, 0, 'webrtc'],
-    [290, 0, 'p2p-circuit'],
-    [301, 0, 'udt'],
-    [302, 0, 'utp'],
-    [400, V, 'unix', false, true],
-    // `ipfs` is added before `p2p` for legacy support.
-    // All text representations will default to `p2p`, but `ipfs` will
-    // still be supported
-    [421, V, 'ipfs'],
-    // `p2p` is the preferred name for 421, and is now the default
-    [421, V, 'p2p'],
-    [443, 0, 'https'],
-    [444, 96, 'onion'],
-    [445, 296, 'onion3'],
-    [446, V, 'garlic64'],
-    [448, 0, 'tls'],
-    [449, V, 'sni'],
-    [460, 0, 'quic'],
-    [461, 0, 'quic-v1'],
-    [465, 0, 'webtransport'],
-    [466, V, 'certhash'],
-    [477, 0, 'ws'],
-    [478, 0, 'wss'],
-    [479, 0, 'p2p-websocket-star'],
-    [480, 0, 'http'],
-    [481, V, 'http-path'],
-    [777, V, 'memory']
-];
-// populate tables
-table.forEach(row => {
-    const proto = createProtocol(...row);
-    codes[proto.code] = proto;
-    names[proto.name] = proto;
-});
-function createProtocol(code, size, name, resolvable, path) {
-    return {
-        code,
-        size,
-        name,
-        resolvable: Boolean(resolvable),
-        path: Boolean(path)
-    };
-}
-/**
- * For the passed proto string or number, return a {@link Protocol}
- *
- * @example
- *
- * ```js
- * import { protocol } from '@multiformats/multiaddr'
- *
- * console.info(protocol(4))
- * // { code: 4, size: 32, name: 'ip4', resolvable: false, path: false }
- * ```
- */
-function getProtocol(proto) {
-    if (typeof proto === 'number') {
-        if (codes[proto] != null) {
-            return codes[proto];
-        }
-        throw new Error(`no protocol with code: ${proto}`);
-    }
-    else if (typeof proto === 'string') {
-        if (names[proto] != null) {
-            return names[proto];
-        }
-        throw new Error(`no protocol with name: ${proto}`);
-    }
-    throw new Error(`invalid protocol id type: ${typeof proto}`);
-}
-
-getProtocol('ip4');
-getProtocol('ip6');
-getProtocol('ipcidr');
-/**
- * Convert [code,Uint8Array] to string
- */
-// eslint-disable-next-line complexity
-function convertToString(proto, buf) {
-    const protocol = getProtocol(proto);
-    switch (protocol.code) {
-        case 4: // ipv4
-        case 41: // ipv6
-            return bytes2ip(buf);
-        case 42: // ipv6zone
-            return bytes2str(buf);
-        case 43: // ipcidr
-            return toString$1(buf, 'base10');
-        case 6: // tcp
-        case 273: // udp
-        case 33: // dccp
-        case 132: // sctp
-            return bytes2port(buf).toString();
-        case 53: // dns
-        case 54: // dns4
-        case 55: // dns6
-        case 56: // dnsaddr
-        case 400: // unix
-        case 449: // sni
-        case 777: // memory
-            return bytes2str(buf);
-        case 421: // ipfs
-            return bytes2mh(buf);
-        case 444: // onion
-            return bytes2onion(buf);
-        case 445: // onion3
-            return bytes2onion(buf);
-        case 466: // certhash
-            return bytes2mb(buf);
-        case 481: // http-path
-            return globalThis.encodeURIComponent(bytes2str(buf));
-        default:
-            return toString$1(buf, 'base16'); // no clue. convert to hex
-    }
-}
-// eslint-disable-next-line complexity
-function convertToBytes(proto, str) {
-    const protocol = getProtocol(proto);
-    switch (protocol.code) {
-        case 4: // ipv4
-            return ip2bytes(str);
-        case 41: // ipv6
-            return ip2bytes(str);
-        case 42: // ipv6zone
-            return str2bytes(str);
-        case 43: // ipcidr
-            return fromString(str, 'base10');
-        case 6: // tcp
-        case 273: // udp
-        case 33: // dccp
-        case 132: // sctp
-            return port2bytes(parseInt(str, 10));
-        case 53: // dns
-        case 54: // dns4
-        case 55: // dns6
-        case 56: // dnsaddr
-        case 400: // unix
-        case 449: // sni
-        case 777: // memory
-            return str2bytes(str);
-        case 421: // ipfs
-            return mh2bytes(str);
-        case 444: // onion
-            return onion2bytes(str);
-        case 445: // onion3
-            return onion32bytes(str);
-        case 466: // certhash
-            return mb2bytes(str);
-        case 481: // http-path
-            return str2bytes(globalThis.decodeURIComponent(str));
-        default:
-            return fromString(str, 'base16'); // no clue. convert from hex
-    }
-}
-const decoders = Object.values(bases).map((c) => c.decoder);
-const anybaseDecoder = (function () {
-    let acc = decoders[0].or(decoders[1]);
-    decoders.slice(2).forEach((d) => (acc = acc.or(d)));
-    return acc;
-})();
-function ip2bytes(ipString) {
-    if (!isIP(ipString)) {
-        throw new Error('invalid ip address');
-    }
-    return toBytes(ipString);
-}
-function bytes2ip(ipBuff) {
-    const ipString = toString(ipBuff, 0, ipBuff.length);
-    if (ipString == null) {
-        throw new Error('ipBuff is required');
-    }
-    if (!isIP(ipString)) {
-        throw new Error('invalid ip address');
-    }
-    return ipString;
-}
-function port2bytes(port) {
-    const buf = new ArrayBuffer(2);
-    const view = new DataView(buf);
-    view.setUint16(0, port);
-    return new Uint8Array(buf);
-}
-function bytes2port(buf) {
-    const view = new DataView(buf.buffer);
-    return view.getUint16(buf.byteOffset);
-}
-function str2bytes(str) {
-    const buf = fromString(str);
-    const size = Uint8Array.from(encode$2(buf.length));
-    return concat([size, buf], size.length + buf.length);
-}
-function bytes2str(buf) {
-    const size = decode$4(buf);
-    buf = buf.slice(encodingLength$1(size));
-    if (buf.length !== size) {
-        throw new Error('inconsistent lengths');
-    }
-    return toString$1(buf);
-}
-function mh2bytes(hash) {
-    let mh;
-    if (hash[0] === 'Q' || hash[0] === '1') {
-        mh = decode$1(base58btc.decode(`z${hash}`)).bytes;
-    }
-    else {
-        mh = CID.parse(hash).multihash.bytes;
-    }
-    // the address is a varint prefixed multihash string representation
-    const size = Uint8Array.from(encode$2(mh.length));
-    return concat([size, mh], size.length + mh.length);
-}
-function mb2bytes(mbstr) {
-    const mb = anybaseDecoder.decode(mbstr);
-    const size = Uint8Array.from(encode$2(mb.length));
-    return concat([size, mb], size.length + mb.length);
-}
-function bytes2mb(buf) {
-    const size = decode$4(buf);
-    const hash = buf.slice(encodingLength$1(size));
-    if (hash.length !== size) {
-        throw new Error('inconsistent lengths');
-    }
-    return 'u' + toString$1(hash, 'base64url');
-}
-/**
- * Converts bytes to bas58btc string
- */
-function bytes2mh(buf) {
-    const size = decode$4(buf);
-    const address = buf.slice(encodingLength$1(size));
-    if (address.length !== size) {
-        throw new Error('inconsistent lengths');
-    }
-    return toString$1(address, 'base58btc');
-}
-function onion2bytes(str) {
-    const addr = str.split(':');
-    if (addr.length !== 2) {
-        throw new Error(`failed to parse onion addr: ["'${addr.join('", "')}'"]' does not contain a port number`);
-    }
-    if (addr[0].length !== 16) {
-        throw new Error(`failed to parse onion addr: ${addr[0]} not a Tor onion address.`);
-    }
-    // onion addresses do not include the multibase prefix, add it before decoding
-    const buf = base32.decode('b' + addr[0]);
-    // onion port number
-    const port = parseInt(addr[1], 10);
-    if (port < 1 || port > 65536) {
-        throw new Error('Port number is not in range(1, 65536)');
-    }
-    const portBuf = port2bytes(port);
-    return concat([buf, portBuf], buf.length + portBuf.length);
-}
-function onion32bytes(str) {
-    const addr = str.split(':');
-    if (addr.length !== 2) {
-        throw new Error(`failed to parse onion addr: ["'${addr.join('", "')}'"]' does not contain a port number`);
-    }
-    if (addr[0].length !== 56) {
-        throw new Error(`failed to parse onion addr: ${addr[0]} not a Tor onion3 address.`);
-    }
-    // onion addresses do not include the multibase prefix, add it before decoding
-    const buf = base32.decode(`b${addr[0]}`);
-    // onion port number
-    const port = parseInt(addr[1], 10);
-    if (port < 1 || port > 65536) {
-        throw new Error('Port number is not in range(1, 65536)');
-    }
-    const portBuf = port2bytes(port);
-    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 port = bytes2port(portBytes);
-    return `${addr}:${port}`;
-}
-
-function stringToMultiaddrParts(str) {
-    str = cleanPath(str);
-    const tuples = [];
-    const stringTuples = [];
-    let path = null;
-    const parts = str.split('/').slice(1);
-    if (parts.length === 1 && parts[0] === '') {
-        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([proto.code]);
-            stringTuples.push([proto.code]);
-            // eslint-disable-next-line no-continue
-            continue;
-        }
-        p++; // advance addr part
-        if (p >= parts.length) {
-            throw ParseError('invalid address: ' + str);
-        }
-        // if it's a path proto, take the rest
-        if (proto.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 = 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 = decode$4(bytes, i);
-        const n = encodingLength$1(code);
-        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$1(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;
-        }
-    }
-    return {
-        bytes: Uint8Array.from(bytes),
-        string: stringTuplesToString(stringTuples),
-        tuples,
-        stringTuples,
-        path
-    };
-}
-/**
- * [[str name, str addr]... ] -> string
- */
-function stringTuplesToString(tuples) {
-    const parts = [];
-    tuples.map((tup) => {
-        const proto = getProtocol(tup[0]);
-        parts.push(proto.name);
-        if (tup.length > 1 && tup[1] != null) {
-            parts.push(tup[1]);
-        }
-        return null;
-    });
-    return cleanPath(parts.join('/'));
-}
-/**
- * [[int code, Uint8Array ]... ] -> Uint8Array
- */
-function tuplesToBytes(tuples) {
-    return concat(tuples.map((tup) => {
-        const proto = getProtocol(tup[0]);
-        let buf = Uint8Array.from(encode$2(proto.code));
-        if (tup.length > 1 && tup[1] != null) {
-            buf = concat([buf, tup[1]]); // add address buffer
-        }
-        return buf;
-    }));
-}
-/**
- * For the passed address, return the serialized size
- */
-function sizeForAddr(p, addr) {
-    if (p.size > 0) {
-        return p.size / 8;
-    }
-    else if (p.size === 0) {
-        return 0;
-    }
-    else {
-        const size = decode$4(addr instanceof Uint8Array ? addr : Uint8Array.from(addr));
-        return size + encodingLength$1(size);
-    }
-}
-function cleanPath(str) {
-    return '/' + str.trim().split('/').filter((a) => a).join('/');
-}
-function ParseError(str) {
-    return new Error('Error parsing address: ' + str);
-}
-
-const inspect = Symbol.for('nodejs.util.inspect.custom');
-const symbol = Symbol.for('@multiformats/js-multiaddr/multiaddr');
-const DNS_CODES = [
-    getProtocol('dns').code,
-    getProtocol('dns4').code,
-    getProtocol('dns6').code,
-    getProtocol('dnsaddr').code
-];
-class NoAvailableResolverError extends Error {
-    constructor(message = 'No available resolver') {
-        super(message);
-        this.name = 'NoAvailableResolverError';
-    }
-}
-/**
- * Creates a {@link Multiaddr} from a {@link MultiaddrInput}
- */
-class Multiaddr {
-    bytes;
-    #string;
-    #tuples;
-    #stringTuples;
-    #path;
-    [symbol] = true;
-    constructor(addr) {
-        // default
-        if (addr == null) {
-            addr = '';
-        }
-        let parts;
-        if (addr instanceof Uint8Array) {
-            parts = bytesToMultiaddrParts(addr);
-        }
-        else if (typeof addr === 'string') {
-            if (addr.length > 0 && addr.charAt(0) !== '/') {
-                throw new Error(`multiaddr "${addr}" must start with a "/"`);
-            }
-            parts = stringToMultiaddrParts(addr);
-        }
-        else if (isMultiaddr(addr)) { // Multiaddr
-            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() {
-        return this.#string;
-    }
-    toJSON() {
-        return this.toString();
-    }
-    toOptions() {
-        let family;
-        let transport;
-        let host;
-        let port;
-        let zone = '';
-        const tcp = getProtocol('tcp');
-        const udp = getProtocol('udp');
-        const ip4 = getProtocol('ip4');
-        const ip6 = getProtocol('ip6');
-        const dns6 = getProtocol('dns6');
-        const ip6zone = getProtocol('ip6zone');
-        for (const [code, value] of this.stringTuples()) {
-            if (code === ip6zone.code) {
-                zone = `%${value ?? ''}`;
-            }
-            // default to https when protocol & port are omitted from DNS addrs
-            if (DNS_CODES.includes(code)) {
-                transport = tcp.name;
-                port = 443;
-                host = `${value ?? ''}${zone}`;
-                family = code === dns6.code ? 6 : 4;
-            }
-            if (code === tcp.code || code === udp.code) {
-                transport = getProtocol(code).name;
-                port = parseInt(value ?? '');
-            }
-            if (code === ip4.code || code === ip6.code) {
-                transport = getProtocol(code).name;
-                host = `${value ?? ''}${zone}`;
-                family = code === ip6.code ? 6 : 4;
-            }
-        }
-        if (family == null || transport == null || host == null || port == null) {
-            throw new Error('multiaddr must have a valid format: "/{ip4, ip6, dns4, dns6, dnsaddr}/{address}/{tcp, udp}/{port}".');
-        }
-        const opts = {
-            family,
-            host,
-            transport,
-            port
-        };
-        return opts;
-    }
-    protos() {
-        return this.#tuples.map(([code]) => Object.assign({}, getProtocol(code)));
-    }
-    protoCodes() {
-        return this.#tuples.map(([code]) => code);
-    }
-    protoNames() {
-        return this.#tuples.map(([code]) => getProtocol(code).name);
-    }
-    tuples() {
-        return this.#tuples.map(([code, value]) => {
-            if (value == null) {
-                return [code];
-            }
-            return [code, value];
-        });
-    }
-    stringTuples() {
-        return this.#stringTuples.map(([code, value]) => {
-            if (value == null) {
-                return [code];
-            }
-            return [code, value];
-        });
-    }
-    encapsulate(addr) {
-        addr = new Multiaddr(addr);
-        return new Multiaddr(this.toString() + addr.toString());
-    }
-    decapsulate(addr) {
-        const addrString = addr.toString();
-        const s = this.toString();
-        const i = s.lastIndexOf(addrString);
-        if (i < 0) {
-            throw new Error(`Address ${this.toString()} does not contain subaddress: ${addr.toString()}`);
-        }
-        return new Multiaddr(s.slice(0, i));
-    }
-    decapsulateCode(code) {
-        const tuples = this.tuples();
-        for (let i = tuples.length - 1; i >= 0; i--) {
-            if (tuples[i][0] === code) {
-                return new Multiaddr(tuplesToBytes(tuples.slice(0, i)));
-            }
-        }
-        return this;
-    }
-    getPeerId() {
-        try {
-            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 = [];
-                }
-            });
-            // 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');
-                }
-                // try to parse peer id as CID
-                return toString$1(CID.parse(peerIdStr).multihash.bytes, 'base58btc');
-            }
-            return null;
-        }
-        catch (e) {
-            return null;
-        }
-    }
-    getPath() {
-        return this.#path;
-    }
-    equals(addr) {
-        return equals(this.bytes, addr.bytes);
-    }
-    async resolve(options) {
-        const resolvableProto = this.protos().find((p) => p.resolvable);
-        // Multiaddr is not resolvable?
-        if (resolvableProto == null) {
-            return [this];
-        }
-        const resolver = resolvers.get(resolvableProto.name);
-        if (resolver == null) {
-            throw new NoAvailableResolverError(`no available resolver for ${resolvableProto.name}`);
-        }
-        const result = await resolver(this, options);
-        return result.map(str => multiaddr(str));
-    }
-    nodeAddress() {
-        const options = this.toOptions();
-        if (options.transport !== 'tcp' && options.transport !== 'udp') {
-            throw new Error(`multiaddr must have a valid format - no protocol with name: "${options.transport}". Must have a valid transport protocol: "{tcp, udp}"`);
-        }
-        return {
-            family: options.family,
-            address: options.host,
-            port: options.port
-        };
-    }
-    isThinWaistAddress(addr) {
-        const protos = (addr ?? this).protos();
-        if (protos.length !== 2) {
-            return false;
-        }
-        if (protos[0].code !== 4 && protos[0].code !== 41) {
-            return false;
-        }
-        if (protos[1].code !== 6 && protos[1].code !== 273) {
-            return false;
-        }
-        return true;
-    }
-    /**
-     * Returns Multiaddr as a human-readable string
-     * https://nodejs.org/api/util.html#utilinspectcustom
-     *
-     * @example
-     * ```js
-     * import { multiaddr } from '@multiformats/multiaddr'
-     *
-     * console.info(multiaddr('/ip4/127.0.0.1/tcp/4001'))
-     * // 'Multiaddr(/ip4/127.0.0.1/tcp/4001)'
-     * ```
-     */
-    [inspect]() {
-        return `Multiaddr(${this.#string})`;
-    }
-}
-
-/**
- * @packageDocumentation
- *
- * A standard way to represent addresses that
- *
- * - support any standard network protocol
- * - are self-describing
- * - have a binary packed format
- * - have a nice string representation
- * - encapsulate well
- *
- * @example
- *
- * ```TypeScript
- * import { multiaddr } from '@multiformats/multiaddr'
- *
- * const addr = multiaddr('/ip4/127.0.0.1/udp/1234')
- * // Multiaddr(/ip4/127.0.0.1/udp/1234)
- *
- * addr.bytes
- * // <Uint8Array 04 7f 00 00 01 11 04 d2>
- *
- * addr.toString()
- * // '/ip4/127.0.0.1/udp/1234'
- *
- * addr.protos()
- * // [
- * //   {code: 4, name: 'ip4', size: 32},
- * //   {code: 273, name: 'udp', size: 16}
- * // ]
- *
- * // gives you an object that is friendly with what Node.js core modules expect for addresses
- * addr.nodeAddress()
- * // {
- * //   family: 4,
- * //   port: 1234,
- * //   address: "127.0.0.1"
- * // }
- *
- * addr.encapsulate('/sctp/5678')
- * // Multiaddr(/ip4/127.0.0.1/udp/1234/sctp/5678)
- * ```
- *
- * ## Resolving DNSADDR addresses
- *
- * [DNSADDR](https://github.com/multiformats/multiaddr/blob/master/protocols/DNSADDR.md) is a spec that allows storing a TXT DNS record that contains a Multiaddr.
- *
- * To resolve DNSADDR addresses, call the `.resolve()` function the multiaddr, optionally passing a `DNS` resolver.
- *
- * DNSADDR addresses can resolve to multiple multiaddrs, since there is no limit to the number of TXT records that can be stored.
- *
- * @example Resolving DNSADDR Multiaddrs
- *
- * ```TypeScript
- * import { multiaddr, resolvers } from '@multiformats/multiaddr'
- * import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
- *
- * resolvers.set('dnsaddr', dnsaddrResolver)
- *
- * const ma = multiaddr('/dnsaddr/bootstrap.libp2p.io')
- *
- * // resolve with a 5s timeout
- * const resolved = await ma.resolve({
- *   signal: AbortSignal.timeout(5000)
- * })
- *
- * console.info(resolved)
- * // [Multiaddr('/ip4/147.75...'), Multiaddr('/ip4/147.75...'), Multiaddr('/ip4/147.75...')...]
- * ```
- *
- * @example Using a custom DNS resolver to resolve DNSADDR Multiaddrs
- *
- * See the docs for [@multiformats/dns](https://www.npmjs.com/package/@multiformats/dns) for a full breakdown of how to specify multiple resolvers or resolvers that can be used for specific TLDs.
- *
- * ```TypeScript
- * import { multiaddr } from '@multiformats/multiaddr'
- * import { dns } from '@multiformats/dns'
- * import { dnsJsonOverHttps } from '@multiformats/dns/resolvers'
- *
- * const resolver = dns({
- *   resolvers: {
- *     '.': dnsJsonOverHttps('https://cloudflare-dns.com/dns-query')
- *   }
- * })
- *
- * const ma = multiaddr('/dnsaddr/bootstrap.libp2p.io')
- * const resolved = await ma.resolve({
- *  dns: resolver
- * })
- *
- * console.info(resolved)
- * // [Multiaddr('/ip4/147.75...'), Multiaddr('/ip4/147.75...'), Multiaddr('/ip4/147.75...')...]
- * ```
- */
-/**
- * All configured {@link Resolver}s
- */
-const resolvers = new Map();
-/**
- * Check if object is a {@link Multiaddr} instance
- *
- * @example
- *
- * ```js
- * import { isMultiaddr, multiaddr } from '@multiformats/multiaddr'
- *
- * isMultiaddr(5)
- * // false
- * isMultiaddr(multiaddr('/ip4/127.0.0.1'))
- * // true
- * ```
- */
-function isMultiaddr(value) {
-    return Boolean(value?.[symbol]);
-}
-/**
- * A function that takes a {@link MultiaddrInput} and returns a {@link Multiaddr}
- *
- * @example
- * ```js
- * import { multiaddr } from '@libp2p/multiaddr'
- *
- * multiaddr('/ip4/127.0.0.1/tcp/4001')
- * // Multiaddr(/ip4/127.0.0.1/tcp/4001)
- * ```
- *
- * @param {MultiaddrInput} [addr] - If String or Uint8Array, needs to adhere to the address format of a [multiaddr](https://github.com/multiformats/multiaddr#string-format)
- */
-function multiaddr(addr) {
-    return new Multiaddr(addr);
-}
-
 const RelayPingContentTopic = "/relay-ping/1/ping/null";
 const log$2 = new Logger("keep-alive");
 class KeepAliveManager {
@@ -4207,59 +2538,13 @@ class ConnectionManager extends TypedEventEmitter {
         this.startPeerDisconnectionListener();
         this.startNetworkStatusListener();
     }
-    /**
-     * Attempts to establish a connection with a peer and set up specified protocols.
-     * The method handles both PeerId and Multiaddr inputs, manages connection attempts,
-     * and maintains the connection state.
-     *
-     * The dialing process includes:
-     * 1. Converting input to dialable peer info
-     * 2. Managing parallel dial attempts
-     * 3. Attempting to establish protocol-specific connections
-     * 4. Handling connection failures and retries
-     * 5. Updating the peer store and connection state
-     *
-     * @param {PeerId | MultiaddrInput} peer - The peer to connect to, either as a PeerId or multiaddr
-     * @param {string[]} [protocolCodecs] - Optional array of protocol-specific codec strings to establish
-     *                                      (e.g., for LightPush, Filter, Store protocols)
-     *
-     * @throws {Error} If the multiaddr is missing a peer ID
-     * @throws {Error} If the maximum dial attempts are reached and the peer cannot be dialed
-     * @throws {Error} If there's an error deleting an undialable peer from the peer store
-     *
-     * @example
-     * ```typescript
-     * // Dial using PeerId
-     * await connectionManager.dialPeer(peerId);
-     *
-     * // Dial using multiaddr with specific protocols
-     * await connectionManager.dialPeer(multiaddr, [
-     *   "/vac/waku/relay/2.0.0",
-     *   "/vac/waku/lightpush/2.0.0-beta1"
-     * ]);
-     * ```
-     *
-     * @remarks
-     * - The method implements exponential backoff through multiple dial attempts
-     * - Maintains a queue for parallel dial attempts (limited by maxParallelDials)
-     * - Integrates with the KeepAliveManager for connection maintenance
-     * - Updates the peer store and connection state after successful/failed attempts
-     * - If all dial attempts fail, triggers DNS discovery as a fallback
-     */
-    async dialPeer(peer) {
-        let connection;
-        let peerId;
-        const peerDialInfo = this.getDialablePeerInfo(peer);
-        const peerIdStr = isPeerId(peerDialInfo)
-            ? peerDialInfo.toString()
-            : peerDialInfo.getPeerId();
+    async dialPeer(peerId) {
         this.currentActiveParallelDialCount += 1;
         let dialAttempt = 0;
         while (dialAttempt < this.options.maxDialAttemptsForPeer) {
             try {
-                log$1.info(`Dialing peer ${peerDialInfo} on attempt ${dialAttempt + 1}`);
-                connection = await this.libp2p.dial(peerDialInfo);
-                peerId = connection.remotePeer;
+                log$1.info(`Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`);
+                await this.libp2p.dial(peerId);
                 const tags = await this.getTagNamesForPeer(peerId);
                 // add tag to connection describing discovery mechanism
                 // don't add duplicate tags
@@ -4276,15 +2561,15 @@ class ConnectionManager extends TypedEventEmitter {
             catch (error) {
                 if (error instanceof AggregateError) {
                     // Handle AggregateError
-                    log$1.error(`Error dialing peer ${peerIdStr} - ${error.errors}`);
+                    log$1.error(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
                 }
                 else {
                     // Handle generic error
-                    log$1.error(`Error dialing peer ${peerIdStr} - ${error.message}`);
+                    log$1.error(`Error dialing peer ${peerId.toString()} - ${error.message}`);
                 }
-                this.dialErrorsForPeer.set(peerIdStr, error);
+                this.dialErrorsForPeer.set(peerId.toString(), error);
                 dialAttempt++;
-                this.dialAttemptsForPeer.set(peerIdStr, dialAttempt);
+                this.dialAttemptsForPeer.set(peerId.toString(), dialAttempt);
             }
         }
         // Always decrease the active dial count and process the dial queue
@@ -4293,7 +2578,7 @@ class ConnectionManager extends TypedEventEmitter {
         // If max dial attempts reached and dialing failed, delete the peer
         if (dialAttempt === this.options.maxDialAttemptsForPeer) {
             try {
-                const error = this.dialErrorsForPeer.get(peerIdStr);
+                const error = this.dialErrorsForPeer.get(peerId.toString());
                 if (error) {
                     let errorMessage;
                     if (error instanceof AggregateError) {
@@ -4310,52 +2595,16 @@ class ConnectionManager extends TypedEventEmitter {
                     else {
                         errorMessage = error.message;
                     }
-                    log$1.info(`Deleting undialable peer ${peerIdStr} from peer store. Reason: ${errorMessage}`);
-                }
-                this.dialErrorsForPeer.delete(peerIdStr);
-                if (peerId) {
-                    await this.libp2p.peerStore.delete(peerId);
+                    log$1.info(`Deleting undialable peer ${peerId.toString()} from peer store. Reason: ${errorMessage}`);
                 }
+                this.dialErrorsForPeer.delete(peerId.toString());
+                await this.libp2p.peerStore.delete(peerId);
                 // if it was last available peer - attempt DNS discovery
                 await this.attemptDnsDiscovery();
             }
             catch (error) {
-                throw new Error(`Error deleting undialable peer ${peerIdStr} from peer store - ${error}`);
-            }
-        }
-        if (!connection) {
-            throw new Error(`Failed to dial peer ${peerDialInfo}`);
-        }
-        return connection;
-    }
-    /**
-     * Dial a peer with specific protocols.
-     * This method is a raw proxy to the libp2p dialProtocol method.
-     * @param peer - The peer to connect to, either as a PeerId or multiaddr
-     * @param protocolCodecs - Optional array of protocol-specific codec strings to establish
-     * @returns A stream to the peer
-     */
-    async rawDialPeerWithProtocols(peer, protocolCodecs) {
-        const peerDialInfo = this.getDialablePeerInfo(peer);
-        return await this.libp2p.dialProtocol(peerDialInfo, protocolCodecs);
-    }
-    /**
-     * Internal utility to extract a PeerId or Multiaddr from a peer input.
-     * This is used internally by the connection manager to handle different peer input formats.
-     * @internal
-     */
-    getDialablePeerInfo(peer) {
-        if (isPeerId(peer)) {
-            return peer;
-        }
-        else {
-            // peer is of MultiaddrInput type
-            const ma = multiaddr(peer);
-            const peerIdStr = ma.getPeerId();
-            if (!peerIdStr) {
-                throw new Error("Failed to dial multiaddr: missing peer ID");
+                throw new Error(`Error deleting undialable peer ${peerId.toString()} from peer store - ${error}`);
             }
-            return ma;
         }
     }
     async attemptDnsDiscovery() {
@@ -4592,6 +2841,75 @@ class ConnectionManager extends TypedEventEmitter {
     }
 }
 
+class HealthManager {
+    static instance;
+    health;
+    constructor() {
+        this.health = {
+            overallStatus: HealthStatus.Unhealthy,
+            protocolStatuses: new Map()
+        };
+    }
+    static getInstance() {
+        if (!HealthManager.instance) {
+            HealthManager.instance = new HealthManager();
+        }
+        return HealthManager.instance;
+    }
+    getHealthStatus() {
+        return this.health.overallStatus;
+    }
+    getProtocolStatus(protocol) {
+        return this.health.protocolStatuses.get(protocol);
+    }
+    updateProtocolHealth(multicodec, connectedPeers) {
+        const protocol = this.getNameFromMulticodec(multicodec);
+        let status = HealthStatus.Unhealthy;
+        if (connectedPeers == 1) {
+            status = HealthStatus.MinimallyHealthy;
+        }
+        else if (connectedPeers >= 2) {
+            status = HealthStatus.SufficientlyHealthy;
+        }
+        this.health.protocolStatuses.set(protocol, {
+            name: protocol,
+            status: status,
+            lastUpdate: new Date()
+        });
+        this.updateOverallHealth();
+    }
+    getNameFromMulticodec(multicodec) {
+        let name;
+        if (multicodec.includes("filter")) {
+            name = Protocols.Filter;
+        }
+        else if (multicodec.includes("lightpush")) {
+            name = Protocols.LightPush;
+        }
+        else if (multicodec.includes("store")) {
+            name = Protocols.Store;
+        }
+        else {
+            throw new Error(`Unknown protocol: ${multicodec}`);
+        }
+        return name;
+    }
+    updateOverallHealth() {
+        const relevantProtocols = [Protocols.LightPush, Protocols.Filter];
+        const statuses = relevantProtocols.map((p) => this.getProtocolStatus(p)?.status);
+        if (statuses.some((status) => status === HealthStatus.Unhealthy)) {
+            this.health.overallStatus = HealthStatus.Unhealthy;
+        }
+        else if (statuses.some((status) => status === HealthStatus.MinimallyHealthy)) {
+            this.health.overallStatus = HealthStatus.MinimallyHealthy;
+        }
+        else {
+            this.health.overallStatus = HealthStatus.SufficientlyHealthy;
+        }
+    }
+}
+const getHealthManager = () => HealthManager.getInstance();
+
 const log = new Logger("metadata");
 const MetadataCodec = "/vac/waku/metadata/1.0.0";
 class Metadata extends BaseProtocol {
@@ -4620,7 +2938,7 @@ class Metadata extends BaseProtocol {
         }
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.getStream(peer);
         }
         catch (error) {
             log.error("Failed to get stream", error);
@@ -4703,4 +3021,4 @@ function wakuMetadata(pubsubTopics) {
     return (components) => new Metadata(pubsubTopics, components);
 }
 
-export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, createEncoder, index$3 as message, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };
+export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, createEncoder, getHealthManager, index$3 as message, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };