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

package/bundle/index.js

@@ -1,8 +1,518 @@
-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';
+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-DJZG2fB2.js';
+export { o as createDecoder } from './version_0-DJZG2fB2.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-G1eRBjeI.js';
+import { B as BaseProtocol } from './base_protocol-Bp5a9PNG.js';
+export { S as StreamManager } from './base_protocol-Bp5a9PNG.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');
 
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
@@ -258,7 +768,7 @@ function equals(a, b) {
  *
  * Borrows liberally from [bl](https://www.npmjs.com/package/bl) but only uses native JS types.
  */
-const symbol = Symbol.for('@achingbrain/uint8arraylist');
+const symbol$1 = Symbol.for('@achingbrain/uint8arraylist');
 function findBufAndOffset(bufs, index) {
     if (index == null || index < 0) {
         throw new RangeError('index is out of bounds');
@@ -290,12 +800,12 @@ function findBufAndOffset(bufs, index) {
  * ```
  */
 function isUint8ArrayList(value) {
-    return Boolean(value?.[symbol]);
+    return Boolean(value?.[symbol$1]);
 }
 class Uint8ArrayList {
     bufs;
     length;
-    [symbol] = true;
+    [symbol$1] = true;
     constructor(...data) {
         this.bufs = [];
         this.length = 0;
@@ -751,9 +1261,9 @@ function isAsyncIterable$2(thing) {
 }
 
 const defaultEncoder = (length) => {
-    const lengthLength = encodingLength(length);
+    const lengthLength = encodingLength$1(length);
     const lengthBuf = allocUnsafe(lengthLength);
-    encode$1(length, lengthBuf);
+    encode$2(length, lengthBuf);
     defaultEncoder.bytes = lengthLength;
     return lengthBuf;
 };
@@ -840,8 +1350,8 @@ var ReadMode;
     ReadMode[ReadMode["DATA"] = 1] = "DATA";
 })(ReadMode || (ReadMode = {}));
 const defaultDecoder = (buf) => {
-    const length = decode$1(buf);
-    defaultDecoder.bytes = encodingLength(length);
+    const length = decode$4(buf);
+    defaultDecoder.bytes = encodingLength$1(length);
     return length;
 };
 defaultDecoder.bytes = 0;
@@ -1491,7 +2001,7 @@ var native = {
 };
 
 function v4(options, buf, offset) {
-  if (native.randomUUID && !buf && !options) {
+  if (native.randomUUID && true && !options) {
     return native.randomUUID();
   }
 
@@ -1631,8 +2141,8 @@ class FilterCore extends BaseProtocol {
             log$5.error("Failed to register ", FilterCodecs.PUSH, e);
         });
     }
-    async subscribe(pubsubTopic, peer, contentTopics) {
-        const stream = await this.getStream(peer);
+    async subscribe(pubsubTopic, peerId, contentTopics) {
+        const stream = await this.getStream(peerId);
         const request = FilterSubscribeRpc.createSubscribeRequest(pubsubTopic, contentTopics);
         let res;
         try {
@@ -1644,7 +2154,7 @@ class FilterCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.GENERIC_FAIL,
-                    peerId: peer.id
+                    peerId: peerId
                 }
             };
         }
@@ -1654,28 +2164,28 @@ class FilterCore extends BaseProtocol {
             return {
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
-                    peerId: peer.id
+                    peerId: peerId
                 },
                 success: null
             };
         }
         return {
             failure: null,
-            success: peer.id
+            success: peerId
         };
     }
-    async unsubscribe(pubsubTopic, peer, contentTopics) {
+    async unsubscribe(pubsubTopic, peerId, contentTopics) {
         let stream;
         try {
-            stream = await this.getStream(peer);
+            stream = await this.getStream(peerId);
         }
         catch (error) {
-            log$5.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
+            log$5.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
             return {
                 success: null,
                 failure: {
                     error: ProtocolError.NO_STREAM_AVAILABLE,
-                    peerId: peer.id
+                    peerId: peerId
                 }
             };
         }
@@ -1689,24 +2199,24 @@ class FilterCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.GENERIC_FAIL,
-                    peerId: peer.id
+                    peerId: peerId
                 }
             };
         }
         return {
-            success: peer.id,
+            success: peerId,
             failure: null
         };
     }
-    async unsubscribeAll(pubsubTopic, peer) {
-        const stream = await this.getStream(peer);
+    async unsubscribeAll(pubsubTopic, peerId) {
+        const stream = await this.getStream(peerId);
         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: peer.id
+                    peerId: peerId
                 },
                 success: null
             };
@@ -1717,28 +2227,28 @@ class FilterCore extends BaseProtocol {
             return {
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
-                    peerId: peer.id
+                    peerId: peerId
                 },
                 success: null
             };
         }
         return {
             failure: null,
-            success: peer.id
+            success: peerId
         };
     }
-    async ping(peer) {
+    async ping(peerId) {
         let stream;
         try {
-            stream = await this.getStream(peer);
+            stream = await this.getStream(peerId);
         }
         catch (error) {
-            log$5.error(`Failed to get a stream for remote peer${peer.id.toString()}`, error);
+            log$5.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
             return {
                 success: null,
                 failure: {
                     error: ProtocolError.NO_STREAM_AVAILABLE,
-                    peerId: peer.id
+                    peerId: peerId
                 }
             };
         }
@@ -1753,7 +2263,7 @@ class FilterCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.GENERIC_FAIL,
-                    peerId: peer.id
+                    peerId: peerId
                 }
             };
         }
@@ -1762,7 +2272,7 @@ class FilterCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.NO_RESPONSE,
-                    peerId: peer.id
+                    peerId: peerId
                 }
             };
         }
@@ -1773,12 +2283,12 @@ class FilterCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
-                    peerId: peer.id
+                    peerId: peerId
                 }
             };
         }
         return {
-            success: peer.id,
+            success: peerId,
             failure: null
         };
     }
@@ -1852,26 +2362,19 @@ class PushRpc {
 // should match nwaku
 // https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/waku/waku_rln_relay/rln_relay.nim#L309
 // https://github.com/waku-org/nwaku/blob/c3cb06ac6c03f0f382d3941ea53b330f6a8dd127/tests/waku_rln_relay/rln/waku_rln_relay_utils.nim#L20
-const RLN_GENERATION_PREFIX_ERROR = "could not generate rln-v2 proof";
+const RLN_GENERATION_PREFIX_ERROR = "could not generate rln proof";
+const RLN_MESSAGE_ID_PREFIX_ERROR = "could not get new message id to generate an rln proof";
+// rare case on nwaku side
+// https://github.com/waku-org/nwaku/blob/a4e92a3d02448fd708857b7b6cac2a7faa7eb4f9/waku/waku_lightpush/callbacks.nim#L49
+// https://github.com/waku-org/nwaku/blob/a4e92a3d02448fd708857b7b6cac2a7faa7eb4f9/waku/node/waku_node.nim#L1117
+const RLN_REMOTE_VALIDATION = "RLN validation failed";
 const isRLNResponseError = (info) => {
     if (!info) {
         return false;
     }
-    return info.includes(RLN_GENERATION_PREFIX_ERROR);
-};
-const matchRLNErrorMessage = (info) => {
-    const rlnErrorMap = {
-        [ProtocolError.RLN_IDENTITY_MISSING]: ProtocolError.RLN_IDENTITY_MISSING,
-        [ProtocolError.RLN_MEMBERSHIP_INDEX]: ProtocolError.RLN_MEMBERSHIP_INDEX,
-        [ProtocolError.RLN_LIMIT_MISSING]: ProtocolError.RLN_LIMIT_MISSING
-    };
-    const infoLowerCase = info.toLowerCase();
-    for (const errorKey in rlnErrorMap) {
-        if (infoLowerCase.includes(errorKey.toLowerCase())) {
-            return rlnErrorMap[errorKey];
-        }
-    }
-    return ProtocolError.RLN_PROOF_GENERATION;
+    return (info.includes(RLN_GENERATION_PREFIX_ERROR) ||
+        info.includes(RLN_MESSAGE_ID_PREFIX_ERROR) ||
+        info.includes(RLN_REMOTE_VALIDATION));
 };
 
 const log$4 = new Logger("light-push");
@@ -1914,21 +2417,20 @@ class LightPushCore extends BaseProtocol {
             };
         }
     }
-    // TODO(weboko): use peer.id as parameter instead
-    async send(encoder, message, peer) {
+    async send(encoder, message, peerId) {
         const { query, error: preparationError } = await this.preparePushMessage(encoder, message);
         if (preparationError || !query) {
             return {
                 success: null,
                 failure: {
                     error: preparationError,
-                    peerId: peer.id
+                    peerId
                 }
             };
         }
         let stream;
         try {
-            stream = await this.getStream(peer);
+            stream = await this.getStream(peerId);
         }
         catch (error) {
             log$4.error("Failed to get stream", error);
@@ -1936,7 +2438,7 @@ class LightPushCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.NO_STREAM_AVAILABLE,
-                    peerId: peer.id
+                    peerId: peerId
                 }
             };
         }
@@ -1945,12 +2447,13 @@ class LightPushCore extends BaseProtocol {
             res = await pipe([query.encode()], encode, stream, decode, async (source) => await all(source));
         }
         catch (err) {
+            // can fail only because of `stream` abortion
             log$4.error("Failed to send waku light push request", err);
             return {
                 success: null,
                 failure: {
-                    error: ProtocolError.GENERIC_FAIL,
-                    peerId: peer.id
+                    error: ProtocolError.STREAM_ABORTED,
+                    peerId: peerId
                 }
             };
         }
@@ -1968,7 +2471,7 @@ class LightPushCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.DECODE_FAILED,
-                    peerId: peer.id
+                    peerId: peerId
                 }
             };
         }
@@ -1978,18 +2481,17 @@ class LightPushCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.NO_RESPONSE,
-                    peerId: peer.id
+                    peerId: peerId
                 }
             };
         }
         if (isRLNResponseError(response.info)) {
-            const rlnErrorCase = matchRLNErrorMessage(response.info);
-            log$4.error("Remote peer rejected the message: ", rlnErrorCase);
+            log$4.error("Remote peer fault: RLN generation");
             return {
                 success: null,
                 failure: {
-                    error: rlnErrorCase,
-                    peerId: peer.id
+                    error: ProtocolError.RLN_PROOF_GENERATION,
+                    peerId: peerId
                 }
             };
         }
@@ -1999,11 +2501,11 @@ class LightPushCore extends BaseProtocol {
                 success: null,
                 failure: {
                     error: ProtocolError.REMOTE_PEER_REJECTED,
-                    peerId: peer.id
+                    peerId: peerId
                 }
             };
         }
-        return { success: peer.id, failure: null };
+        return { success: peerId, failure: null };
     }
 }
 
@@ -2107,7 +2609,7 @@ class StoreCore extends BaseProtocol {
         super(StoreCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
     }
-    async *queryPerPage(queryOpts, decoders, peer) {
+    async *queryPerPage(queryOpts, decoders, peerId) {
         if (queryOpts.contentTopics.toString() !==
             Array.from(decoders.keys()).toString()) {
             throw new Error("Internal error, the decoders should match the query's content topics");
@@ -2120,7 +2622,7 @@ class StoreCore extends BaseProtocol {
             });
             let stream;
             try {
-                stream = await this.getStream(peer);
+                stream = await this.getStream(peerId);
             }
             catch (e) {
                 log$3.error("Failed to get stream", e);
@@ -2180,6 +2682,18 @@ 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
  */
@@ -2252,6 +2766,1154 @@ 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 {
@@ -2538,13 +4200,59 @@ class ConnectionManager extends TypedEventEmitter {
         this.startPeerDisconnectionListener();
         this.startNetworkStatusListener();
     }
-    async dialPeer(peerId) {
+    /**
+     * 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();
         this.currentActiveParallelDialCount += 1;
         let dialAttempt = 0;
         while (dialAttempt < this.options.maxDialAttemptsForPeer) {
             try {
-                log$1.info(`Dialing peer ${peerId.toString()} on attempt ${dialAttempt + 1}`);
-                await this.libp2p.dial(peerId);
+                log$1.info(`Dialing peer ${peerDialInfo} on attempt ${dialAttempt + 1}`);
+                connection = await this.libp2p.dial(peerDialInfo);
+                peerId = connection.remotePeer;
                 const tags = await this.getTagNamesForPeer(peerId);
                 // add tag to connection describing discovery mechanism
                 // don't add duplicate tags
@@ -2561,15 +4269,15 @@ class ConnectionManager extends TypedEventEmitter {
             catch (error) {
                 if (error instanceof AggregateError) {
                     // Handle AggregateError
-                    log$1.error(`Error dialing peer ${peerId.toString()} - ${error.errors}`);
+                    log$1.error(`Error dialing peer ${peerIdStr} - ${error.errors}`);
                 }
                 else {
                     // Handle generic error
-                    log$1.error(`Error dialing peer ${peerId.toString()} - ${error.message}`);
+                    log$1.error(`Error dialing peer ${peerIdStr} - ${error.message}`);
                 }
-                this.dialErrorsForPeer.set(peerId.toString(), error);
+                this.dialErrorsForPeer.set(peerIdStr, error);
                 dialAttempt++;
-                this.dialAttemptsForPeer.set(peerId.toString(), dialAttempt);
+                this.dialAttemptsForPeer.set(peerIdStr, dialAttempt);
             }
         }
         // Always decrease the active dial count and process the dial queue
@@ -2578,7 +4286,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(peerId.toString());
+                const error = this.dialErrorsForPeer.get(peerIdStr);
                 if (error) {
                     let errorMessage;
                     if (error instanceof AggregateError) {
@@ -2595,17 +4303,53 @@ class ConnectionManager extends TypedEventEmitter {
                     else {
                         errorMessage = error.message;
                     }
-                    log$1.info(`Deleting undialable peer ${peerId.toString()} from peer store. Reason: ${errorMessage}`);
+                    log$1.info(`Deleting undialable peer ${peerIdStr} from peer store. Reason: ${errorMessage}`);
+                }
+                this.dialErrorsForPeer.delete(peerIdStr);
+                if (peerId) {
+                    await this.libp2p.peerStore.delete(peerId);
                 }
-                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 ${peerId.toString()} from peer store - ${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");
+            }
+            return ma;
+        }
     }
     async attemptDnsDiscovery() {
         if (this.libp2p.getConnections().length > 0)
@@ -2841,75 +4585,6 @@ 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 {
@@ -2938,7 +4613,7 @@ class Metadata extends BaseProtocol {
         }
         let stream;
         try {
-            stream = await this.getStream(peer);
+            stream = await this.getStream(peerId);
         }
         catch (error) {
             log.error("Failed to get stream", error);
@@ -3021,4 +4696,4 @@ function wakuMetadata(pubsubTopics) {
     return (components) => new Metadata(pubsubTopics, components);
 }
 
-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 };
+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 };