@waku/core 0.0.36-383e0b2.0 → 0.0.36-4c18ca2.0

package/bundle/index.js

@@ -1,8 +1,5 @@
-import { v as version_0, a as allocUnsafe, b as alloc, e as encodingLength$1, c as encode$2, d as decode$4, F as FilterSubscribeRequest, f as FilterSubscribeResponse$1, M as MessagePush, 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-4TwtF5aQ.js';
-export { o as createDecoder } from './version_0-4TwtF5aQ.js';
-import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, L as Logger, P as ProtocolError, T as Tags, E as EPeersByDiscoveryEvents, f as EConnectionStateEvents } from './index-CTo1my9M.js';
-import { B as BaseProtocol } from './base_protocol-DvQrudwy.js';
-export { S as StreamManager } from './base_protocol-DvQrudwy.js';
+import { e as equals$2, c as coerce, b as base32, a as base58btc, d as base36, v as version_0, f as allocUnsafe, g as alloc, h as encodingLength$1, i as encode$2, j as decode$4, L as Logger, F as FilterSubscribeRequest, k as FilterSubscribeResponse$1, M as MessagePush, P as ProtocolError, l as PushRpc$1, m as PushResponse, S as StoreQueryRequest$1, n as StoreQueryResponse$1, o as bases, t as toString, p as fromString, q as base64url, r as encodeUint8Array, u as utf8ToBytes, s as createEncoder, w as pubsubTopicToSingleShardInfo, x as bytesToUtf8, T as Tags, E as EPeersByDiscoveryEvents, y as shardInfoToPubsubTopics, z as EConnectionStateEvents, W as WakuMetadataRequest, A as pubsubTopicsToShardInfo, B as WakuMetadataResponse, C as concat$1, D as sha256, G as bytesToHex, H as numberToBytes } from './version_0-9DPFjcJG.js';
+export { I as createDecoder } from './version_0-9DPFjcJG.js';
 
 /* eslint-disable */
 var encode_1 = encode$1;
@@ -514,6 +511,10 @@ function encodeCID(version, code, multihash) {
 }
 const cidSymbol = Symbol.for('@ipld/js-cid/CID');
 
+function isDefined(value) {
+    return Boolean(value);
+}
+
 const MB = 1024 ** 2;
 const SIZE_CAP_IN_MB = 1;
 /**
@@ -2008,25 +2009,38 @@ function queuelessPushable() {
 function isAsyncIterable$1(thing) {
     return thing[Symbol.asyncIterator] != null;
 }
-async function addAllToPushable(sources, output) {
+async function addAllToPushable(sources, output, signal) {
     try {
         await Promise.all(sources.map(async (source) => {
             for await (const item of source) {
-                await output.push(item);
+                await output.push(item, {
+                    signal
+                });
+                signal.throwIfAborted();
             }
         }));
-        await output.end();
+        await output.end(undefined, {
+            signal
+        });
     }
     catch (err) {
-        await output.end(err)
+        await output.end(err, {
+            signal
+        })
             .catch(() => { });
     }
 }
 async function* mergeSources(sources) {
+    const controller = new AbortController();
     const output = queuelessPushable();
-    addAllToPushable(sources, output)
+    addAllToPushable(sources, output, controller.signal)
         .catch(() => { });
-    yield* output;
+    try {
+        yield* output;
+    }
+    finally {
+        controller.abort();
+    }
 }
 function* mergeSyncSources(syncSources) {
     for (const source of syncSources) {
@@ -2132,6 +2146,129 @@ const duplexPipelineFn = (duplex) => {
     };
 };
 
+function selectOpenConnection(connections) {
+    return connections
+        .filter((c) => c.status === "open")
+        .sort((left, right) => right.timeline.open - left.timeline.open)
+        .at(0);
+}
+
+const STREAM_LOCK_KEY = "consumed";
+class StreamManager {
+    multicodec;
+    libp2p;
+    log;
+    ongoingCreation = new Set();
+    streamPool = new Map();
+    constructor(multicodec, libp2p) {
+        this.multicodec = multicodec;
+        this.libp2p = libp2p;
+        this.log = new Logger(`stream-manager:${multicodec}`);
+        this.libp2p.events.addEventListener("peer:update", this.handlePeerUpdateStreamPool);
+    }
+    async getStream(peerId) {
+        const peerIdStr = peerId.toString();
+        const scheduledStream = this.streamPool.get(peerIdStr);
+        if (scheduledStream) {
+            this.streamPool.delete(peerIdStr);
+            await scheduledStream;
+        }
+        let stream = this.getOpenStreamForCodec(peerId);
+        if (stream) {
+            this.log.info(`Found existing stream peerId=${peerIdStr} multicodec=${this.multicodec}`);
+            this.lockStream(peerIdStr, stream);
+            return stream;
+        }
+        stream = await this.createStream(peerId);
+        this.lockStream(peerIdStr, stream);
+        return stream;
+    }
+    async createStream(peerId, retries = 0) {
+        const connections = this.libp2p.connectionManager.getConnections(peerId);
+        const connection = selectOpenConnection(connections);
+        if (!connection) {
+            throw new Error(`Failed to get a connection to the peer peerId=${peerId.toString()} multicodec=${this.multicodec}`);
+        }
+        let lastError;
+        let stream;
+        for (let i = 0; i < retries + 1; i++) {
+            try {
+                this.log.info(`Attempting to create a stream for peerId=${peerId.toString()} multicodec=${this.multicodec}`);
+                stream = await connection.newStream(this.multicodec);
+                this.log.info(`Created stream for peerId=${peerId.toString()} multicodec=${this.multicodec}`);
+                break;
+            }
+            catch (error) {
+                lastError = error;
+            }
+        }
+        if (!stream) {
+            throw new Error(`Failed to create a new stream for ${peerId.toString()} -- ` + lastError);
+        }
+        return stream;
+    }
+    async createStreamWithLock(peer) {
+        const peerId = peer.id.toString();
+        if (this.ongoingCreation.has(peerId)) {
+            this.log.info(`Skipping creation of a stream due to lock for peerId=${peerId} multicodec=${this.multicodec}`);
+            return;
+        }
+        try {
+            this.ongoingCreation.add(peerId);
+            await this.createStream(peer.id);
+        }
+        catch (error) {
+            this.log.error(`Failed to createStreamWithLock:`, error);
+        }
+        finally {
+            this.ongoingCreation.delete(peerId);
+        }
+        return;
+    }
+    handlePeerUpdateStreamPool = (evt) => {
+        const { peer } = evt.detail;
+        if (!peer.protocols.includes(this.multicodec)) {
+            return;
+        }
+        const stream = this.getOpenStreamForCodec(peer.id);
+        if (stream) {
+            return;
+        }
+        this.scheduleNewStream(peer);
+    };
+    scheduleNewStream(peer) {
+        this.log.info(`Scheduling creation of a stream for peerId=${peer.id.toString()} multicodec=${this.multicodec}`);
+        // abandon previous attempt
+        if (this.streamPool.has(peer.id.toString())) {
+            this.streamPool.delete(peer.id.toString());
+        }
+        this.streamPool.set(peer.id.toString(), this.createStreamWithLock(peer));
+    }
+    getOpenStreamForCodec(peerId) {
+        const connections = this.libp2p.connectionManager.getConnections(peerId);
+        const connection = selectOpenConnection(connections);
+        if (!connection) {
+            return;
+        }
+        const stream = connection.streams.find((s) => s.protocol === this.multicodec);
+        if (!stream) {
+            return;
+        }
+        const isStreamUnusable = ["done", "closed", "closing"].includes(stream.writeStatus || "");
+        if (isStreamUnusable || this.isStreamLocked(stream)) {
+            return;
+        }
+        return stream;
+    }
+    lockStream(peerId, stream) {
+        this.log.info(`Locking stream for peerId:${peerId}\tstreamId:${stream.id}`);
+        stream.metadata[STREAM_LOCK_KEY] = true;
+    }
+    isStreamLocked(stream) {
+        return !!stream.metadata[STREAM_LOCK_KEY];
+    }
+}
+
 // Unique ID creation requires a high quality random # generator. In the browser we therefore
 // require the crypto API and do not support built-in fallback to lower quality random number
 // generators (like Math.random()).
@@ -2299,13 +2436,33 @@ const FilterCodecs = {
     SUBSCRIBE: "/vac/waku/filter-subscribe/2.0.0-beta1",
     PUSH: "/vac/waku/filter-push/2.0.0-beta1"
 };
-class FilterCore extends BaseProtocol {
-    handleIncomingMessage;
+class FilterCore {
     pubsubTopics;
+    streamManager;
+    static handleIncomingMessage;
+    multicodec = FilterCodecs.SUBSCRIBE;
     constructor(handleIncomingMessage, pubsubTopics, libp2p) {
-        super(FilterCodecs.SUBSCRIBE, libp2p.components, pubsubTopics);
-        this.handleIncomingMessage = handleIncomingMessage;
         this.pubsubTopics = pubsubTopics;
+        this.streamManager = new StreamManager(FilterCodecs.SUBSCRIBE, libp2p.components);
+        // TODO(weboko): remove when @waku/sdk 0.0.33 is released
+        const prevHandler = FilterCore.handleIncomingMessage;
+        FilterCore.handleIncomingMessage = !prevHandler
+            ? handleIncomingMessage
+            : async (pubsubTopic, message, peerIdStr) => {
+                try {
+                    await prevHandler(pubsubTopic, message, peerIdStr);
+                }
+                catch (e) {
+                    log$5.error("Previous FilterCore incoming message handler failed ", e);
+                }
+                try {
+                    await handleIncomingMessage(pubsubTopic, message, peerIdStr);
+                }
+                catch (e) {
+                    log$5.error("Present FilterCore incoming message handler failed ", e);
+                }
+                return;
+            };
         libp2p
             .handle(FilterCodecs.PUSH, this.onRequest.bind(this), {
             maxInboundStreams: 100
@@ -2315,7 +2472,7 @@ class FilterCore extends BaseProtocol {
         });
     }
     async subscribe(pubsubTopic, peerId, contentTopics) {
-        const stream = await this.getStream(peerId);
+        const stream = await this.streamManager.getStream(peerId);
         const request = FilterSubscribeRpc.createSubscribeRequest(pubsubTopic, contentTopics);
         let res;
         try {
@@ -2350,7 +2507,7 @@ class FilterCore extends BaseProtocol {
     async unsubscribe(pubsubTopic, peerId, contentTopics) {
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.streamManager.getStream(peerId);
         }
         catch (error) {
             log$5.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
@@ -2382,7 +2539,7 @@ class FilterCore extends BaseProtocol {
         };
     }
     async unsubscribeAll(pubsubTopic, peerId) {
-        const stream = await this.getStream(peerId);
+        const stream = await this.streamManager.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) {
@@ -2413,7 +2570,7 @@ class FilterCore extends BaseProtocol {
     async ping(peerId) {
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.streamManager.getStream(peerId);
         }
         catch (error) {
             log$5.error(`Failed to get a stream for remote peer${peerId.toString()}`, error);
@@ -2482,7 +2639,7 @@ class FilterCore extends BaseProtocol {
                         log$5.error("Pubsub topic missing from push message");
                         return;
                     }
-                    await this.handleIncomingMessage(pubsubTopic, wakuMessage, connection.remotePeer.toString());
+                    await FilterCore.handleIncomingMessage?.(pubsubTopic, wakuMessage, connection.remotePeer.toString());
                 }
             }).then(() => {
                 log$5.info("Receiving pipe closed.");
@@ -2555,11 +2712,13 @@ const LightPushCodec = "/vac/waku/lightpush/2.0.0-beta1";
 /**
  * Implements the [Waku v2 Light Push protocol](https://rfc.vac.dev/spec/19/).
  */
-class LightPushCore extends BaseProtocol {
+class LightPushCore {
     pubsubTopics;
+    streamManager;
+    multicodec = LightPushCodec;
     constructor(pubsubTopics, libp2p) {
-        super(LightPushCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
+        this.streamManager = new StreamManager(LightPushCodec, libp2p.components);
     }
     async preparePushMessage(encoder, message) {
         try {
@@ -2603,7 +2762,7 @@ class LightPushCore extends BaseProtocol {
         }
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.streamManager.getStream(peerId);
         }
         catch (error) {
             log$4.error("Failed to get stream", error);
@@ -2727,19 +2886,15 @@ class StoreQueryRequest {
                 ? BigInt(params.paginationLimit)
                 : undefined
         });
-        // Validate request parameters based on RFC
         const isHashQuery = params.messageHashes && params.messageHashes.length > 0;
         const hasContentTopics = params.contentTopics && params.contentTopics.length > 0;
         const hasTimeFilter = params.timeStart || params.timeEnd;
         if (isHashQuery) {
-            // Message hash lookup queries cannot include content topics or time filters
-            // but pubsubTopic is allowed/required
             if (hasContentTopics || hasTimeFilter) {
                 throw new Error("Message hash lookup queries cannot include content filter criteria (contentTopics, timeStart, or timeEnd)");
             }
         }
         else {
-            // Content-filtered queries require both pubsubTopic and contentTopics to be set together
             if ((params.pubsubTopic &&
                 (!params.contentTopics || params.contentTopics.length === 0)) ||
                 (!params.pubsubTopic &&
@@ -2786,11 +2941,13 @@ class StoreQueryResponse {
 
 const log$3 = new Logger("store");
 const StoreCodec = "/vac/waku/store-query/3.0.0";
-class StoreCore extends BaseProtocol {
+class StoreCore {
     pubsubTopics;
+    streamManager;
+    multicodec = StoreCodec;
     constructor(pubsubTopics, libp2p) {
-        super(StoreCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
+        this.streamManager = new StreamManager(StoreCodec, libp2p.components);
     }
     async *queryPerPage(queryOpts, decoders, peerId) {
         // Only validate decoder content topics for content-filtered queries
@@ -2815,7 +2972,7 @@ class StoreCore extends BaseProtocol {
             });
             let stream;
             try {
-                stream = await this.getStream(peerId);
+                stream = await this.streamManager.getStream(peerId);
             }
             catch (e) {
                 log$3.error("Failed to get stream", e);
@@ -2887,9 +3044,71 @@ function isPeerId(other) {
     return Boolean(other?.[peerIdSymbol]);
 }
 
+/**
+ * @packageDocumentation
+ *
+ * Adds types to the EventTarget class.
+ *
+ * Hopefully this won't be necessary
+ * forever:
+ *
+ * - https://github.com/microsoft/TypeScript/issues/28357
+ * - https://github.com/microsoft/TypeScript/issues/43477
+ * - https://github.com/microsoft/TypeScript/issues/299
+ * - https://www.npmjs.com/package/typed-events
+ * - https://www.npmjs.com/package/typed-event-emitter
+ * - https://www.npmjs.com/package/typed-event-target
+ * - etc
+ *
+ * In addition to types, a `safeDispatchEvent` method is available which
+ * prevents dispatching events that aren't in the event map, and a
+ * `listenerCount` method which reports the number of listeners that are
+ * currently registered for a given event.
+ *
+ * @example
+ *
+ * ```ts
+ * import { TypedEventEmitter } from 'main-event'
+ * import type { TypedEventTarget } from 'main-event'
+ *
+ * interface EventTypes {
+ *   'test': CustomEvent<string>
+ * }
+ *
+ * const target = new TypedEventEmitter<EventTypes>()
+ *
+ * // it's a regular EventTarget
+ * console.info(target instanceof EventTarget) // true
+ *
+ * // register listeners normally
+ * target.addEventListener('test', (evt) => {
+ *   // evt is CustomEvent<string>
+ * })
+ *
+ * // @ts-expect-error 'derp' is not in the event map
+ * target.addEventListener('derp', () => {})
+ *
+ * // use normal dispatchEvent method
+ * target.dispatchEvent(new CustomEvent('test', {
+ *   detail: 'hello'
+ * }))
+ *
+ * // use type safe dispatch method
+ * target.safeDispatchEvent('test', {
+ *   detail: 'world'
+ * })
+ *
+ * // report listener count
+ * console.info(target.listenerCount('test')) // 0
+ *
+ * // event emitters can be used purely as interfaces too
+ * function acceptTarget (target: TypedEventTarget<EventTypes>) {
+ *   // ...
+ * }
+ * ```
+ */
 /**
  * An implementation of a typed event target
- * etc
  */
 class TypedEventEmitter extends EventTarget {
     #listeners = new Map();
@@ -2939,6 +3158,26 @@ class TypedEventEmitter extends EventTarget {
     }
 }
 
+/**
+ * Thrown when an invalid multiaddr is encountered
+ */
+class InvalidMultiaddrError extends Error {
+    static name = 'InvalidMultiaddrError';
+    name = 'InvalidMultiaddrError';
+}
+class ValidationError extends Error {
+    static name = 'ValidationError';
+    name = 'ValidationError';
+}
+class InvalidParametersError extends Error {
+    static name = 'InvalidParametersError';
+    name = 'InvalidParametersError';
+}
+class UnknownProtocolError extends Error {
+    static name = 'UnknownProtocolError';
+    name = 'UnknownProtocolError';
+}
+
 /* eslint-disable @typescript-eslint/no-unsafe-return */
 class Parser {
     index = 0;
@@ -3162,24 +3401,6 @@ function parseIPv6(input) {
     }
     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) {
@@ -3189,347 +3410,69 @@ function isIPv4(input) {
 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 '';
-};
+// the values here come from https://github.com/multiformats/multiaddr/blob/master/protocols.csv
+const CODE_IP4 = 4;
+const CODE_TCP = 6;
+const CODE_UDP = 273;
+const CODE_DCCP = 33;
+const CODE_IP6 = 41;
+const CODE_IP6ZONE = 42;
+const CODE_IPCIDR = 43;
+const CODE_DNS = 53;
+const CODE_DNS4 = 54;
+const CODE_DNS6 = 55;
+const CODE_DNSADDR = 56;
+const CODE_SCTP = 132;
+const CODE_UDT = 301;
+const CODE_UTP = 302;
+const CODE_UNIX = 400;
+const CODE_P2P = 421; // also IPFS
+const CODE_ONION = 444;
+const CODE_ONION3 = 445;
+const CODE_GARLIC64 = 446;
+const CODE_GARLIC32 = 447;
+const CODE_TLS = 448;
+const CODE_SNI = 449;
+const CODE_NOISE = 454;
+const CODE_QUIC = 460;
+const CODE_QUIC_V1 = 461;
+const CODE_WEBTRANSPORT = 465;
+const CODE_CERTHASH = 466;
+const CODE_HTTP = 480;
+const CODE_HTTP_PATH = 481;
+const CODE_HTTPS = 443;
+const CODE_WS = 477;
+const CODE_WSS = 478;
+const CODE_P2P_WEBSOCKET_STAR = 479;
+const CODE_P2P_STARDUST = 277;
+const CODE_P2P_WEBRTC_STAR = 275;
+const CODE_P2P_WEBRTC_DIRECT = 276;
+const CODE_WEBRTC_DIRECT = 280;
+const CODE_WEBRTC = 281;
+const CODE_P2P_CIRCUIT = 290;
+const CODE_MEMORY = 777;
 
-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)
+function bytesToString(base) {
+    return (buf) => {
+        return toString(buf, base);
     };
 }
-/**
- * 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 stringToBytes(base) {
+    return (buf) => {
+        return fromString(buf, base);
+    };
 }
-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 bytes2port(buf) {
+    const view = new DataView(buf.buffer);
+    return view.getUint16(buf.byteOffset).toString();
 }
 function port2bytes(port) {
     const buf = new ArrayBuffer(2);
     const view = new DataView(buf);
-    view.setUint16(0, port);
+    view.setUint16(0, typeof port === 'string' ? parseInt(port) : 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) {
@@ -3539,7 +3482,7 @@ function onion2bytes(str) {
         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]);
+    const buf = fromString(addr[0], 'base32');
     // onion port number
     const port = parseInt(addr[1], 10);
     if (port < 1 || port > 65536) {
@@ -3567,167 +3510,558 @@ function onion32bytes(str) {
     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 addrBytes = buf.subarray(0, buf.length - 2);
+    const portBytes = buf.subarray(buf.length - 2);
+    const addr = toString(addrBytes, 'base32');
     const port = bytes2port(portBytes);
     return `${addr}:${port}`;
 }
+// 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 ip4ToBytes = function (ip) {
+    ip = ip.toString().trim();
+    const bytes = new Uint8Array(4);
+    ip.split(/\./g).forEach((byte, index) => {
+        const value = parseInt(byte, 10);
+        if (isNaN(value) || value < 0 || value > 0xff) {
+            throw new InvalidMultiaddrError('Invalid byte value in IP address');
+        }
+        bytes[index] = value;
+    });
+    return bytes;
+};
+// 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 ip6ToBytes = function (ip) {
+    let offset = 0;
+    ip = ip.toString().trim();
+    const sections = ip.split(':', 8);
+    let i;
+    for (i = 0; i < sections.length; i++) {
+        const isv4 = isIPv4(sections[i]);
+        let v4Buffer;
+        if (isv4) {
+            v4Buffer = ip4ToBytes(sections[i]);
+            sections[i] = toString(v4Buffer.subarray(0, 2), 'base16');
+        }
+        if (v4Buffer != null && ++i < 8) {
+            sections.splice(i, 0, toString(v4Buffer.subarray(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++) {
+        if (sections[i] === '') {
+            sections[i] = '0';
+        }
+        const word = parseInt(sections[i], 16);
+        if (isNaN(word) || word < 0 || word > 0xffff) {
+            throw new InvalidMultiaddrError('Invalid byte value in IP address');
+        }
+        bytes[offset++] = (word >> 8) & 0xff;
+        bytes[offset++] = word & 0xff;
+    }
+    return bytes;
+};
+// Copied from https://github.com/indutny/node-ip/blob/master/lib/ip.js#L63
+const ip4ToString = function (buf) {
+    if (buf.byteLength !== 4) {
+        throw new InvalidMultiaddrError('IPv4 address was incorrect length');
+    }
+    const result = [];
+    for (let i = 0; i < buf.byteLength; i++) {
+        result.push(buf[i]);
+    }
+    return result.join('.');
+};
+const ip6ToString = function (buf) {
+    if (buf.byteLength !== 16) {
+        throw new InvalidMultiaddrError('IPv6 address was incorrect length');
+    }
+    const result = [];
+    for (let i = 0; i < buf.byteLength; i += 2) {
+        const byte1 = buf[i];
+        const byte2 = buf[i + 1];
+        const tuple = `${byte1.toString(16).padStart(2, '0')}${byte2.toString(16).padStart(2, '0')}`;
+        result.push(tuple);
+    }
+    const ip = result.join(':');
+    try {
+        const url = new URL(`http://[${ip}]`);
+        return url.hostname.substring(1, url.hostname.length - 1);
+    }
+    catch {
+        throw new InvalidMultiaddrError(`Invalid IPv6 address "${ip}"`);
+    }
+};
+function ip6StringToValue(str) {
+    try {
+        const url = new URL(`http://[${str}]`);
+        return url.hostname.substring(1, url.hostname.length - 1);
+    }
+    catch {
+        throw new InvalidMultiaddrError(`Invalid IPv6 address "${str}"`);
+    }
+}
+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 mb2bytes(mbstr) {
+    return anybaseDecoder.decode(mbstr);
+}
+function bytes2mb(base) {
+    return (buf) => {
+        return base.encoder.encode(buf);
+    };
+}
 
-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
-        };
+function integer(value) {
+    const int = parseInt(value);
+    if (int.toString() !== value) {
+        throw new ValidationError('Value must be an integer');
     }
-    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 new 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 positive(value) {
+    if (value < 0) {
+        throw new ValidationError('Value must be a positive integer, or zero');
+    }
+}
+function maxValue(max) {
+    return (value) => {
+        if (value > max) {
+            throw new ValidationError(`Value must be smaller than or equal to ${max}`);
+        }
+    };
+}
+function validate$1(...funcs) {
+    return (value) => {
+        for (const fn of funcs) {
+            fn(value);
+        }
     };
 }
-function bytesToMultiaddrParts(bytes) {
-    const tuples = [];
-    const stringTuples = [];
-    let path = null;
+const validatePort = validate$1(integer, positive, maxValue(65_535));
+
+const V = -1;
+class Registry {
+    protocolsByCode = new Map();
+    protocolsByName = new Map();
+    getProtocol(key) {
+        let codec;
+        if (typeof key === 'string') {
+            codec = this.protocolsByName.get(key);
+        }
+        else {
+            codec = this.protocolsByCode.get(key);
+        }
+        if (codec == null) {
+            throw new UnknownProtocolError(`Protocol ${key} was unknown`);
+        }
+        return codec;
+    }
+    addProtocol(codec) {
+        this.protocolsByCode.set(codec.code, codec);
+        this.protocolsByName.set(codec.name, codec);
+        codec.aliases?.forEach(alias => {
+            this.protocolsByName.set(alias, codec);
+        });
+    }
+    removeProtocol(code) {
+        const codec = this.protocolsByCode.get(code);
+        if (codec == null) {
+            return;
+        }
+        this.protocolsByCode.delete(codec.code);
+        this.protocolsByName.delete(codec.name);
+        codec.aliases?.forEach(alias => {
+            this.protocolsByName.delete(alias);
+        });
+    }
+}
+const registry = new Registry();
+const codecs = [{
+        code: CODE_IP4,
+        name: 'ip4',
+        size: 32,
+        valueToBytes: ip4ToBytes,
+        bytesToValue: ip4ToString,
+        validate: (value) => {
+            if (!isIPv4(value)) {
+                throw new ValidationError(`Invalid IPv4 address "${value}"`);
+            }
+        }
+    }, {
+        code: CODE_TCP,
+        name: 'tcp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_UDP,
+        name: 'udp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_DCCP,
+        name: 'dccp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_IP6,
+        name: 'ip6',
+        size: 128,
+        valueToBytes: ip6ToBytes,
+        bytesToValue: ip6ToString,
+        stringToValue: ip6StringToValue,
+        validate: (value) => {
+            if (!isIPv6(value)) {
+                throw new ValidationError(`Invalid IPv6 address "${value}"`);
+            }
+        }
+    }, {
+        code: CODE_IP6ZONE,
+        name: 'ip6zone',
+        size: V
+    }, {
+        code: CODE_IPCIDR,
+        name: 'ipcidr',
+        size: 8,
+        bytesToValue: bytesToString('base10'),
+        valueToBytes: stringToBytes('base10')
+    }, {
+        code: CODE_DNS,
+        name: 'dns',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_DNS4,
+        name: 'dns4',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_DNS6,
+        name: 'dns6',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_DNSADDR,
+        name: 'dnsaddr',
+        size: V,
+        resolvable: true
+    }, {
+        code: CODE_SCTP,
+        name: 'sctp',
+        size: 16,
+        valueToBytes: port2bytes,
+        bytesToValue: bytes2port,
+        validate: validatePort
+    }, {
+        code: CODE_UDT,
+        name: 'udt'
+    }, {
+        code: CODE_UTP,
+        name: 'utp'
+    }, {
+        code: CODE_UNIX,
+        name: 'unix',
+        size: V,
+        path: true,
+        stringToValue: (str) => decodeURIComponent(str),
+        valueToString: (val) => encodeURIComponent(val)
+    }, {
+        code: CODE_P2P,
+        name: 'p2p',
+        aliases: ['ipfs'],
+        size: V,
+        bytesToValue: bytesToString('base58btc'),
+        valueToBytes: (val) => {
+            if (val.startsWith('Q') || val.startsWith('1')) {
+                return stringToBytes('base58btc')(val);
+            }
+            return CID.parse(val).multihash.bytes;
+        }
+    }, {
+        code: CODE_ONION,
+        name: 'onion',
+        size: 96,
+        bytesToValue: bytes2onion,
+        valueToBytes: onion2bytes
+    }, {
+        code: CODE_ONION3,
+        name: 'onion3',
+        size: 296,
+        bytesToValue: bytes2onion,
+        valueToBytes: onion32bytes
+    }, {
+        code: CODE_GARLIC64,
+        name: 'garlic64',
+        size: V
+    }, {
+        code: CODE_GARLIC32,
+        name: 'garlic32',
+        size: V
+    }, {
+        code: CODE_TLS,
+        name: 'tls'
+    }, {
+        code: CODE_SNI,
+        name: 'sni',
+        size: V
+    }, {
+        code: CODE_NOISE,
+        name: 'noise'
+    }, {
+        code: CODE_QUIC,
+        name: 'quic'
+    }, {
+        code: CODE_QUIC_V1,
+        name: 'quic-v1'
+    }, {
+        code: CODE_WEBTRANSPORT,
+        name: 'webtransport'
+    }, {
+        code: CODE_CERTHASH,
+        name: 'certhash',
+        size: V,
+        bytesToValue: bytes2mb(base64url),
+        valueToBytes: mb2bytes
+    }, {
+        code: CODE_HTTP,
+        name: 'http'
+    }, {
+        code: CODE_HTTP_PATH,
+        name: 'http-path',
+        size: V,
+        stringToValue: (str) => `/${decodeURIComponent(str)}`,
+        valueToString: (val) => encodeURIComponent(val.substring(1))
+    }, {
+        code: CODE_HTTPS,
+        name: 'https'
+    }, {
+        code: CODE_WS,
+        name: 'ws'
+    }, {
+        code: CODE_WSS,
+        name: 'wss'
+    }, {
+        code: CODE_P2P_WEBSOCKET_STAR,
+        name: 'p2p-websocket-star'
+    }, {
+        code: CODE_P2P_STARDUST,
+        name: 'p2p-stardust'
+    }, {
+        code: CODE_P2P_WEBRTC_STAR,
+        name: 'p2p-webrtc-star'
+    }, {
+        code: CODE_P2P_WEBRTC_DIRECT,
+        name: 'p2p-webrtc-direct'
+    }, {
+        code: CODE_WEBRTC_DIRECT,
+        name: 'webrtc-direct'
+    }, {
+        code: CODE_WEBRTC,
+        name: 'webrtc'
+    }, {
+        code: CODE_P2P_CIRCUIT,
+        name: 'p2p-circuit'
+    }, {
+        code: CODE_MEMORY,
+        name: 'memory',
+        size: V
+    }];
+codecs.forEach(codec => {
+    registry.addProtocol(codec);
+});
+
+function bytesToComponents(bytes) {
+    const components = [];
     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 new 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
-    };
+        const codec = registry.getProtocol(code);
+        const codeLength = encodingLength$1(code);
+        const size = sizeForAddr(codec, bytes, i + codeLength);
+        let sizeLength = 0;
+        if (size > 0 && codec.size === V) {
+            sizeLength = encodingLength$1(size);
+        }
+        const componentLength = codeLength + sizeLength + size;
+        const component = {
+            code,
+            name: codec.name,
+            bytes: bytes.subarray(i, i + componentLength)
+        };
+        if (size > 0) {
+            const valueOffset = i + codeLength + sizeLength;
+            const valueBytes = bytes.subarray(valueOffset, valueOffset + size);
+            component.value = codec.bytesToValue?.(valueBytes) ?? toString(valueBytes);
+        }
+        components.push(component);
+        i += componentLength;
+    }
+    return components;
 }
-/**
- * [[num code, str value?]... ] -> 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]);
+function componentsToBytes(components) {
+    let length = 0;
+    const bytes = [];
+    for (const component of components) {
+        if (component.bytes == null) {
+            const codec = registry.getProtocol(component.code);
+            const codecLength = encodingLength$1(component.code);
+            let valueBytes;
+            let valueLength = 0;
+            let valueLengthLength = 0;
+            if (component.value != null) {
+                valueBytes = codec.valueToBytes?.(component.value) ?? fromString(component.value);
+                valueLength = valueBytes.byteLength;
+                if (codec.size === V) {
+                    valueLengthLength = encodingLength$1(valueLength);
+                }
+            }
+            const bytes = new Uint8Array(codecLength + valueLengthLength + valueLength);
+            // encode the protocol code
+            let offset = 0;
+            encodeUint8Array(component.code, bytes, offset);
+            offset += codecLength;
+            // if there is a value
+            if (valueBytes != null) {
+                // if the value has variable length, encode the length
+                if (codec.size === V) {
+                    encodeUint8Array(valueLength, bytes, offset);
+                    offset += valueLengthLength;
+                }
+                // finally encode the value
+                bytes.set(valueBytes, offset);
+            }
+            component.bytes = bytes;
         }
-        return null;
-    });
-    return cleanPath(parts.join('/'));
+        bytes.push(component.bytes);
+        length += component.bytes.byteLength;
+    }
+    return concat(bytes, length);
 }
-/**
- * [[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;
-    }));
+function stringToComponents(string) {
+    if (string.charAt(0) !== '/') {
+        throw new InvalidMultiaddrError('String multiaddr must start with "/"');
+    }
+    const components = [];
+    let collecting = 'protocol';
+    let value = '';
+    let protocol = '';
+    for (let i = 1; i < string.length; i++) {
+        const char = string.charAt(i);
+        if (char !== '/') {
+            if (collecting === 'protocol') {
+                protocol += string.charAt(i);
+            }
+            else {
+                value += string.charAt(i);
+            }
+        }
+        const ended = i === string.length - 1;
+        if (char === '/' || ended) {
+            const codec = registry.getProtocol(protocol);
+            if (collecting === 'protocol') {
+                if (codec.size == null || codec.size === 0) {
+                    // a protocol without an address, eg. `/tls`
+                    components.push({
+                        code: codec.code,
+                        name: codec.name
+                    });
+                    value = '';
+                    protocol = '';
+                    collecting = 'protocol';
+                    continue;
+                }
+                else if (ended) {
+                    throw new InvalidMultiaddrError(`Component ${protocol} was missing value`);
+                }
+                // continue collecting value
+                collecting = 'value';
+            }
+            else if (collecting === 'value') {
+                const component = {
+                    code: codec.code,
+                    name: codec.name
+                };
+                if (codec.size != null && codec.size !== 0) {
+                    if (value === '') {
+                        throw new InvalidMultiaddrError(`Component ${protocol} was missing value`);
+                    }
+                    component.value = codec.stringToValue?.(value) ?? value;
+                }
+                components.push(component);
+                value = '';
+                protocol = '';
+                collecting = 'protocol';
+            }
+        }
+    }
+    if (protocol !== '' && value !== '') {
+        throw new InvalidMultiaddrError('Incomplete multiaddr');
+    }
+    return components;
+}
+function componentsToString(components) {
+    return `/${components.flatMap(component => {
+        if (component.value == null) {
+            return component.name;
+        }
+        const codec = registry.getProtocol(component.code);
+        if (codec == null) {
+            throw new InvalidMultiaddrError(`Unknown protocol code ${component.code}`);
+        }
+        return [
+            component.name,
+            codec.valueToString?.(component.value) ?? component.value
+        ];
+    }).join('/')}`;
 }
 /**
  * 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) {
+function sizeForAddr(codec, bytes, offset) {
+    if (codec.size == null || codec.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('/');
-}
-class ParseError extends Error {
-    static name = 'ParseError';
-    name = 'ParseError';
-    constructor(str) {
-        super(`Error parsing address: ${str}`);
+    if (codec.size > 0) {
+        return codec.size / 8;
     }
+    return decode$4(bytes, offset);
 }
 
-/* eslint-disable complexity */
 const inspect = Symbol.for('nodejs.util.inspect.custom');
-const symbol = Symbol.for('@multiformats/js-multiaddr/multiaddr');
+const symbol = Symbol.for('@multiformats/multiaddr');
 const DNS_CODES = [
-    getProtocol('dns').code,
-    getProtocol('dns4').code,
-    getProtocol('dns6').code,
-    getProtocol('dnsaddr').code
+    CODE_DNS,
+    CODE_DNS4,
+    CODE_DNS6,
+    CODE_DNSADDR
 ];
 class NoAvailableResolverError extends Error {
     constructor(message = 'No available resolver') {
@@ -3735,44 +4069,56 @@ class NoAvailableResolverError extends Error {
         this.name = 'NoAvailableResolverError';
     }
 }
+function toComponents(addr) {
+    if (addr == null) {
+        addr = '/';
+    }
+    if (isMultiaddr(addr)) {
+        return addr.getComponents();
+    }
+    if (addr instanceof Uint8Array) {
+        return bytesToComponents(addr);
+    }
+    if (typeof addr === 'string') {
+        addr = addr
+            .replace(/\/(\/)+/, '/')
+            .replace(/(\/)+$/, '');
+        if (addr === '') {
+            addr = '/';
+        }
+        return stringToComponents(addr);
+    }
+    if (Array.isArray(addr)) {
+        return addr;
+    }
+    throw new InvalidMultiaddrError('Must be a string, Uint8Array, Component[], or another Multiaddr');
+}
 /**
  * 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);
+    #components;
+    // cache string representation
+    #string;
+    // cache byte representation
+    #bytes;
+    constructor(addr = '/', options = {}) {
+        this.#components = toComponents(addr);
+        if (options.validate !== false) {
+            validate(this);
         }
-        else {
-            throw new Error('addr must be a string, Buffer, or another Multiaddr');
+    }
+    get bytes() {
+        if (this.#bytes == null) {
+            this.#bytes = componentsToBytes(this.#components);
         }
-        this.bytes = parts.bytes;
-        this.#string = parts.string;
-        this.#tuples = parts.tuples;
-        this.#stringTuples = parts.stringTuples;
-        this.#path = parts.path;
+        return this.#bytes;
     }
     toString() {
+        if (this.#string == null) {
+            this.#string = componentsToString(this.#components);
+        }
         return this.#string;
     }
     toJSON() {
@@ -3784,31 +4130,25 @@ class Multiaddr {
         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) {
+        for (const { code, name, value } of this.#components) {
+            if (code === CODE_IP6ZONE) {
                 zone = `%${value ?? ''}`;
             }
             // default to https when protocol & port are omitted from DNS addrs
             if (DNS_CODES.includes(code)) {
-                transport = tcp.name === 'tcp' ? 'tcp' : 'udp';
+                transport = 'tcp';
                 port = 443;
                 host = `${value ?? ''}${zone}`;
-                family = code === dns6.code ? 6 : 4;
+                family = code === CODE_DNS6 ? 6 : 4;
             }
-            if (code === tcp.code || code === udp.code) {
-                transport = getProtocol(code).name === 'tcp' ? 'tcp' : 'udp';
+            if (code === CODE_TCP || code === CODE_UDP) {
+                transport = name === 'tcp' ? 'tcp' : 'udp';
                 port = parseInt(value ?? '');
             }
-            if (code === ip4.code || code === ip6.code) {
-                transport = getProtocol(code).name === 'tcp' ? 'tcp' : 'udp';
+            if (code === CODE_IP4 || code === CODE_IP6) {
+                transport = 'tcp';
                 host = `${value ?? ''}${zone}`;
-                family = code === ip6.code ? 6 : 4;
+                family = code === CODE_IP6 ? 6 : 4;
             }
         }
         if (family == null || transport == null || host == null || port == null) {
@@ -3822,25 +4162,44 @@ class Multiaddr {
         };
         return opts;
     }
+    getComponents() {
+        return [
+            ...this.#components
+        ];
+    }
     protos() {
-        return this.#tuples.map(([code]) => Object.assign({}, getProtocol(code)));
+        return this.#components.map(({ code, value }) => {
+            const codec = registry.getProtocol(code);
+            return {
+                code,
+                size: codec.size ?? 0,
+                name: codec.name,
+                resolvable: Boolean(codec.resolvable),
+                path: Boolean(codec.path)
+            };
+        });
     }
     protoCodes() {
-        return this.#tuples.map(([code]) => code);
+        return this.#components.map(({ code }) => code);
     }
     protoNames() {
-        return this.#tuples.map(([code]) => getProtocol(code).name);
+        return this.#components.map(({ name }) => name);
     }
     tuples() {
-        return this.#tuples.map(([code, value]) => {
+        return this.#components.map(({ code, value }) => {
             if (value == null) {
                 return [code];
             }
-            return [code, value];
+            const codec = registry.getProtocol(code);
+            const output = [code];
+            if (value != null) {
+                output.push(codec.valueToBytes?.(value) ?? fromString(value));
+            }
+            return output;
         });
     }
     stringTuples() {
-        return this.#stringTuples.map(([code, value]) => {
+        return this.#components.map(({ code, value }) => {
             if (value == null) {
                 return [code];
             }
@@ -3848,37 +4207,47 @@ class Multiaddr {
         });
     }
     encapsulate(addr) {
-        addr = new Multiaddr(addr);
-        return new Multiaddr(this.toString() + addr.toString());
+        const ma = new Multiaddr(addr);
+        return new Multiaddr([
+            ...this.#components,
+            ...ma.getComponents()
+        ], {
+            validate: false
+        });
     }
     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()}`);
+            throw new InvalidParametersError(`Address ${this.toString()} does not contain subaddress: ${addr.toString()}`);
         }
-        return new Multiaddr(s.slice(0, i));
+        return new Multiaddr(s.slice(0, i), {
+            validate: false
+        });
     }
     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)));
+        let index;
+        for (let i = this.#components.length - 1; i > -1; i--) {
+            if (this.#components[i].code === code) {
+                index = i;
+                break;
             }
         }
-        return this;
+        return new Multiaddr(this.#components.slice(0, index), {
+            validate: false
+        });
     }
     getPeerId() {
         try {
             let tuples = [];
-            this.stringTuples().forEach(([code, name]) => {
-                if (code === names.p2p.code) {
-                    tuples.push([code, name]);
+            this.#components.forEach(({ code, value }) => {
+                if (code === CODE_P2P) {
+                    tuples.push([code, value]);
                 }
                 // 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) {
+                if (code === CODE_P2P_CIRCUIT) {
                     tuples = [];
                 }
             });
@@ -3889,10 +4258,10 @@ class Multiaddr {
                 // peer id is base58btc encoded string but not multibase encoded so add the `z`
                 // prefix so we can validate that it is correctly encoded
                 if (peerIdStr[0] === 'Q' || peerIdStr[0] === '1') {
-                    return toString$1(base58btc.decode(`z${peerIdStr}`), 'base58btc');
+                    return toString(base58btc.decode(`z${peerIdStr}`), 'base58btc');
                 }
                 // try to parse peer id as CID
-                return toString$1(CID.parse(peerIdStr).multihash.bytes, 'base58btc');
+                return toString(CID.parse(peerIdStr).multihash.bytes, 'base58btc');
             }
             return null;
         }
@@ -3901,7 +4270,14 @@ class Multiaddr {
         }
     }
     getPath() {
-        return this.#path;
+        for (const component of this.#components) {
+            const codec = registry.getProtocol(component.code);
+            if (!codec.path) {
+                continue;
+            }
+            return component.value ?? null;
+        }
+        return null;
     }
     equals(addr) {
         return equals(this.bytes, addr.bytes);
@@ -3930,15 +4306,14 @@ class Multiaddr {
             port: options.port
         };
     }
-    isThinWaistAddress(addr) {
-        const protos = (addr ?? this).protos();
-        if (protos.length !== 2) {
+    isThinWaistAddress() {
+        if (this.#components.length !== 2) {
             return false;
         }
-        if (protos[0].code !== 4 && protos[0].code !== 41) {
+        if (this.#components[0].code !== CODE_IP4 && this.#components[0].code !== CODE_IP6) {
             return false;
         }
-        if (protos[1].code !== 6 && protos[1].code !== 273) {
+        if (this.#components[1].code !== CODE_TCP && this.#components[1].code !== CODE_UDP) {
             return false;
         }
         return true;
@@ -3956,9 +4331,23 @@ class Multiaddr {
      * ```
      */
     [inspect]() {
-        return `Multiaddr(${this.#string})`;
+        return `Multiaddr(${this.toString()})`;
     }
 }
+/**
+ * Ensures all multiaddr tuples are correct. Throws if any invalid protocols or
+ * values are encountered.
+ */
+function validate(addr) {
+    addr.getComponents()
+        .forEach(component => {
+        const codec = registry.getProtocol(component.code);
+        if (component.value == null) {
+            return;
+        }
+        codec.validate?.(component.value);
+    });
+}
 
 /**
  * @packageDocumentation
@@ -4053,9 +4442,42 @@ class Multiaddr {
  * console.info(resolved)
  * // [Multiaddr('/ip4/147.75...'), Multiaddr('/ip4/147.75...'), Multiaddr('/ip4/147.75...')...]
  * ```
+ *
+ * @example Adding custom protocols
+ *
+ * To add application-specific or experimental protocols, add a protocol codec
+ * to the protocol registry:
+ *
+ * ```ts
+ * import { registry, V, multiaddr } from '@multiformats/multiaddr'
+ * import type { ProtocolCodec } from '@multiformats/multiaddr'
+ *
+ * const maWithCustomTuple = '/custom-protocol/hello'
+ *
+ * // throws UnknownProtocolError
+ * multiaddr(maWithCustomTuple)
+ *
+ * const protocol: ProtocolCodec = {
+ *   code: 2059,
+ *   name: 'custom-protocol',
+ *   size: V
+ *   // V means variable length, can also be 0, a positive integer (e.g. a fixed
+ *   // length or omitted
+ * }
+ *
+ * registry.addProtocol(protocol)
+ *
+ * // does not throw UnknownProtocolError
+ * multiaddr(maWithCustomTuple)
+ *
+ * // protocols can also be removed
+ * registry.removeProtocol(protocol.code)
+ * ```
  */
 /**
  * All configured {@link Resolver}s
+ *
+ * @deprecated DNS resolving will be removed in a future release
  */
 const resolvers = new Map();
 /**
@@ -4765,13 +5187,15 @@ class ConnectionManager extends TypedEventEmitter {
 
 const log = new Logger("metadata");
 const MetadataCodec = "/vac/waku/metadata/1.0.0";
-class Metadata extends BaseProtocol {
+class Metadata {
     pubsubTopics;
+    streamManager;
     libp2pComponents;
     handshakesConfirmed = new Map();
+    multicodec = MetadataCodec;
     constructor(pubsubTopics, libp2p) {
-        super(MetadataCodec, libp2p.components, pubsubTopics);
         this.pubsubTopics = pubsubTopics;
+        this.streamManager = new StreamManager(MetadataCodec, libp2p);
         this.libp2pComponents = libp2p;
         void libp2p.registrar.handle(MetadataCodec, (streamData) => {
             void this.onRequest(streamData);
@@ -4791,7 +5215,7 @@ class Metadata extends BaseProtocol {
         }
         let stream;
         try {
-            stream = await this.getStream(peerId);
+            stream = await this.streamManager.getStream(peerId);
         }
         catch (error) {
             log.error("Failed to get stream", error);
@@ -4874,4 +5298,85 @@ 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 };
+/**
+ * Deterministic Message Hashing as defined in
+ * [14/WAKU2-MESSAGE](https://rfc.vac.dev/spec/14/#deterministic-message-hashing)
+ *
+ * Computes a SHA-256 hash of the concatenation of pubsub topic, payload, content topic, meta, and timestamp.
+ *
+ * @param pubsubTopic - The pubsub topic string
+ * @param message - The message to be hashed
+ * @returns A Uint8Array containing the SHA-256 hash
+ *
+ * @example
+ * ```typescript
+ * import { messageHash } from "@waku/core";
+ *
+ * const pubsubTopic = "/waku/2/default-waku/proto";
+ * const message = {
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   contentTopic: "/waku/2/default-content/proto",
+ *   meta: new Uint8Array([5, 6, 7, 8]),
+ *   timestamp: new Date()
+ * };
+ *
+ * const hash = messageHash(pubsubTopic, message);
+ * ```
+ */
+function messageHash(pubsubTopic, message) {
+    const pubsubTopicBytes = utf8ToBytes(pubsubTopic);
+    const contentTopicBytes = utf8ToBytes(message.contentTopic);
+    const timestampBytes = tryConvertTimestampToBytes(message.timestamp);
+    const bytes = concat$1([
+        pubsubTopicBytes,
+        message.payload,
+        contentTopicBytes,
+        message.meta,
+        timestampBytes
+    ].filter(isDefined));
+    return sha256(bytes);
+}
+function tryConvertTimestampToBytes(timestamp) {
+    if (!timestamp) {
+        return;
+    }
+    let bigIntTimestamp;
+    if (typeof timestamp === "bigint") {
+        bigIntTimestamp = timestamp;
+    }
+    else {
+        bigIntTimestamp = BigInt(timestamp.valueOf()) * 1000000n;
+    }
+    return numberToBytes(bigIntTimestamp);
+}
+/**
+ * Computes a deterministic message hash and returns it as a hexadecimal string.
+ * This is a convenience wrapper around messageHash that converts the result to a hex string.
+ *
+ * @param pubsubTopic - The pubsub topic string
+ * @param message - The message to be hashed
+ * @returns A string containing the hex representation of the SHA-256 hash
+ *
+ * @example
+ * ```typescript
+ * import { messageHashStr } from "@waku/core";
+ *
+ * const pubsubTopic = "/waku/2/default-waku/proto";
+ * const message = {
+ *   payload: new Uint8Array([1, 2, 3, 4]),
+ *   contentTopic: "/waku/2/default-content/proto",
+ *   meta: new Uint8Array([5, 6, 7, 8]),
+ *   timestamp: new Date()
+ * };
+ *
+ * const hashString = messageHashStr(pubsubTopic, message);
+ * console.log(hashString); // e.g. "a1b2c3d4..."
+ * ```
+ */
+function messageHashStr(pubsubTopic, message) {
+    const hash = messageHash(pubsubTopic, message);
+    const hashStr = bytesToHex(hash);
+    return hashStr;
+}
+
+export { ConnectionManager, FilterCodecs, FilterCore, LightPushCodec, LightPushCore, MetadataCodec, StoreCodec, StoreCore, StreamManager, createEncoder, index$3 as message, messageHash, messageHashStr, wakuMetadata, index$2 as waku_filter, index$1 as waku_light_push, index as waku_store };