@waku/enr 0.0.27-f599932.0 → 0.0.28-5674b0e.0

package/bundle/index.js

@@ -241,11 +241,12 @@ class Decoder {
     constructor(name, prefix, baseDecode) {
         this.name = name;
         this.prefix = prefix;
+        const prefixCodePoint = prefix.codePointAt(0);
         /* c8 ignore next 3 */
-        if (prefix.codePointAt(0) === undefined) {
+        if (prefixCodePoint === undefined) {
             throw new Error('Invalid prefix character');
         }
-        this.prefixCodePoint = prefix.codePointAt(0);
+        this.prefixCodePoint = prefixCodePoint;
         this.baseDecode = baseDecode;
     }
     decode(text) {
@@ -449,7 +450,14 @@ var base2$1 = /*#__PURE__*/Object.freeze({
 
 const alphabet = Array.from('🚀🪐☄🛰🌌🌑🌒🌓🌔🌕🌖🌗🌘🌍🌏🌎🐉☀💻🖥💾💿😂❤😍🤣😊🙏💕😭😘👍😅👏😁🔥🥰💔💖💙😢🤔😆🙄💪😉☺👌🤗💜😔😎😇🌹🤦🎉💞✌✨🤷😱😌🌸🙌😋💗💚😏💛🙂💓🤩😄😀🖤😃💯🙈👇🎶😒🤭❣😜💋👀😪😑💥🙋😞😩😡🤪👊🥳😥🤤👉💃😳✋😚😝😴🌟😬🙃🍀🌷😻😓⭐✅🥺🌈😈🤘💦✔😣🏃💐☹🎊💘😠☝😕🌺🎂🌻😐🖕💝🙊😹🗣💫💀👑🎵🤞😛🔴😤🌼😫⚽🤙☕🏆🤫👈😮🙆🍻🍃🐶💁😲🌿🧡🎁⚡🌞🎈❌✊👋😰🤨😶🤝🚶💰🍓💢🤟🙁🚨💨🤬✈🎀🍺🤓😙💟🌱😖👶🥴▶➡❓💎💸⬇😨🌚🦋😷🕺⚠🙅😟😵👎🤲🤠🤧📌🔵💅🧐🐾🍒😗🤑🌊🤯🐷☎💧😯💆👆🎤🙇🍑❄🌴💣🐸💌📍🥀🤢👅💡💩👐📸👻🤐🤮🎼🥵🚩🍎🍊👼💍📣🥂');
 const alphabetBytesToChars = (alphabet.reduce((p, c, i) => { p[i] = c; return p; }, ([])));
-const alphabetCharsToBytes = (alphabet.reduce((p, c, i) => { p[c.codePointAt(0)] = i; return p; }, ([])));
+const alphabetCharsToBytes = (alphabet.reduce((p, c, i) => {
+    const codePoint = c.codePointAt(0);
+    if (codePoint == null) {
+        throw new Error(`Invalid character: ${c}`);
+    }
+    p[codePoint] = i;
+    return p;
+}, ([])));
 function encode$4(data) {
     return data.reduce((p, c) => {
         p += alphabetBytesToChars[c];
@@ -459,8 +467,12 @@ function encode$4(data) {
 function decode$5(str) {
     const byts = [];
     for (const char of str) {
-        const byt = alphabetCharsToBytes[char.codePointAt(0)];
-        if (byt === undefined) {
+        const codePoint = char.codePointAt(0);
+        if (codePoint == null) {
+            throw new Error(`Invalid character: ${char}`);
+        }
+        const byt = alphabetCharsToBytes[codePoint];
+        if (byt == null) {
             throw new Error(`Non-base256emoji character: ${char}`);
         }
         byts.push(byt);
@@ -733,7 +745,7 @@ function encodingLength$1(int) {
 /**
  * Creates a multihash digest.
  */
-function create$1(code, digest) {
+function create(code, digest) {
     const size = digest.byteLength;
     const sizeOffset = encodingLength$1(code);
     const digestOffset = sizeOffset + encodingLength$1(size);
@@ -792,7 +804,7 @@ const code = 0x0;
 const name = 'identity';
 const encode$2 = coerce;
 function digest(input) {
-    return create$1(code, encode$2(input));
+    return create(code, encode$2(input));
 }
 const identity = { code, name, encode: encode$2, digest };
 
@@ -816,9 +828,9 @@ class Hasher {
         if (input instanceof Uint8Array) {
             const result = this.encode(input);
             return result instanceof Uint8Array
-                ? create$1(this.code, result)
+                ? create(this.code, result)
                 /* c8 ignore next 1 */
-                : result.then(digest => create$1(this.code, digest));
+                : result.then(digest => create(this.code, digest));
         }
         else {
             throw Error('Unknown type, must be binary type');
@@ -918,7 +930,7 @@ class CID {
         switch (this.version) {
             case 0: {
                 const { code, digest } = this.multihash;
-                const multihash = create$1(code, digest);
+                const multihash = create(code, digest);
                 return (CID.createV1(this.code, multihash));
             }
             case 1: {
@@ -1148,9 +1160,13 @@ function parseCIDtoBytes(source, base) {
             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 or base58btc encoded CID multibase decoder must be provided');
+                throw Error('To parse non base32, base36 or base58btc encoded CID multibase decoder must be provided');
             }
             return [source[0], base.decode(source)];
         }
@@ -3056,7 +3072,7 @@ async function sign$1(message, privateKey) {
 function keccak256(input) {
     return new Uint8Array(sha3.keccak256.arrayBuffer(input));
 }
-function compressPublicKey$1(publicKey) {
+function compressPublicKey(publicKey) {
     if (publicKey.length === 64) {
         publicKey = concat$2([new Uint8Array([4]), publicKey], 65);
     }
@@ -3125,23 +3141,6 @@ const createView = (arr) => new DataView(arr.buffer, arr.byteOffset, arr.byteLen
 // The rotate right (circular right shift) operation for uint32
 const rotr = (word, shift) => (word << (32 - shift)) | (word >>> shift);
 new Uint8Array(new Uint32Array([0x11223344]).buffer)[0] === 0x44;
-// There is no setImmediate in browser and setTimeout is slow.
-// call of async fn will return Promise, which will be fullfiled only on
-// next scheduler queue processing step and this is exactly what we need.
-const nextTick = async () => { };
-// Returns control to thread each 'tick' ms to avoid blocking
-async function asyncLoop(iters, tick, cb) {
-    let ts = Date.now();
-    for (let i = 0; i < iters; i++) {
-        cb(i);
-        // Date.now() is not monotonic, so in case if clock goes backwards we return return control too
-        const diff = Date.now() - ts;
-        if (diff >= 0 && diff < tick)
-            continue;
-        await nextTick();
-        ts += diff;
-    }
-}
 /**
  * @example utf8ToBytes('abc') // new Uint8Array([97, 98, 99])
  */
@@ -3186,13 +3185,6 @@ class Hash {
         return this._cloneInto();
     }
 }
-const toStr = {}.toString;
-function checkOpts(defaults, opts) {
-    if (opts !== undefined && toStr.call(opts) !== '[object Object]')
-        throw new Error('Options should be object or undefined');
-    const merged = Object.assign(defaults, opts);
-    return merged;
-}
 function wrapConstructor(hashCons) {
     const hashC = (msg) => hashCons().update(toBytes$1(msg)).digest();
     const tmp = hashCons();
@@ -3204,14 +3196,20 @@ function wrapConstructor(hashCons) {
 /**
  * Secure PRNG. Uses `crypto.getRandomValues`, which defers to OS.
  */
-function randomBytes$1(bytesLength = 32) {
+function randomBytes(bytesLength = 32) {
     if (crypto$1 && typeof crypto$1.getRandomValues === 'function') {
         return crypto$1.getRandomValues(new Uint8Array(bytesLength));
     }
+    // Legacy Node.js compatibility
+    if (crypto$1 && typeof crypto$1.randomBytes === 'function') {
+        return crypto$1.randomBytes(bytesLength);
+    }
     throw new Error('crypto.getRandomValues must be defined');
 }
 
-// Polyfill for Safari 14
+/**
+ * Polyfill for Safari 14
+ */
 function setBigUint64(view, byteOffset, value, isLE) {
     if (typeof view.setBigUint64 === 'function')
         return view.setBigUint64(byteOffset, value, isLE);
@@ -3224,9 +3222,13 @@ function setBigUint64(view, byteOffset, value, isLE) {
     view.setUint32(byteOffset + h, wh, isLE);
     view.setUint32(byteOffset + l, wl, isLE);
 }
-// Choice: a ? b : c
+/**
+ * Choice: a ? b : c
+ */
 const Chi = (a, b, c) => (a & b) ^ (~a & c);
-// Majority function, true if any two inpust is true
+/**
+ * Majority function, true if any two inputs is true
+ */
 const Maj = (a, b, c) => (a & b) ^ (a & c) ^ (b & c);
 /**
  * Merkle-Damgard hash construction base class.
@@ -3621,7 +3623,7 @@ function requireMs () {
 	 * @api public
 	 */
 
-	ms = function(val, options) {
+	ms = function (val, options) {
 	  options = options || {};
 	  var type = typeof val;
 	  if (type === 'string' && val.length > 0) {
@@ -4314,7 +4316,6 @@ var debug = /*@__PURE__*/getDefaultExportFromCjs(browserExports);
 
 const APP_NAME = "waku";
 let Logger$1 = class Logger {
-    _debug;
     _info;
     _warn;
     _error;
@@ -4322,14 +4323,10 @@ let Logger$1 = class Logger {
         return prefix ? `${APP_NAME}:${level}:${prefix}` : `${APP_NAME}:${level}`;
     }
     constructor(prefix) {
-        this._debug = debug(Logger.createDebugNamespace("debug", prefix));
         this._info = debug(Logger.createDebugNamespace("info", prefix));
         this._warn = debug(Logger.createDebugNamespace("warn", prefix));
         this._error = debug(Logger.createDebugNamespace("error", prefix));
     }
-    get debug() {
-        return this._debug;
-    }
     get info() {
         return this._info;
     }
@@ -4345,34 +4342,6 @@ let Logger$1 = class Logger {
     }
 };
 
-const peerIdSymbol = Symbol.for('@libp2p/peer-id');
-
-/**
- * When this error is thrown it means an operation was aborted,
- * usually in response to the `abort` event being emitted by an
- * AbortSignal.
- */
-class CodeError extends Error {
-    code;
-    props;
-    constructor(message, code, props) {
-        super(message);
-        this.code = code;
-        this.name = props?.name ?? 'CodeError';
-        this.props = props ?? {}; // eslint-disable-line @typescript-eslint/consistent-type-assertions
-    }
-}
-class AggregateCodeError extends AggregateError {
-    code;
-    props;
-    constructor(errors, message, code, props) {
-        super(errors, message);
-        this.code = code;
-        this.name = props?.name ?? 'AggregateCodeError';
-        this.props = props ?? {}; // eslint-disable-line @typescript-eslint/consistent-type-assertions
-    }
-}
-
 /**
  * Returns true if the two passed Uint8Arrays have the same content
  */
@@ -5430,6 +5399,12 @@ const DNS_CODES = [
     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}
  */
@@ -5599,7 +5574,7 @@ class Multiaddr {
         }
         const resolver = resolvers.get(resolvableProto.name);
         if (resolver == null) {
-            throw new CodeError(`no available resolver for ${resolvableProto.name}`, 'ERR_NO_AVAILABLE_RESOLVER');
+            throw new NoAvailableResolverError(`no available resolver for ${resolvableProto.name}`);
         }
         const result = await resolver(this, options);
         return result.map(str => multiaddr(str));
@@ -5813,13 +5788,30 @@ function locationMultiaddrFromEnrFields(enr, protocol) {
     return multiaddrFromFields(isIpv6 ? "ip6" : "ip4", protoName, ipVal, protoVal);
 }
 
-function isPromise(thing) {
-    if (thing == null) {
-        return false;
+/**
+ * When this error is thrown it means an operation was aborted,
+ * usually in response to the `abort` event being emitted by an
+ * AbortSignal.
+ */
+/**
+ * Thrown when invalid parameters are passed to a function or method call
+ */
+class InvalidParametersError extends Error {
+    static name = 'InvalidParametersError';
+    constructor(message = 'Invalid parameters') {
+        super(message);
+        this.name = 'InvalidParametersError';
+    }
+}
+/**
+ * Thrown when a public key is invalid
+ */
+class InvalidPublicKeyError extends Error {
+    static name = 'InvalidPublicKeyError';
+    constructor(message = 'Invalid public key') {
+        super(message);
+        this.name = 'InvalidPublicKeyError';
     }
-    return typeof thing.then === 'function' &&
-        typeof thing.catch === 'function' &&
-        typeof thing.finally === 'function';
 }
 
 const U32_MASK64 = /* @__PURE__ */ BigInt(2 ** 32 - 1);
@@ -6907,6 +6899,60 @@ function wNAF(c, bits) {
         },
     };
 }
+/**
+ * Pippenger algorithm for multi-scalar multiplication (MSM).
+ * MSM is basically (Pa + Qb + Rc + ...).
+ * 30x faster vs naive addition on L=4096, 10x faster with precomputes.
+ * For N=254bit, L=1, it does: 1024 ADD + 254 DBL. For L=5: 1536 ADD + 254 DBL.
+ * Algorithmically constant-time (for same L), even when 1 point + scalar, or when scalar = 0.
+ * @param c Curve Point constructor
+ * @param field field over CURVE.N - important that it's not over CURVE.P
+ * @param points array of L curve points
+ * @param scalars array of L scalars (aka private keys / bigints)
+ */
+function pippenger(c, field, points, scalars) {
+    // If we split scalars by some window (let's say 8 bits), every chunk will only
+    // take 256 buckets even if there are 4096 scalars, also re-uses double.
+    // TODO:
+    // - https://eprint.iacr.org/2024/750.pdf
+    // - https://tches.iacr.org/index.php/TCHES/article/view/10287
+    // 0 is accepted in scalars
+    if (!Array.isArray(points) || !Array.isArray(scalars) || scalars.length !== points.length)
+        throw new Error('arrays of points and scalars must have equal length');
+    scalars.forEach((s, i) => {
+        if (!field.isValid(s))
+            throw new Error(`wrong scalar at index ${i}`);
+    });
+    points.forEach((p, i) => {
+        if (!(p instanceof c))
+            throw new Error(`wrong point at index ${i}`);
+    });
+    const wbits = bitLen(BigInt(points.length));
+    const windowSize = wbits > 12 ? wbits - 3 : wbits > 4 ? wbits - 2 : wbits ? 2 : 1; // in bits
+    const MASK = (1 << windowSize) - 1;
+    const buckets = new Array(MASK + 1).fill(c.ZERO); // +1 for zero array
+    const lastBits = Math.floor((field.BITS - 1) / windowSize) * windowSize;
+    let sum = c.ZERO;
+    for (let i = lastBits; i >= 0; i -= windowSize) {
+        buckets.fill(c.ZERO);
+        for (let j = 0; j < scalars.length; j++) {
+            const scalar = scalars[j];
+            const wbits = Number((scalar >> BigInt(i)) & BigInt(MASK));
+            buckets[wbits] = buckets[wbits].add(points[j]);
+        }
+        let resI = c.ZERO; // not using this will do small speed-up, but will lose ct
+        // Skip first bucket, because it is zero
+        for (let j = buckets.length - 1, sumI = c.ZERO; j > 0; j--) {
+            sumI = sumI.add(buckets[j]);
+            resI = resI.add(sumI);
+        }
+        sum = sum.add(resI);
+        if (i !== 0)
+            for (let j = 0; j < windowSize; j++)
+                sum = sum.double();
+    }
+    return sum;
+}
 function validateBasic(curve) {
     validateField(curve.Fp);
     validateObject(curve, {
@@ -6961,6 +7007,7 @@ function twistedEdwards(curveDef) {
     const { Fp, n: CURVE_ORDER, prehash: prehash, hash: cHash, randomBytes, nByteLength, h: cofactor, } = CURVE;
     const MASK = _2n$2 << (BigInt(nByteLength * 8) - _1n$3);
     const modP = Fp.create; // Function overrides
+    const Fn = Field(CURVE.n, CURVE.nBitLength);
     // sqrt(u/v)
     const uvRatio = CURVE.uvRatio ||
         ((u, v) => {
@@ -7059,6 +7106,10 @@ function twistedEdwards(curveDef) {
             const toInv = Fp.invertBatch(points.map((p) => p.ez));
             return points.map((p, i) => p.toAffine(toInv[i])).map(Point.fromAffine);
         }
+        // Multiscalar Multiplication
+        static msm(points, scalars) {
+            return pippenger(Point, Fn, points, scalars);
+        }
         // "Private method", don't use it directly
         _setWindowSize(windowSize) {
             wnaf.setWindowSize(this, windowSize);
@@ -7434,7 +7485,7 @@ const ed25519Defaults = /* @__PURE__ */ (() => ({
     Gx: BigInt('15112221349535400772501151409588531511454012693041857206046113283949847762202'),
     Gy: BigInt('46316835694926478169428394003475163141307993866256225615783033603165251855960'),
     hash: sha512,
-    randomBytes: randomBytes$1,
+    randomBytes,
     adjustScalarBytes,
     // dom2
     // Ratio of u to v. Allows us to combine inversion and square root. Uses algo from RFC8032 5.1.3.
@@ -7447,176 +7498,46 @@ const ed25519Defaults = /* @__PURE__ */ (() => ({
 const ed25519 = /* @__PURE__ */ (() => twistedEdwards(ed25519Defaults))();
 
 const PUBLIC_KEY_BYTE_LENGTH = 32;
-const PRIVATE_KEY_BYTE_LENGTH = 64; // private key is actually 32 bytes but for historical reasons we concat private and public keys
-const KEYS_BYTE_LENGTH = 32;
-function generateKey$2() {
-    // the actual private key (32 bytes)
-    const privateKeyRaw = ed25519.utils.randomPrivateKey();
-    const publicKey = ed25519.getPublicKey(privateKeyRaw);
-    // concatenated the public key to the private key
-    const privateKey = concatKeys(privateKeyRaw, publicKey);
-    return {
-        privateKey,
-        publicKey
-    };
-}
-/**
- * Generate keypair from a 32 byte uint8array
- */
-function generateKeyFromSeed(seed) {
-    if (seed.length !== KEYS_BYTE_LENGTH) {
-        throw new TypeError('"seed" must be 32 bytes in length.');
-    }
-    else if (!(seed instanceof Uint8Array)) {
-        throw new TypeError('"seed" must be a node.js Buffer, or Uint8Array.');
-    }
-    // based on node forges algorithm, the seed is used directly as private key
-    const privateKeyRaw = seed;
-    const publicKey = ed25519.getPublicKey(privateKeyRaw);
-    const privateKey = concatKeys(privateKeyRaw, publicKey);
-    return {
-        privateKey,
-        publicKey
-    };
-}
-function hashAndSign$2(privateKey, msg) {
-    const privateKeyRaw = privateKey.subarray(0, KEYS_BYTE_LENGTH);
-    return ed25519.sign(msg instanceof Uint8Array ? msg : msg.subarray(), privateKeyRaw);
-}
 function hashAndVerify$2(publicKey, sig, msg) {
     return ed25519.verify(sig, msg instanceof Uint8Array ? msg : msg.subarray(), publicKey);
 }
-function concatKeys(privateKeyRaw, publicKey) {
-    const privateKey = new Uint8Array(PRIVATE_KEY_BYTE_LENGTH);
-    for (let i = 0; i < KEYS_BYTE_LENGTH; i++) {
-        privateKey[i] = privateKeyRaw[i];
-        privateKey[KEYS_BYTE_LENGTH + i] = publicKey[i];
-    }
-    return privateKey;
-}
 
-/* eslint-env browser */
-// Check native crypto exists and is enabled (In insecure context `self.crypto`
-// exists but `self.crypto.subtle` does not).
-var webcrypto = {
-    get(win = globalThis) {
-        const nativeCrypto = win.crypto;
-        if (nativeCrypto?.subtle == null) {
-            throw Object.assign(new Error('Missing Web Crypto API. ' +
-                'The most likely cause of this error is that this page is being accessed ' +
-                'from an insecure context (i.e. not HTTPS). For more information and ' +
-                'possible resolutions see ' +
-                'https://github.com/libp2p/js-libp2p/blob/main/packages/crypto/README.md#web-crypto-api'), { code: 'ERR_MISSING_WEB_CRYPTO' });
-        }
-        return nativeCrypto;
+class Ed25519PublicKey {
+    type = 'Ed25519';
+    raw;
+    constructor(key) {
+        this.raw = ensureEd25519Key(key, PUBLIC_KEY_BYTE_LENGTH);
     }
-};
-
-// WebKit on Linux does not support deriving a key from an empty PBKDF2 key.
-// So, as a workaround, we provide the generated key as a constant. We test that
-// this generated key is accurate in test/workaround.spec.ts
-// Generated via:
-// await crypto.subtle.exportKey('jwk',
-//   await crypto.subtle.deriveKey(
-//     { name: 'PBKDF2', salt: new Uint8Array(16), iterations: 32767, hash: { name: 'SHA-256' } },
-//     await crypto.subtle.importKey('raw', new Uint8Array(0), { name: 'PBKDF2' }, false, ['deriveKey']),
-//     { name: 'AES-GCM', length: 128 }, true, ['encrypt', 'decrypt'])
-// )
-const derivedEmptyPasswordKey = { alg: 'A128GCM', ext: true, k: 'scm9jmO_4BJAgdwWGVulLg', key_ops: ['encrypt', 'decrypt'], kty: 'oct' };
-// Based off of code from https://github.com/luke-park/SecureCompatibleEncryptionExamples
-function create(opts) {
-    const algorithm = 'AES-GCM';
-    let keyLength = 16;
-    const nonceLength = 12;
-    const digest = 'SHA-256';
-    const saltLength = 16;
-    const iterations = 32767;
-    const crypto = webcrypto.get();
-    keyLength *= 8; // Browser crypto uses bits instead of bytes
-    /**
-     * Uses the provided password to derive a pbkdf2 key. The key
-     * will then be used to encrypt the data.
-     */
-    async function encrypt(data, password) {
-        const salt = crypto.getRandomValues(new Uint8Array(saltLength));
-        const nonce = crypto.getRandomValues(new Uint8Array(nonceLength));
-        const aesGcm = { name: algorithm, iv: nonce };
-        if (typeof password === 'string') {
-            password = fromString(password);
-        }
-        let cryptoKey;
-        if (password.length === 0) {
-            cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, { name: 'AES-GCM' }, true, ['encrypt']);
-            try {
-                const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } };
-                const runtimeDerivedEmptyPassword = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey']);
-                cryptoKey = await crypto.subtle.deriveKey(deriveParams, runtimeDerivedEmptyPassword, { name: algorithm, length: keyLength }, true, ['encrypt']);
-            }
-            catch {
-                cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, { name: 'AES-GCM' }, true, ['encrypt']);
-            }
-        }
-        else {
-            // Derive a key using PBKDF2.
-            const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } };
-            const rawKey = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey']);
-            cryptoKey = await crypto.subtle.deriveKey(deriveParams, rawKey, { name: algorithm, length: keyLength }, true, ['encrypt']);
-        }
-        // Encrypt the string.
-        const ciphertext = await crypto.subtle.encrypt(aesGcm, cryptoKey, data);
-        return concat$1([salt, aesGcm.iv, new Uint8Array(ciphertext)]);
-    }
-    /**
-     * Uses the provided password to derive a pbkdf2 key. The key
-     * will then be used to decrypt the data. The options used to create
-     * this decryption cipher must be the same as those used to create
-     * the encryption cipher.
-     */
-    async function decrypt(data, password) {
-        const salt = data.subarray(0, saltLength);
-        const nonce = data.subarray(saltLength, saltLength + nonceLength);
-        const ciphertext = data.subarray(saltLength + nonceLength);
-        const aesGcm = { name: algorithm, iv: nonce };
-        if (typeof password === 'string') {
-            password = fromString(password);
-        }
-        let cryptoKey;
-        if (password.length === 0) {
-            try {
-                const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } };
-                const runtimeDerivedEmptyPassword = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey']);
-                cryptoKey = await crypto.subtle.deriveKey(deriveParams, runtimeDerivedEmptyPassword, { name: algorithm, length: keyLength }, true, ['decrypt']);
-            }
-            catch {
-                cryptoKey = await crypto.subtle.importKey('jwk', derivedEmptyPasswordKey, { name: 'AES-GCM' }, true, ['decrypt']);
-            }
+    toMultihash() {
+        return identity.digest(publicKeyToProtobuf(this));
+    }
+    toCID() {
+        return CID.createV1(114, this.toMultihash());
+    }
+    toString() {
+        return base58btc.encode(this.toMultihash().bytes).substring(1);
+    }
+    equals(key) {
+        if (key == null || !(key.raw instanceof Uint8Array)) {
+            return false;
         }
-        else {
-            // Derive the key using PBKDF2.
-            const deriveParams = { name: 'PBKDF2', salt, iterations, hash: { name: digest } };
-            const rawKey = await crypto.subtle.importKey('raw', password, { name: 'PBKDF2' }, false, ['deriveKey']);
-            cryptoKey = await crypto.subtle.deriveKey(deriveParams, rawKey, { name: algorithm, length: keyLength }, true, ['decrypt']);
-        }
-        // Decrypt the string.
-        const plaintext = await crypto.subtle.decrypt(aesGcm, cryptoKey, ciphertext);
-        return new Uint8Array(plaintext);
-    }
-    const cipher = {
-        encrypt,
-        decrypt
-    };
-    return cipher;
+        return equals(this.raw, key.raw);
+    }
+    verify(data, sig) {
+        return hashAndVerify$2(this.raw, sig, data);
+    }
 }
 
-/**
- * Exports the given PrivateKey as a base64 encoded string.
- * The PrivateKey is encrypted via a password derived PBKDF2 key
- * leveraging the aes-gcm cipher algorithm.
- */
-async function exporter(privateKey, password) {
-    const cipher = create();
-    const encryptedKey = await cipher.encrypt(privateKey, password);
-    return base64.encode(encryptedKey);
+function unmarshalEd25519PublicKey(bytes) {
+    bytes = ensureEd25519Key(bytes, PUBLIC_KEY_BYTE_LENGTH);
+    return new Ed25519PublicKey(bytes);
+}
+function ensureEd25519Key(key, length) {
+    key = Uint8Array.from(key ?? []);
+    if (key.length !== length) {
+        throw new InvalidParametersError(`Key must be a Uint8Array of length ${length}, got ${key.length}`);
+    }
+    return key;
 }
 
 const f32 = new Float32Array([-0]);
@@ -8825,13 +8746,13 @@ var KeyType;
 (function (KeyType) {
     KeyType["RSA"] = "RSA";
     KeyType["Ed25519"] = "Ed25519";
-    KeyType["Secp256k1"] = "Secp256k1";
+    KeyType["secp256k1"] = "secp256k1";
 })(KeyType || (KeyType = {}));
 var __KeyTypeValues;
 (function (__KeyTypeValues) {
     __KeyTypeValues[__KeyTypeValues["RSA"] = 0] = "RSA";
     __KeyTypeValues[__KeyTypeValues["Ed25519"] = 1] = "Ed25519";
-    __KeyTypeValues[__KeyTypeValues["Secp256k1"] = 2] = "Secp256k1";
+    __KeyTypeValues[__KeyTypeValues["secp256k1"] = 2] = "secp256k1";
 })(__KeyTypeValues || (__KeyTypeValues = {}));
 (function (KeyType) {
     KeyType.codec = () => {
@@ -8858,21 +8779,24 @@ var PublicKey;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {};
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.Type = KeyType.codec().decode(reader);
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.Data = reader.bytes();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -8883,8 +8807,8 @@ var PublicKey;
     PublicKey.encode = (obj) => {
         return encodeMessage(obj, PublicKey.codec());
     };
-    PublicKey.decode = (buf) => {
-        return decodeMessage(buf, PublicKey.codec());
+    PublicKey.decode = (buf, opts) => {
+        return decodeMessage(buf, PublicKey.codec(), opts);
     };
 })(PublicKey || (PublicKey = {}));
 var PrivateKey;
@@ -8907,21 +8831,24 @@ var PrivateKey;
                 if (opts.lengthDelimited !== false) {
                     w.ldelim();
                 }
-            }, (reader, length) => {
+            }, (reader, length, opts = {}) => {
                 const obj = {};
                 const end = length == null ? reader.len : reader.pos + length;
                 while (reader.pos < end) {
                     const tag = reader.uint32();
                     switch (tag >>> 3) {
-                        case 1:
+                        case 1: {
                             obj.Type = KeyType.codec().decode(reader);
                             break;
-                        case 2:
+                        }
+                        case 2: {
                             obj.Data = reader.bytes();
                             break;
-                        default:
+                        }
+                        default: {
                             reader.skipType(tag & 7);
                             break;
+                        }
                     }
                 }
                 return obj;
@@ -8932,393 +8859,122 @@ var PrivateKey;
     PrivateKey.encode = (obj) => {
         return encodeMessage(obj, PrivateKey.codec());
     };
-    PrivateKey.decode = (buf) => {
-        return decodeMessage(buf, PrivateKey.codec());
+    PrivateKey.decode = (buf, opts) => {
+        return decodeMessage(buf, PrivateKey.codec(), opts);
     };
 })(PrivateKey || (PrivateKey = {}));
 
-class Ed25519PublicKey {
-    _key;
-    constructor(key) {
-        this._key = ensureKey(key, PUBLIC_KEY_BYTE_LENGTH);
-    }
-    verify(data, sig) {
-        return hashAndVerify$2(this._key, sig, data);
-    }
-    marshal() {
-        return this._key;
-    }
-    get bytes() {
-        return PublicKey.encode({
-            Type: KeyType.Ed25519,
-            Data: this.marshal()
-        }).subarray();
-    }
-    equals(key) {
-        return equals(this.bytes, key.bytes);
+/*!
+ * MIT License
+ * 
+ * Copyright (c) 2017-2022 Peculiar Ventures, LLC
+ * 
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ * 
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ * 
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ * 
+ */
+
+const ARRAY_BUFFER_NAME = "[object ArrayBuffer]";
+class BufferSourceConverter {
+    static isArrayBuffer(data) {
+        return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME;
     }
-    hash() {
-        const p = sha256$1.digest(this.bytes);
-        if (isPromise(p)) {
-            return p.then(({ bytes }) => bytes);
+    static toArrayBuffer(data) {
+        if (this.isArrayBuffer(data)) {
+            return data;
         }
-        return p.bytes;
-    }
-}
-class Ed25519PrivateKey {
-    _key;
-    _publicKey;
-    // key       - 64 byte Uint8Array containing private key
-    // publicKey - 32 byte Uint8Array containing public key
-    constructor(key, publicKey) {
-        this._key = ensureKey(key, PRIVATE_KEY_BYTE_LENGTH);
-        this._publicKey = ensureKey(publicKey, PUBLIC_KEY_BYTE_LENGTH);
-    }
-    sign(message) {
-        return hashAndSign$2(this._key, message);
+        if (data.byteLength === data.buffer.byteLength) {
+            return data.buffer;
+        }
+        if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
+            return data.buffer;
+        }
+        return this.toUint8Array(data.buffer)
+            .slice(data.byteOffset, data.byteOffset + data.byteLength)
+            .buffer;
     }
-    get public() {
-        return new Ed25519PublicKey(this._publicKey);
+    static toUint8Array(data) {
+        return this.toView(data, Uint8Array);
     }
-    marshal() {
-        return this._key;
+    static toView(data, type) {
+        if (data.constructor === type) {
+            return data;
+        }
+        if (this.isArrayBuffer(data)) {
+            return new type(data);
+        }
+        if (this.isArrayBufferView(data)) {
+            return new type(data.buffer, data.byteOffset, data.byteLength);
+        }
+        throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
     }
-    get bytes() {
-        return PrivateKey.encode({
-            Type: KeyType.Ed25519,
-            Data: this.marshal()
-        }).subarray();
+    static isBufferSource(data) {
+        return this.isArrayBufferView(data)
+            || this.isArrayBuffer(data);
     }
-    equals(key) {
-        return equals(this.bytes, key.bytes);
+    static isArrayBufferView(data) {
+        return ArrayBuffer.isView(data)
+            || (data && this.isArrayBuffer(data.buffer));
     }
-    async hash() {
-        const p = sha256$1.digest(this.bytes);
-        let bytes;
-        if (isPromise(p)) {
-            ({ bytes } = await p);
+    static isEqual(a, b) {
+        const aView = BufferSourceConverter.toUint8Array(a);
+        const bView = BufferSourceConverter.toUint8Array(b);
+        if (aView.length !== bView.byteLength) {
+            return false;
         }
-        else {
-            bytes = p.bytes;
+        for (let i = 0; i < aView.length; i++) {
+            if (aView[i] !== bView[i]) {
+                return false;
+            }
         }
-        return bytes;
-    }
-    /**
-     * Gets the ID of the key.
-     *
-     * The key id is the base58 encoding of the identity multihash containing its public key.
-     * The public key is a protobuf encoding containing a type and the DER encoding
-     * of the PKCS SubjectPublicKeyInfo.
-     *
-     * @returns {Promise<string>}
-     */
-    async id() {
-        const encoding = identity.digest(this.public.bytes);
-        return base58btc.encode(encoding.bytes).substring(1);
+        return true;
     }
-    /**
-     * Exports the key into a password protected `format`
-     */
-    async export(password, format = 'libp2p-key') {
-        if (format === 'libp2p-key') {
-            return exporter(this.bytes, password);
+    static concat(...args) {
+        let buffers;
+        if (Array.isArray(args[0]) && !(args[1] instanceof Function)) {
+            buffers = args[0];
+        }
+        else if (Array.isArray(args[0]) && args[1] instanceof Function) {
+            buffers = args[0];
         }
         else {
-            throw new CodeError(`export format '${format}' is not supported`, 'ERR_INVALID_EXPORT_FORMAT');
+            if (args[args.length - 1] instanceof Function) {
+                buffers = args.slice(0, args.length - 1);
+            }
+            else {
+                buffers = args;
+            }
         }
-    }
-}
-function unmarshalEd25519PrivateKey(bytes) {
-    // Try the old, redundant public key version
-    if (bytes.length > PRIVATE_KEY_BYTE_LENGTH) {
-        bytes = ensureKey(bytes, PRIVATE_KEY_BYTE_LENGTH + PUBLIC_KEY_BYTE_LENGTH);
-        const privateKeyBytes = bytes.subarray(0, PRIVATE_KEY_BYTE_LENGTH);
-        const publicKeyBytes = bytes.subarray(PRIVATE_KEY_BYTE_LENGTH, bytes.length);
-        return new Ed25519PrivateKey(privateKeyBytes, publicKeyBytes);
-    }
-    bytes = ensureKey(bytes, PRIVATE_KEY_BYTE_LENGTH);
-    const privateKeyBytes = bytes.subarray(0, PRIVATE_KEY_BYTE_LENGTH);
-    const publicKeyBytes = bytes.subarray(PUBLIC_KEY_BYTE_LENGTH);
-    return new Ed25519PrivateKey(privateKeyBytes, publicKeyBytes);
-}
-function unmarshalEd25519PublicKey(bytes) {
-    bytes = ensureKey(bytes, PUBLIC_KEY_BYTE_LENGTH);
-    return new Ed25519PublicKey(bytes);
-}
-async function generateKeyPair$2() {
-    const { privateKey, publicKey } = generateKey$2();
-    return new Ed25519PrivateKey(privateKey, publicKey);
-}
-async function generateKeyPairFromSeed(seed) {
-    const { privateKey, publicKey } = generateKeyFromSeed(seed);
-    return new Ed25519PrivateKey(privateKey, publicKey);
-}
-function ensureKey(key, length) {
-    key = Uint8Array.from(key ?? []);
-    if (key.length !== length) {
-        throw new CodeError(`Key must be a Uint8Array of length ${length}, got ${key.length}`, 'ERR_INVALID_KEY_TYPE');
-    }
-    return key;
-}
-
-var Ed25519 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Ed25519PrivateKey: Ed25519PrivateKey,
-    Ed25519PublicKey: Ed25519PublicKey,
-    generateKeyPair: generateKeyPair$2,
-    generateKeyPairFromSeed: generateKeyPairFromSeed,
-    unmarshalEd25519PrivateKey: unmarshalEd25519PrivateKey,
-    unmarshalEd25519PublicKey: unmarshalEd25519PublicKey
-});
-
-/**
- * Generates a Uint8Array with length `number` populated by random bytes
- */
-function randomBytes(length) {
-    if (isNaN(length) || length <= 0) {
-        throw new CodeError('random bytes length must be a Number bigger than 0', 'ERR_INVALID_LENGTH');
-    }
-    return randomBytes$1(length);
-}
-
-// HMAC (RFC 2104)
-class HMAC extends Hash {
-    constructor(hash$1, _key) {
-        super();
-        this.finished = false;
-        this.destroyed = false;
-        hash(hash$1);
-        const key = toBytes$1(_key);
-        this.iHash = hash$1.create();
-        if (typeof this.iHash.update !== 'function')
-            throw new Error('Expected instance of class which extends utils.Hash');
-        this.blockLen = this.iHash.blockLen;
-        this.outputLen = this.iHash.outputLen;
-        const blockLen = this.blockLen;
-        const pad = new Uint8Array(blockLen);
-        // blockLen can be bigger than outputLen
-        pad.set(key.length > blockLen ? hash$1.create().update(key).digest() : key);
-        for (let i = 0; i < pad.length; i++)
-            pad[i] ^= 0x36;
-        this.iHash.update(pad);
-        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone
-        this.oHash = hash$1.create();
-        // Undo internal XOR && apply outer XOR
-        for (let i = 0; i < pad.length; i++)
-            pad[i] ^= 0x36 ^ 0x5c;
-        this.oHash.update(pad);
-        pad.fill(0);
-    }
-    update(buf) {
-        exists(this);
-        this.iHash.update(buf);
-        return this;
-    }
-    digestInto(out) {
-        exists(this);
-        bytes(out, this.outputLen);
-        this.finished = true;
-        this.iHash.digestInto(out);
-        this.oHash.update(out);
-        this.oHash.digestInto(out);
-        this.destroy();
-    }
-    digest() {
-        const out = new Uint8Array(this.oHash.outputLen);
-        this.digestInto(out);
-        return out;
-    }
-    _cloneInto(to) {
-        // Create new instance without calling constructor since key already in state and we don't know it.
-        to || (to = Object.create(Object.getPrototypeOf(this), {}));
-        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
-        to = to;
-        to.finished = finished;
-        to.destroyed = destroyed;
-        to.blockLen = blockLen;
-        to.outputLen = outputLen;
-        to.oHash = oHash._cloneInto(to.oHash);
-        to.iHash = iHash._cloneInto(to.iHash);
-        return to;
-    }
-    destroy() {
-        this.destroyed = true;
-        this.oHash.destroy();
-        this.iHash.destroy();
-    }
-}
-/**
- * HMAC: RFC2104 message authentication code.
- * @param hash - function that would be used e.g. sha256
- * @param key - message key
- * @param message - message data
- */
-const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
-hmac.create = (hash, key) => new HMAC(hash, key);
-
-// Common prologue and epilogue for sync/async functions
-function pbkdf2Init(hash$1, _password, _salt, _opts) {
-    hash(hash$1);
-    const opts = checkOpts({ dkLen: 32, asyncTick: 10 }, _opts);
-    const { c, dkLen, asyncTick } = opts;
-    number(c);
-    number(dkLen);
-    number(asyncTick);
-    if (c < 1)
-        throw new Error('PBKDF2: iterations (c) should be >= 1');
-    const password = toBytes$1(_password);
-    const salt = toBytes$1(_salt);
-    // DK = PBKDF2(PRF, Password, Salt, c, dkLen);
-    const DK = new Uint8Array(dkLen);
-    // U1 = PRF(Password, Salt + INT_32_BE(i))
-    const PRF = hmac.create(hash$1, password);
-    const PRFSalt = PRF._cloneInto().update(salt);
-    return { c, dkLen, asyncTick, DK, PRF, PRFSalt };
-}
-function pbkdf2Output(PRF, PRFSalt, DK, prfW, u) {
-    PRF.destroy();
-    PRFSalt.destroy();
-    if (prfW)
-        prfW.destroy();
-    u.fill(0);
-    return DK;
-}
-async function pbkdf2Async(hash, password, salt, opts) {
-    const { c, dkLen, asyncTick, DK, PRF, PRFSalt } = pbkdf2Init(hash, password, salt, opts);
-    let prfW; // Working copy
-    const arr = new Uint8Array(4);
-    const view = createView(arr);
-    const u = new Uint8Array(PRF.outputLen);
-    // DK = T1 + T2 + ⋯ + Tdklen/hlen
-    for (let ti = 1, pos = 0; pos < dkLen; ti++, pos += PRF.outputLen) {
-        // Ti = F(Password, Salt, c, i)
-        const Ti = DK.subarray(pos, pos + PRF.outputLen);
-        view.setInt32(0, ti, false);
-        // F(Password, Salt, c, i) = U1 ^ U2 ^ ⋯ ^ Uc
-        // U1 = PRF(Password, Salt + INT_32_BE(i))
-        (prfW = PRFSalt._cloneInto(prfW)).update(arr).digestInto(u);
-        Ti.set(u.subarray(0, Ti.length));
-        await asyncLoop(c - 1, asyncTick, () => {
-            // Uc = PRF(Password, Uc−1)
-            PRF._cloneInto(prfW).update(u).digestInto(u);
-            for (let i = 0; i < Ti.length; i++)
-                Ti[i] ^= u[i];
-        });
-    }
-    return pbkdf2Output(PRF, PRFSalt, DK, prfW, u);
-}
-
-/*!
- * MIT License
- * 
- * Copyright (c) 2017-2022 Peculiar Ventures, LLC
- * 
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- * 
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- * 
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- * 
- */
-
-const ARRAY_BUFFER_NAME = "[object ArrayBuffer]";
-class BufferSourceConverter {
-    static isArrayBuffer(data) {
-        return Object.prototype.toString.call(data) === ARRAY_BUFFER_NAME;
-    }
-    static toArrayBuffer(data) {
-        if (this.isArrayBuffer(data)) {
-            return data;
-        }
-        if (data.byteLength === data.buffer.byteLength) {
-            return data.buffer;
-        }
-        if (data.byteOffset === 0 && data.byteLength === data.buffer.byteLength) {
-            return data.buffer;
-        }
-        return this.toUint8Array(data.buffer)
-            .slice(data.byteOffset, data.byteOffset + data.byteLength)
-            .buffer;
-    }
-    static toUint8Array(data) {
-        return this.toView(data, Uint8Array);
-    }
-    static toView(data, type) {
-        if (data.constructor === type) {
-            return data;
-        }
-        if (this.isArrayBuffer(data)) {
-            return new type(data);
-        }
-        if (this.isArrayBufferView(data)) {
-            return new type(data.buffer, data.byteOffset, data.byteLength);
-        }
-        throw new TypeError("The provided value is not of type '(ArrayBuffer or ArrayBufferView)'");
-    }
-    static isBufferSource(data) {
-        return this.isArrayBufferView(data)
-            || this.isArrayBuffer(data);
-    }
-    static isArrayBufferView(data) {
-        return ArrayBuffer.isView(data)
-            || (data && this.isArrayBuffer(data.buffer));
-    }
-    static isEqual(a, b) {
-        const aView = BufferSourceConverter.toUint8Array(a);
-        const bView = BufferSourceConverter.toUint8Array(b);
-        if (aView.length !== bView.byteLength) {
-            return false;
-        }
-        for (let i = 0; i < aView.length; i++) {
-            if (aView[i] !== bView[i]) {
-                return false;
-            }
-        }
-        return true;
-    }
-    static concat(...args) {
-        let buffers;
-        if (Array.isArray(args[0]) && !(args[1] instanceof Function)) {
-            buffers = args[0];
-        }
-        else if (Array.isArray(args[0]) && args[1] instanceof Function) {
-            buffers = args[0];
-        }
-        else {
-            if (args[args.length - 1] instanceof Function) {
-                buffers = args.slice(0, args.length - 1);
-            }
-            else {
-                buffers = args;
-            }
-        }
-        let size = 0;
-        for (const buffer of buffers) {
-            size += buffer.byteLength;
-        }
-        const res = new Uint8Array(size);
-        let offset = 0;
-        for (const buffer of buffers) {
-            const view = this.toUint8Array(buffer);
-            res.set(view, offset);
-            offset += view.length;
-        }
-        if (args[args.length - 1] instanceof Function) {
-            return this.toView(res, args[args.length - 1]);
-        }
-        return res.buffer;
+        let size = 0;
+        for (const buffer of buffers) {
+            size += buffer.byteLength;
+        }
+        const res = new Uint8Array(size);
+        let offset = 0;
+        for (const buffer of buffers) {
+            const view = this.toUint8Array(buffer);
+            res.set(view, offset);
+            offset += view.length;
+        }
+        if (args[args.length - 1] instanceof Function) {
+            return this.toView(res, args[args.length - 1]);
+        }
+        return res.buffer;
     }
 }
 
@@ -12459,272 +12115,44 @@ _a = TIME;
 TIME.NAME = "TIME";
 
 /**
- * Convert a PKCS#1 in ASN1 DER format to a JWK key
+ * Signing a message failed
  */
-function pkcs1ToJwk(bytes) {
-    const { result } = fromBER(bytes);
-    // @ts-expect-error this looks fragile but DER is a canonical format so we are
-    // safe to have deeply property chains like this
-    const values = result.valueBlock.value;
-    const key = {
-        n: toString$1(bnToBuf(values[1].toBigInt()), 'base64url'),
-        e: toString$1(bnToBuf(values[2].toBigInt()), 'base64url'),
-        d: toString$1(bnToBuf(values[3].toBigInt()), 'base64url'),
-        p: toString$1(bnToBuf(values[4].toBigInt()), 'base64url'),
-        q: toString$1(bnToBuf(values[5].toBigInt()), 'base64url'),
-        dp: toString$1(bnToBuf(values[6].toBigInt()), 'base64url'),
-        dq: toString$1(bnToBuf(values[7].toBigInt()), 'base64url'),
-        qi: toString$1(bnToBuf(values[8].toBigInt()), 'base64url'),
-        kty: 'RSA',
-        alg: 'RS256'
-    };
-    return key;
-}
 /**
- * Convert a JWK key into PKCS#1 in ASN1 DER format
+ * Verifying a message signature failed
  */
-function jwkToPkcs1(jwk) {
-    if (jwk.n == null || jwk.e == null || jwk.d == null || jwk.p == null || jwk.q == null || jwk.dp == null || jwk.dq == null || jwk.qi == null) {
-        throw new CodeError('JWK was missing components', 'ERR_INVALID_PARAMETERS');
+class VerificationError extends Error {
+    constructor(message = 'An error occurred while verifying a message') {
+        super(message);
+        this.name = 'VerificationError';
     }
-    const root = new Sequence({
-        value: [
-            new Integer({ value: 0 }),
-            Integer.fromBigInt(bufToBn(fromString(jwk.n, 'base64url'))),
-            Integer.fromBigInt(bufToBn(fromString(jwk.e, 'base64url'))),
-            Integer.fromBigInt(bufToBn(fromString(jwk.d, 'base64url'))),
-            Integer.fromBigInt(bufToBn(fromString(jwk.p, 'base64url'))),
-            Integer.fromBigInt(bufToBn(fromString(jwk.q, 'base64url'))),
-            Integer.fromBigInt(bufToBn(fromString(jwk.dp, 'base64url'))),
-            Integer.fromBigInt(bufToBn(fromString(jwk.dq, 'base64url'))),
-            Integer.fromBigInt(bufToBn(fromString(jwk.qi, 'base64url')))
-        ]
-    });
-    const der = root.toBER();
-    return new Uint8Array(der, 0, der.byteLength);
-}
-/**
- * Convert a PKCIX in ASN1 DER format to a JWK key
- */
-function pkixToJwk(bytes) {
-    const { result } = fromBER(bytes);
-    // @ts-expect-error this looks fragile but DER is a canonical format so we are
-    // safe to have deeply property chains like this
-    const values = result.valueBlock.value[1].valueBlock.value[0].valueBlock.value;
-    return {
-        kty: 'RSA',
-        n: toString$1(bnToBuf(values[0].toBigInt()), 'base64url'),
-        e: toString$1(bnToBuf(values[1].toBigInt()), 'base64url')
-    };
 }
 /**
- * Convert a JWK key to PKCIX in ASN1 DER format
+ * WebCrypto was not available in the current context
  */
-function jwkToPkix(jwk) {
-    if (jwk.n == null || jwk.e == null) {
-        throw new CodeError('JWK was missing components', 'ERR_INVALID_PARAMETERS');
-    }
-    const root = new Sequence({
-        value: [
-            new Sequence({
-                value: [
-                    // rsaEncryption
-                    new ObjectIdentifier({
-                        value: '1.2.840.113549.1.1.1'
-                    }),
-                    new Null()
-                ]
-            }),
-            // this appears to be a bug in asn1js.js - this should really be a Sequence
-            // and not a BitString but it generates the same bytes as node-forge so 🤷‍♂️
-            new BitString({
-                valueHex: new Sequence({
-                    value: [
-                        Integer.fromBigInt(bufToBn(fromString(jwk.n, 'base64url'))),
-                        Integer.fromBigInt(bufToBn(fromString(jwk.e, 'base64url')))
-                    ]
-                }).toBER()
-            })
-        ]
-    });
-    const der = root.toBER();
-    return new Uint8Array(der, 0, der.byteLength);
-}
-function bnToBuf(bn) {
-    let hex = bn.toString(16);
-    if (hex.length % 2 > 0) {
-        hex = `0${hex}`;
-    }
-    const len = hex.length / 2;
-    const u8 = new Uint8Array(len);
-    let i = 0;
-    let j = 0;
-    while (i < len) {
-        u8[i] = parseInt(hex.slice(j, j + 2), 16);
-        i += 1;
-        j += 2;
+class WebCryptoMissingError extends Error {
+    constructor(message = 'Missing Web Crypto API') {
+        super(message);
+        this.name = 'WebCryptoMissingError';
     }
-    return u8;
 }
-function bufToBn(u8) {
-    const hex = [];
-    u8.forEach(function (i) {
-        let h = i.toString(16);
-        if (h.length % 2 > 0) {
-            h = `0${h}`;
+
+/* eslint-env browser */
+// Check native crypto exists and is enabled (In insecure context `self.crypto`
+// exists but `self.crypto.subtle` does not).
+var webcrypto = {
+    get(win = globalThis) {
+        const nativeCrypto = win.crypto;
+        if (nativeCrypto?.subtle == null) {
+            throw new WebCryptoMissingError('Missing Web Crypto API. ' +
+                'The most likely cause of this error is that this page is being accessed ' +
+                'from an insecure context (i.e. not HTTPS). For more information and ' +
+                'possible resolutions see ' +
+                'https://github.com/libp2p/js-libp2p/blob/main/packages/crypto/README.md#web-crypto-api');
         }
-        hex.push(h);
-    });
-    return BigInt('0x' + hex.join(''));
-}
-const SALT_LENGTH = 16;
-const KEY_SIZE = 32;
-const ITERATIONS = 10000;
-async function exportToPem(privateKey, password) {
-    const crypto = webcrypto.get();
-    // PrivateKeyInfo
-    const keyWrapper = new Sequence({
-        value: [
-            // version (0)
-            new Integer({ value: 0 }),
-            // privateKeyAlgorithm
-            new Sequence({
-                value: [
-                    // rsaEncryption OID
-                    new ObjectIdentifier({
-                        value: '1.2.840.113549.1.1.1'
-                    }),
-                    new Null()
-                ]
-            }),
-            // PrivateKey
-            new OctetString({
-                valueHex: privateKey.marshal()
-            })
-        ]
-    });
-    const keyBuf = keyWrapper.toBER();
-    const keyArr = new Uint8Array(keyBuf, 0, keyBuf.byteLength);
-    const salt = randomBytes(SALT_LENGTH);
-    const encryptionKey = await pbkdf2Async(sha512, password, salt, {
-        c: ITERATIONS,
-        dkLen: KEY_SIZE
-    });
-    const iv = randomBytes(16);
-    const cryptoKey = await crypto.subtle.importKey('raw', encryptionKey, 'AES-CBC', false, ['encrypt']);
-    const encrypted = await crypto.subtle.encrypt({
-        name: 'AES-CBC',
-        iv
-    }, cryptoKey, keyArr);
-    const pbkdf2Params = new Sequence({
-        value: [
-            // salt
-            new OctetString({ valueHex: salt }),
-            // iteration count
-            new Integer({ value: ITERATIONS }),
-            // key length
-            new Integer({ value: KEY_SIZE }),
-            // AlgorithmIdentifier
-            new Sequence({
-                value: [
-                    // hmacWithSHA512
-                    new ObjectIdentifier({ value: '1.2.840.113549.2.11' }),
-                    new Null()
-                ]
-            })
-        ]
-    });
-    const encryptionAlgorithm = new Sequence({
-        value: [
-            // pkcs5PBES2
-            new ObjectIdentifier({
-                value: '1.2.840.113549.1.5.13'
-            }),
-            new Sequence({
-                value: [
-                    // keyDerivationFunc
-                    new Sequence({
-                        value: [
-                            // pkcs5PBKDF2
-                            new ObjectIdentifier({
-                                value: '1.2.840.113549.1.5.12'
-                            }),
-                            // PBKDF2-params
-                            pbkdf2Params
-                        ]
-                    }),
-                    // encryptionScheme
-                    new Sequence({
-                        value: [
-                            // aes256-CBC
-                            new ObjectIdentifier({
-                                value: '2.16.840.1.101.3.4.1.42'
-                            }),
-                            // iv
-                            new OctetString({
-                                valueHex: iv
-                            })
-                        ]
-                    })
-                ]
-            })
-        ]
-    });
-    const finalWrapper = new Sequence({
-        value: [
-            encryptionAlgorithm,
-            new OctetString({ valueHex: encrypted })
-        ]
-    });
-    const finalWrapperBuf = finalWrapper.toBER();
-    const finalWrapperArr = new Uint8Array(finalWrapperBuf, 0, finalWrapperBuf.byteLength);
-    return [
-        '-----BEGIN ENCRYPTED PRIVATE KEY-----',
-        ...toString$1(finalWrapperArr, 'base64pad').split(/(.{64})/).filter(Boolean),
-        '-----END ENCRYPTED PRIVATE KEY-----'
-    ].join('\n');
-}
+        return nativeCrypto;
+    }
+};
 
-async function generateKey$1(bits) {
-    const pair = await webcrypto.get().subtle.generateKey({
-        name: 'RSASSA-PKCS1-v1_5',
-        modulusLength: bits,
-        publicExponent: new Uint8Array([0x01, 0x00, 0x01]),
-        hash: { name: 'SHA-256' }
-    }, true, ['sign', 'verify']);
-    const keys = await exportKey(pair);
-    return {
-        privateKey: keys[0],
-        publicKey: keys[1]
-    };
-}
-// Takes a jwk key
-async function unmarshalPrivateKey$1(key) {
-    const privateKey = await webcrypto.get().subtle.importKey('jwk', key, {
-        name: 'RSASSA-PKCS1-v1_5',
-        hash: { name: 'SHA-256' }
-    }, true, ['sign']);
-    const pair = [
-        privateKey,
-        await derivePublicFromPrivate(key)
-    ];
-    const keys = await exportKey({
-        privateKey: pair[0],
-        publicKey: pair[1]
-    });
-    return {
-        privateKey: keys[0],
-        publicKey: keys[1]
-    };
-}
-async function hashAndSign$1(key, msg) {
-    const privateKey = await webcrypto.get().subtle.importKey('jwk', key, {
-        name: 'RSASSA-PKCS1-v1_5',
-        hash: { name: 'SHA-256' }
-    }, false, ['sign']);
-    const sig = await webcrypto.get().subtle.sign({ name: 'RSASSA-PKCS1-v1_5' }, privateKey, msg instanceof Uint8Array ? msg : msg.subarray());
-    return new Uint8Array(sig, 0, sig.byteLength);
-}
 async function hashAndVerify$1(key, sig, msg) {
     const publicKey = await webcrypto.get().subtle.importKey('jwk', key, {
         name: 'RSASSA-PKCS1-v1_5',
@@ -12732,173 +12160,214 @@ async function hashAndVerify$1(key, sig, msg) {
     }, false, ['verify']);
     return webcrypto.get().subtle.verify({ name: 'RSASSA-PKCS1-v1_5' }, publicKey, sig, msg instanceof Uint8Array ? msg : msg.subarray());
 }
-async function exportKey(pair) {
-    if (pair.privateKey == null || pair.publicKey == null) {
-        throw new CodeError('Private and public key are required', 'ERR_INVALID_PARAMETERS');
-    }
-    return Promise.all([
-        webcrypto.get().subtle.exportKey('jwk', pair.privateKey),
-        webcrypto.get().subtle.exportKey('jwk', pair.publicKey)
-    ]);
-}
-async function derivePublicFromPrivate(jwKey) {
-    return webcrypto.get().subtle.importKey('jwk', {
-        kty: jwKey.kty,
-        n: jwKey.n,
-        e: jwKey.e
-    }, {
-        name: 'RSASSA-PKCS1-v1_5',
-        hash: { name: 'SHA-256' }
-    }, true, ['verify']);
-}
-function keySize(jwk) {
+function rsaKeySize(jwk) {
     if (jwk.kty !== 'RSA') {
-        throw new CodeError('invalid key type', 'ERR_INVALID_KEY_TYPE');
+        throw new InvalidParametersError('invalid key type');
     }
     else if (jwk.n == null) {
-        throw new CodeError('invalid key modulus', 'ERR_INVALID_KEY_MODULUS');
+        throw new InvalidParametersError('invalid key modulus');
     }
     const bytes = fromString(jwk.n, 'base64url');
     return bytes.length * 8;
 }
 
-const MAX_RSA_KEY_SIZE = 8192;
-class RsaPublicKey {
+class RSAPublicKey {
+    type = 'RSA';
     _key;
-    constructor(key) {
+    _raw;
+    _multihash;
+    constructor(key, digest) {
         this._key = key;
+        this._multihash = digest;
     }
-    verify(data, sig) {
-        return hashAndVerify$1(this._key, sig, data);
-    }
-    marshal() {
-        return jwkToPkix(this._key);
-    }
-    get bytes() {
-        return PublicKey.encode({
-            Type: KeyType.RSA,
-            Data: this.marshal()
-        }).subarray();
-    }
-    equals(key) {
-        return equals(this.bytes, key.bytes);
-    }
-    hash() {
-        const p = sha256$1.digest(this.bytes);
-        if (isPromise(p)) {
-            return p.then(({ bytes }) => bytes);
+    get raw() {
+        if (this._raw == null) {
+            this._raw = jwkToPkix(this._key);
         }
-        return p.bytes;
-    }
-}
-class RsaPrivateKey {
-    _key;
-    _publicKey;
-    constructor(key, publicKey) {
-        this._key = key;
-        this._publicKey = publicKey;
+        return this._raw;
     }
-    genSecret() {
-        return randomBytes(16);
+    toMultihash() {
+        return this._multihash;
     }
-    sign(message) {
-        return hashAndSign$1(this._key, message);
-    }
-    get public() {
-        if (this._publicKey == null) {
-            throw new CodeError('public key not provided', 'ERR_PUBKEY_NOT_PROVIDED');
-        }
-        return new RsaPublicKey(this._publicKey);
-    }
-    marshal() {
-        return jwkToPkcs1(this._key);
+    toCID() {
+        return CID.createV1(114, this._multihash);
     }
-    get bytes() {
-        return PrivateKey.encode({
-            Type: KeyType.RSA,
-            Data: this.marshal()
-        }).subarray();
+    toString() {
+        return base58btc.encode(this.toMultihash().bytes).substring(1);
     }
     equals(key) {
-        return equals(this.bytes, key.bytes);
-    }
-    hash() {
-        const p = sha256$1.digest(this.bytes);
-        if (isPromise(p)) {
-            return p.then(({ bytes }) => bytes);
+        if (key == null || !(key.raw instanceof Uint8Array)) {
+            return false;
         }
-        return p.bytes;
+        return equals(this.raw, key.raw);
     }
-    /**
-     * Gets the ID of the key.
-     *
-     * The key id is the base58 encoding of the SHA-256 multihash of its public key.
-     * The public key is a protobuf encoding containing a type and the DER encoding
-     * of the PKCS SubjectPublicKeyInfo.
-     */
-    async id() {
-        const hash = await this.public.hash();
-        return toString$1(hash, 'base58btc');
+    verify(data, sig) {
+        return hashAndVerify$1(this._key, sig, data);
     }
-    /**
-     * Exports the key as libp2p-key - a aes-gcm encrypted value with the key
-     * derived from the password.
-     *
-     * To export it as a password protected PEM file, please use the `exportPEM`
-     * function from `@libp2p/rsa`.
-     */
-    async export(password, format = 'pkcs-8') {
-        if (format === 'pkcs-8') {
-            return exportToPem(this, password);
-        }
-        else if (format === 'libp2p-key') {
-            return exporter(this.bytes, password);
-        }
-        else {
-            throw new CodeError(`export format '${format}' is not supported`, 'ERR_INVALID_EXPORT_FORMAT');
-        }
+}
+
+const MAX_RSA_KEY_SIZE = 8192;
+const SHA2_256_CODE = 0x12;
+/**
+ * Convert a PKIX in ASN1 DER format to a JWK key
+ */
+function pkixToJwk(bytes) {
+    const { result } = fromBER(bytes);
+    // @ts-expect-error this looks fragile but DER is a canonical format so we are
+    // safe to have deeply property chains like this
+    const values = result.valueBlock.value[1].valueBlock.value[0].valueBlock.value;
+    return {
+        kty: 'RSA',
+        n: asn1jsIntegerToBase64(values[0]),
+        e: asn1jsIntegerToBase64(values[1])
+    };
+}
+/**
+ * Convert a JWK key to PKIX in ASN1 DER format
+ */
+function jwkToPkix(jwk) {
+    if (jwk.n == null || jwk.e == null) {
+        throw new InvalidParametersError('JWK was missing components');
     }
+    const root = new Sequence({
+        value: [
+            new Sequence({
+                value: [
+                    // rsaEncryption
+                    new ObjectIdentifier({
+                        value: '1.2.840.113549.1.1.1'
+                    }),
+                    new Null()
+                ]
+            }),
+            // this appears to be a bug in asn1js.js - this should really be a Sequence
+            // and not a BitString but it generates the same bytes as node-forge so 🤷‍♂️
+            new BitString({
+                valueHex: new Sequence({
+                    value: [
+                        Integer.fromBigInt(bufToBn(fromString(jwk.n, 'base64url'))),
+                        Integer.fromBigInt(bufToBn(fromString(jwk.e, 'base64url')))
+                    ]
+                }).toBER()
+            })
+        ]
+    });
+    const der = root.toBER();
+    return new Uint8Array(der, 0, der.byteLength);
 }
-async function unmarshalRsaPrivateKey(bytes) {
-    const jwk = pkcs1ToJwk(bytes);
-    if (keySize(jwk) > MAX_RSA_KEY_SIZE) {
-        throw new CodeError('key size is too large', 'ERR_KEY_SIZE_TOO_LARGE');
+function asn1jsIntegerToBase64(int) {
+    let buf = int.valueBlock.valueHexView;
+    // chrome rejects values with leading 0s
+    while (buf[0] === 0) {
+        buf = buf.subarray(1);
     }
-    const keys = await unmarshalPrivateKey$1(jwk);
-    return new RsaPrivateKey(keys.privateKey, keys.publicKey);
+    return toString$1(buf, 'base64url');
+}
+function bufToBn(u8) {
+    const hex = [];
+    u8.forEach(function (i) {
+        let h = i.toString(16);
+        if (h.length % 2 > 0) {
+            h = `0${h}`;
+        }
+        hex.push(h);
+    });
+    return BigInt('0x' + hex.join(''));
 }
-function unmarshalRsaPublicKey(bytes) {
+/**
+ * Turn PKIX bytes to a PublicKey
+ */
+function pkixToRSAPublicKey(bytes) {
     const jwk = pkixToJwk(bytes);
-    if (keySize(jwk) > MAX_RSA_KEY_SIZE) {
-        throw new CodeError('key size is too large', 'ERR_KEY_SIZE_TOO_LARGE');
+    if (rsaKeySize(jwk) > MAX_RSA_KEY_SIZE) {
+        throw new InvalidPublicKeyError('Key size is too large');
     }
-    return new RsaPublicKey(jwk);
+    const hash = sha256(PublicKey.encode({
+        Type: KeyType.RSA,
+        Data: bytes
+    }));
+    const digest = create(SHA2_256_CODE, hash);
+    return new RSAPublicKey(jwk, digest);
 }
-async function fromJwk(jwk) {
-    if (keySize(jwk) > MAX_RSA_KEY_SIZE) {
-        throw new CodeError('key size is too large', 'ERR_KEY_SIZE_TOO_LARGE');
+
+// HMAC (RFC 2104)
+class HMAC extends Hash {
+    constructor(hash$1, _key) {
+        super();
+        this.finished = false;
+        this.destroyed = false;
+        hash(hash$1);
+        const key = toBytes$1(_key);
+        this.iHash = hash$1.create();
+        if (typeof this.iHash.update !== 'function')
+            throw new Error('Expected instance of class which extends utils.Hash');
+        this.blockLen = this.iHash.blockLen;
+        this.outputLen = this.iHash.outputLen;
+        const blockLen = this.blockLen;
+        const pad = new Uint8Array(blockLen);
+        // blockLen can be bigger than outputLen
+        pad.set(key.length > blockLen ? hash$1.create().update(key).digest() : key);
+        for (let i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36;
+        this.iHash.update(pad);
+        // By doing update (processing of first block) of outer hash here we can re-use it between multiple calls via clone
+        this.oHash = hash$1.create();
+        // Undo internal XOR && apply outer XOR
+        for (let i = 0; i < pad.length; i++)
+            pad[i] ^= 0x36 ^ 0x5c;
+        this.oHash.update(pad);
+        pad.fill(0);
     }
-    const keys = await unmarshalPrivateKey$1(jwk);
-    return new RsaPrivateKey(keys.privateKey, keys.publicKey);
-}
-async function generateKeyPair$1(bits) {
-    if (bits > MAX_RSA_KEY_SIZE) {
-        throw new CodeError('key size is too large', 'ERR_KEY_SIZE_TOO_LARGE');
+    update(buf) {
+        exists(this);
+        this.iHash.update(buf);
+        return this;
+    }
+    digestInto(out) {
+        exists(this);
+        bytes(out, this.outputLen);
+        this.finished = true;
+        this.iHash.digestInto(out);
+        this.oHash.update(out);
+        this.oHash.digestInto(out);
+        this.destroy();
+    }
+    digest() {
+        const out = new Uint8Array(this.oHash.outputLen);
+        this.digestInto(out);
+        return out;
+    }
+    _cloneInto(to) {
+        // Create new instance without calling constructor since key already in state and we don't know it.
+        to || (to = Object.create(Object.getPrototypeOf(this), {}));
+        const { oHash, iHash, finished, destroyed, blockLen, outputLen } = this;
+        to = to;
+        to.finished = finished;
+        to.destroyed = destroyed;
+        to.blockLen = blockLen;
+        to.outputLen = outputLen;
+        to.oHash = oHash._cloneInto(to.oHash);
+        to.iHash = iHash._cloneInto(to.iHash);
+        return to;
+    }
+    destroy() {
+        this.destroyed = true;
+        this.oHash.destroy();
+        this.iHash.destroy();
     }
-    const keys = await generateKey$1(bits);
-    return new RsaPrivateKey(keys.privateKey, keys.publicKey);
 }
-
-var RSA = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    MAX_RSA_KEY_SIZE: MAX_RSA_KEY_SIZE,
-    RsaPrivateKey: RsaPrivateKey,
-    RsaPublicKey: RsaPublicKey,
-    fromJwk: fromJwk,
-    generateKeyPair: generateKeyPair$1,
-    unmarshalRsaPrivateKey: unmarshalRsaPrivateKey,
-    unmarshalRsaPublicKey: unmarshalRsaPublicKey
-});
+/**
+ * HMAC: RFC2104 message authentication code.
+ * @param hash - function that would be used e.g. sha256
+ * @param key - message key
+ * @param message - message data
+ * @example
+ * import { hmac } from '@noble/hashes/hmac';
+ * import { sha256 } from '@noble/hashes/sha2';
+ * const mac1 = hmac(sha256, 'key', 'message');
+ */
+const hmac = (hash, key, message) => new HMAC(hash, key).update(message).digest();
+hmac.create = (hash, key) => new HMAC(hash, key);
 
 /*! noble-curves - MIT License (c) 2022 Paul Miller (paulmillr.com) */
 // Short Weierstrass curve. The formula is: y² = x³ + ax + b
@@ -12935,8 +12404,14 @@ function validatePointOpts(curve) {
     }
     return Object.freeze({ ...opts });
 }
-// ASN.1 DER encoding utilities
 const { bytesToNumberBE: b2n, hexToBytes: h2b } = ut;
+/**
+ * ASN.1 DER encoding utilities. ASN is very complex & fragile. Format:
+ *
+ *     [0x30 (SEQUENCE), bytelength, 0x02 (INTEGER), intLength, R, 0x02 (INTEGER), intLength, S]
+ *
+ * Docs: https://letsencrypt.org/docs/a-warm-welcome-to-asn1-and-der/, https://luca.ntop.org/Teaching/Appunti/asn1.html
+ */
 const DER = {
     // asn.1 DER encoding utils
     Err: class DERErr extends Error {
@@ -12944,54 +12419,103 @@ const DER = {
             super(m);
         }
     },
-    _parseInt(data) {
-        const { Err: E } = DER;
-        if (data.length < 2 || data[0] !== 0x02)
-            throw new E('Invalid signature integer tag');
-        const len = data[1];
-        const res = data.subarray(2, len + 2);
-        if (!len || res.length !== len)
-            throw new E('Invalid signature integer: wrong length');
-        // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
-        // since we always use positive integers here. It must always be empty:
-        // - add zero byte if exists
-        // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
-        if (res[0] & 0b10000000)
-            throw new E('Invalid signature integer: negative');
-        if (res[0] === 0x00 && !(res[1] & 0b10000000))
-            throw new E('Invalid signature integer: unnecessary leading zero');
-        return { d: b2n(res), l: data.subarray(len + 2) }; // d is data, l is left
+    // Basic building block is TLV (Tag-Length-Value)
+    _tlv: {
+        encode: (tag, data) => {
+            const { Err: E } = DER;
+            if (tag < 0 || tag > 256)
+                throw new E('tlv.encode: wrong tag');
+            if (data.length & 1)
+                throw new E('tlv.encode: unpadded data');
+            const dataLen = data.length / 2;
+            const len = numberToHexUnpadded(dataLen);
+            if ((len.length / 2) & 128)
+                throw new E('tlv.encode: long form length too big');
+            // length of length with long form flag
+            const lenLen = dataLen > 127 ? numberToHexUnpadded((len.length / 2) | 128) : '';
+            return `${numberToHexUnpadded(tag)}${lenLen}${len}${data}`;
+        },
+        // v - value, l - left bytes (unparsed)
+        decode(tag, data) {
+            const { Err: E } = DER;
+            let pos = 0;
+            if (tag < 0 || tag > 256)
+                throw new E('tlv.encode: wrong tag');
+            if (data.length < 2 || data[pos++] !== tag)
+                throw new E('tlv.decode: wrong tlv');
+            const first = data[pos++];
+            const isLong = !!(first & 128); // First bit of first length byte is flag for short/long form
+            let length = 0;
+            if (!isLong)
+                length = first;
+            else {
+                // Long form: [longFlag(1bit), lengthLength(7bit), length (BE)]
+                const lenLen = first & 127;
+                if (!lenLen)
+                    throw new E('tlv.decode(long): indefinite length not supported');
+                if (lenLen > 4)
+                    throw new E('tlv.decode(long): byte length is too big'); // this will overflow u32 in js
+                const lengthBytes = data.subarray(pos, pos + lenLen);
+                if (lengthBytes.length !== lenLen)
+                    throw new E('tlv.decode: length bytes not complete');
+                if (lengthBytes[0] === 0)
+                    throw new E('tlv.decode(long): zero leftmost byte');
+                for (const b of lengthBytes)
+                    length = (length << 8) | b;
+                pos += lenLen;
+                if (length < 128)
+                    throw new E('tlv.decode(long): not minimal encoding');
+            }
+            const v = data.subarray(pos, pos + length);
+            if (v.length !== length)
+                throw new E('tlv.decode: wrong value length');
+            return { v, l: data.subarray(pos + length) };
+        },
+    },
+    // https://crypto.stackexchange.com/a/57734 Leftmost bit of first byte is 'negative' flag,
+    // since we always use positive integers here. It must always be empty:
+    // - add zero byte if exists
+    // - if next byte doesn't have a flag, leading zero is not allowed (minimal encoding)
+    _int: {
+        encode(num) {
+            const { Err: E } = DER;
+            if (num < _0n)
+                throw new E('integer: negative integers are not allowed');
+            let hex = numberToHexUnpadded(num);
+            // Pad with zero byte if negative flag is present
+            if (Number.parseInt(hex[0], 16) & 0b1000)
+                hex = '00' + hex;
+            if (hex.length & 1)
+                throw new E('unexpected assertion');
+            return hex;
+        },
+        decode(data) {
+            const { Err: E } = DER;
+            if (data[0] & 128)
+                throw new E('Invalid signature integer: negative');
+            if (data[0] === 0x00 && !(data[1] & 128))
+                throw new E('Invalid signature integer: unnecessary leading zero');
+            return b2n(data);
+        },
     },
     toSig(hex) {
         // parse DER signature
-        const { Err: E } = DER;
+        const { Err: E, _int: int, _tlv: tlv } = DER;
         const data = typeof hex === 'string' ? h2b(hex) : hex;
         abytes(data);
-        let l = data.length;
-        if (l < 2 || data[0] != 0x30)
-            throw new E('Invalid signature tag');
-        if (data[1] !== l - 2)
-            throw new E('Invalid signature: incorrect length');
-        const { d: r, l: sBytes } = DER._parseInt(data.subarray(2));
-        const { d: s, l: rBytesLeft } = DER._parseInt(sBytes);
-        if (rBytesLeft.length)
+        const { v: seqBytes, l: seqLeftBytes } = tlv.decode(0x30, data);
+        if (seqLeftBytes.length)
             throw new E('Invalid signature: left bytes after parsing');
-        return { r, s };
+        const { v: rBytes, l: rLeftBytes } = tlv.decode(0x02, seqBytes);
+        const { v: sBytes, l: sLeftBytes } = tlv.decode(0x02, rLeftBytes);
+        if (sLeftBytes.length)
+            throw new E('Invalid signature: left bytes after parsing');
+        return { r: int.decode(rBytes), s: int.decode(sBytes) };
     },
     hexFromSig(sig) {
-        // Add leading zero if first byte has negative bit enabled. More details in '_parseInt'
-        const slice = (s) => (Number.parseInt(s[0], 16) & 0b1000 ? '00' + s : s);
-        const h = (num) => {
-            const hex = num.toString(16);
-            return hex.length & 1 ? `0${hex}` : hex;
-        };
-        const s = slice(h(sig.s));
-        const r = slice(h(sig.r));
-        const shl = s.length / 2;
-        const rhl = r.length / 2;
-        const sl = h(shl);
-        const rl = h(rhl);
-        return `30${h(rhl + shl + 4)}02${rl}${r}02${sl}${s}`;
+        const { _tlv: tlv, _int: int } = DER;
+        const seq = `${tlv.encode(0x02, int.encode(sig.r))}${tlv.encode(0x02, int.encode(sig.s))}`;
+        return tlv.encode(0x30, seq);
     },
 };
 // Be friendly to bad ECMAScript parsers by not using bigint literals
@@ -13000,6 +12524,7 @@ const _0n = BigInt(0), _1n$1 = BigInt(1); BigInt(2); const _3n = BigInt(3); BigI
 function weierstrassPoints(opts) {
     const CURVE = validatePointOpts(opts);
     const { Fp } = CURVE; // All curves has same field / group length as for now, but they can differ
+    const Fn = Field(CURVE.n, CURVE.nBitLength);
     const toBytes = CURVE.toBytes ||
         ((_c, point, _isCompressed) => {
             const a = point.toAffine();
@@ -13173,6 +12698,10 @@ function weierstrassPoints(opts) {
         static fromPrivateKey(privateKey) {
             return Point.BASE.multiply(normPrivateKeyToScalar(privateKey));
         }
+        // Multiscalar Multiplication
+        static msm(points, scalars) {
+            return pippenger(Point, Fn, points, scalars);
+        }
         // "Private method", don't use it directly
         _setWindowSize(windowSize) {
             wnaf.setWindowSize(this, windowSize);
@@ -13858,7 +13387,7 @@ function getHash(hash) {
     return {
         hash,
         hmac: (key, ...msgs) => hmac(hash, key, concatBytes$1(...msgs)),
-        randomBytes: randomBytes$1,
+        randomBytes,
     };
 }
 function createCurve(curveDef, defHash) {
@@ -13951,27 +13480,15 @@ const secp256k1 = createCurve({
 BigInt(0);
 secp256k1.ProjectivePoint;
 
-function generateKey() {
-    return secp256k1.utils.randomPrivateKey();
-}
-/**
- * Hash and sign message with private key
- */
-function hashAndSign(key, msg) {
-    const p = sha256$1.digest(msg instanceof Uint8Array ? msg : msg.subarray());
-    if (isPromise(p)) {
-        return p.then(({ digest }) => secp256k1.sign(digest, key).toDERRawBytes())
-            .catch(err => {
-            throw new CodeError(String(err), 'ERR_INVALID_INPUT');
-        });
-    }
-    try {
-        return secp256k1.sign(p.digest, key).toDERRawBytes();
-    }
-    catch (err) {
-        throw new CodeError(String(err), 'ERR_INVALID_INPUT');
+function isPromise(thing) {
+    if (thing == null) {
+        return false;
     }
+    return typeof thing.then === 'function' &&
+        typeof thing.catch === 'function' &&
+        typeof thing.finally === 'function';
 }
+
 /**
  * Hash message and verify signature with public key
  */
@@ -13980,207 +13497,114 @@ function hashAndVerify(key, sig, msg) {
     if (isPromise(p)) {
         return p.then(({ digest }) => secp256k1.verify(sig, digest, key))
             .catch(err => {
-            throw new CodeError(String(err), 'ERR_INVALID_INPUT');
+            throw new VerificationError(String(err));
         });
     }
     try {
         return secp256k1.verify(sig, p.digest, key);
     }
     catch (err) {
-        throw new CodeError(String(err), 'ERR_INVALID_INPUT');
-    }
-}
-function compressPublicKey(key) {
-    const point = secp256k1.ProjectivePoint.fromHex(key).toRawBytes(true);
-    return point;
-}
-function validatePrivateKey(key) {
-    try {
-        secp256k1.getPublicKey(key, true);
-    }
-    catch (err) {
-        throw new CodeError(String(err), 'ERR_INVALID_PRIVATE_KEY');
-    }
-}
-function validatePublicKey(key) {
-    try {
-        secp256k1.ProjectivePoint.fromHex(key);
-    }
-    catch (err) {
-        throw new CodeError(String(err), 'ERR_INVALID_PUBLIC_KEY');
-    }
-}
-function computePublicKey(privateKey) {
-    try {
-        return secp256k1.getPublicKey(privateKey, true);
-    }
-    catch (err) {
-        throw new CodeError(String(err), 'ERR_INVALID_PRIVATE_KEY');
+        throw new VerificationError(String(err));
     }
 }
 
 class Secp256k1PublicKey {
+    type = 'secp256k1';
+    raw;
     _key;
     constructor(key) {
-        validatePublicKey(key);
-        this._key = key;
-    }
-    verify(data, sig) {
-        return hashAndVerify(this._key, sig, data);
-    }
-    marshal() {
-        return compressPublicKey(this._key);
-    }
-    get bytes() {
-        return PublicKey.encode({
-            Type: KeyType.Secp256k1,
-            Data: this.marshal()
-        }).subarray();
-    }
-    equals(key) {
-        return equals(this.bytes, key.bytes);
-    }
-    async hash() {
-        const p = sha256$1.digest(this.bytes);
-        let bytes;
-        if (isPromise(p)) {
-            ({ bytes } = await p);
-        }
-        else {
-            bytes = p.bytes;
-        }
-        return bytes;
+        this._key = validateSecp256k1PublicKey(key);
+        this.raw = compressSecp256k1PublicKey(this._key);
     }
-}
-class Secp256k1PrivateKey {
-    _key;
-    _publicKey;
-    constructor(key, publicKey) {
-        this._key = key;
-        this._publicKey = publicKey ?? computePublicKey(key);
-        validatePrivateKey(this._key);
-        validatePublicKey(this._publicKey);
+    toMultihash() {
+        return identity.digest(publicKeyToProtobuf(this));
     }
-    sign(message) {
-        return hashAndSign(this._key, message);
-    }
-    get public() {
-        return new Secp256k1PublicKey(this._publicKey);
-    }
-    marshal() {
-        return this._key;
+    toCID() {
+        return CID.createV1(114, this.toMultihash());
     }
-    get bytes() {
-        return PrivateKey.encode({
-            Type: KeyType.Secp256k1,
-            Data: this.marshal()
-        }).subarray();
+    toString() {
+        return base58btc.encode(this.toMultihash().bytes).substring(1);
     }
     equals(key) {
-        return equals(this.bytes, key.bytes);
-    }
-    hash() {
-        const p = sha256$1.digest(this.bytes);
-        if (isPromise(p)) {
-            return p.then(({ bytes }) => bytes);
+        if (key == null || !(key.raw instanceof Uint8Array)) {
+            return false;
         }
-        return p.bytes;
+        return equals(this.raw, key.raw);
     }
-    /**
-     * Gets the ID of the key.
-     *
-     * The key id is the base58 encoding of the SHA-256 multihash of its public key.
-     * The public key is a protobuf encoding containing a type and the DER encoding
-     * of the PKCS SubjectPublicKeyInfo.
-     */
-    async id() {
-        const hash = await this.public.hash();
-        return toString$1(hash, 'base58btc');
-    }
-    /**
-     * Exports the key into a password protected `format`
-     */
-    async export(password, format = 'libp2p-key') {
-        if (format === 'libp2p-key') {
-            return exporter(this.bytes, password);
-        }
-        else {
-            throw new CodeError(`export format '${format}' is not supported`, 'ERR_INVALID_EXPORT_FORMAT');
-        }
+    verify(data, sig) {
+        return hashAndVerify(this._key, sig, data);
     }
 }
-function unmarshalSecp256k1PrivateKey(bytes) {
-    return new Secp256k1PrivateKey(bytes);
-}
+
 function unmarshalSecp256k1PublicKey(bytes) {
     return new Secp256k1PublicKey(bytes);
 }
-async function generateKeyPair() {
-    const privateKeyBytes = generateKey();
-    return new Secp256k1PrivateKey(privateKeyBytes);
+function compressSecp256k1PublicKey(key) {
+    const point = secp256k1.ProjectivePoint.fromHex(key).toRawBytes(true);
+    return point;
+}
+function validateSecp256k1PublicKey(key) {
+    try {
+        secp256k1.ProjectivePoint.fromHex(key);
+        return key;
+    }
+    catch (err) {
+        throw new InvalidPublicKeyError(String(err));
+    }
 }
-
-var Secp256k1 = /*#__PURE__*/Object.freeze({
-    __proto__: null,
-    Secp256k1PrivateKey: Secp256k1PrivateKey,
-    Secp256k1PublicKey: Secp256k1PublicKey,
-    generateKeyPair: generateKeyPair,
-    unmarshalSecp256k1PrivateKey: unmarshalSecp256k1PrivateKey,
-    unmarshalSecp256k1PublicKey: unmarshalSecp256k1PublicKey
-});
 
 /**
  * @packageDocumentation
  *
- * **Supported Key Types**
- *
- * The {@link generateKeyPair}, {@link marshalPublicKey}, and {@link marshalPrivateKey} functions accept a string `type` argument.
+ * ## Supported Key Types
  *
  * Currently the `'RSA'`, `'ed25519'`, and `secp256k1` types are supported, although ed25519 and secp256k1 keys support only signing and verification of messages.
  *
  * For encryption / decryption support, RSA keys should be used.
  */
-const supportedKeys = {
-    rsa: RSA,
-    ed25519: Ed25519,
-    secp256k1: Secp256k1
-};
-function unsupportedKey(type) {
-    const supported = Object.keys(supportedKeys).join(' / ');
-    return new CodeError(`invalid or unsupported key type ${type}. Must be ${supported}`, 'ERR_UNSUPPORTED_KEY_TYPE');
-}
 /**
- * Converts a protobuf serialized public key into its representative object
+ * Creates a public key from the raw key bytes
  */
-function unmarshalPublicKey(buf) {
-    const decoded = PublicKey.decode(buf);
-    const data = decoded.Data ?? new Uint8Array();
-    switch (decoded.Type) {
-        case KeyType.RSA:
-            return supportedKeys.rsa.unmarshalRsaPublicKey(data);
-        case KeyType.Ed25519:
-            return supportedKeys.ed25519.unmarshalEd25519PublicKey(data);
-        case KeyType.Secp256k1:
-            return supportedKeys.secp256k1.unmarshalSecp256k1PublicKey(data);
-        default:
-            throw unsupportedKey(decoded.Type ?? 'unknown');
+function publicKeyFromRaw(buf) {
+    if (buf.byteLength === 32) {
+        return unmarshalEd25519PublicKey(buf);
+    }
+    else if (buf.byteLength === 33) {
+        return unmarshalSecp256k1PublicKey(buf);
+    }
+    else {
+        return pkixToRSAPublicKey(buf);
     }
 }
 /**
- * Converts a protobuf serialized private key into its representative object
+ * Converts a public key object into a protobuf serialized public key
  */
-async function unmarshalPrivateKey(buf) {
-    const decoded = PrivateKey.decode(buf);
-    const data = decoded.Data ?? new Uint8Array();
-    switch (decoded.Type) {
-        case KeyType.RSA:
-            return supportedKeys.rsa.unmarshalRsaPrivateKey(data);
-        case KeyType.Ed25519:
-            return supportedKeys.ed25519.unmarshalEd25519PrivateKey(data);
-        case KeyType.Secp256k1:
-            return supportedKeys.secp256k1.unmarshalSecp256k1PrivateKey(data);
-        default:
-            throw unsupportedKey(decoded.Type ?? 'RSA');
+function publicKeyToProtobuf(key) {
+    return PublicKey.encode({
+        Type: KeyType[key.type],
+        Data: key.raw
+    });
+}
+
+/**
+ * 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');
+
+/**
+ * When this error is thrown it means an operation was aborted,
+ * usually in response to the `abort` event being emitted by an
+ * AbortSignal.
+ */
+/**
+ * Thrown when and attempt to operate on an unsupported key was made
+ */
+class UnsupportedKeyTypeError extends Error {
+    static name = 'UnsupportedKeyTypeError';
+    constructor(message = 'Unsupported key type') {
+        super(message);
+        this.name = 'UnsupportedKeyTypeError';
     }
 }
 
@@ -14200,25 +13624,16 @@ async function unmarshalPrivateKey(buf) {
  * ```
  */
 const inspect = Symbol.for('nodejs.util.inspect.custom');
-const baseDecoder = Object
-    .values(bases)
-    .map(codec => codec.decoder)
-    // @ts-expect-error https://github.com/multiformats/js-multiformats/issues/141
-    .reduce((acc, curr) => acc.or(curr), bases.identity.decoder);
 // these values are from https://github.com/multiformats/multicodec/blob/master/table.csv
 const LIBP2P_KEY_CODE = 0x72;
-const MARSHALLED_ED225519_PUBLIC_KEY_LENGTH = 36;
-const MARSHALLED_SECP256K1_PUBLIC_KEY_LENGTH = 37;
 class PeerIdImpl {
     type;
     multihash;
-    privateKey;
     publicKey;
     string;
     constructor(init) {
         this.type = init.type;
         this.multihash = init.multihash;
-        this.privateKey = init.privateKey;
         // mark string cache as non-enumerable
         Object.defineProperty(this, 'string', {
             enumerable: false,
@@ -14235,17 +13650,14 @@ class PeerIdImpl {
         }
         return this.string;
     }
+    toMultihash() {
+        return this.multihash;
+    }
     // return self-describing String representation
     // in default format from RFC 0001: https://github.com/libp2p/specs/pull/209
     toCID() {
         return CID.createV1(LIBP2P_KEY_CODE, this.multihash);
     }
-    toBytes() {
-        return this.multihash.bytes;
-    }
-    /**
-     * Returns Multiaddr as a JSON string
-     */
     toJSON() {
         return this.toString();
     }
@@ -14260,10 +13672,10 @@ class PeerIdImpl {
             return equals(this.multihash.bytes, id);
         }
         else if (typeof id === 'string') {
-            return peerIdFromString(id).equals(this);
+            return this.toString() === id;
         }
-        else if (id?.multihash?.bytes != null) {
-            return equals(this.multihash.bytes, id.multihash.bytes);
+        else if (id?.toMultihash()?.bytes != null) {
+            return equals(this.multihash.bytes, id.toMultihash().bytes);
         }
         else {
             throw new Error('not valid Id');
@@ -14285,7 +13697,7 @@ class PeerIdImpl {
         return `PeerId(${this.toString()})`;
     }
 }
-class RSAPeerIdImpl extends PeerIdImpl {
+class RSAPeerId extends PeerIdImpl {
     type = 'RSA';
     publicKey;
     constructor(init) {
@@ -14293,153 +13705,67 @@ class RSAPeerIdImpl extends PeerIdImpl {
         this.publicKey = init.publicKey;
     }
 }
-class Ed25519PeerIdImpl extends PeerIdImpl {
+class Ed25519PeerId extends PeerIdImpl {
     type = 'Ed25519';
     publicKey;
     constructor(init) {
         super({ ...init, type: 'Ed25519' });
-        this.publicKey = init.multihash.digest;
+        this.publicKey = init.publicKey;
     }
 }
-class Secp256k1PeerIdImpl extends PeerIdImpl {
+class Secp256k1PeerId extends PeerIdImpl {
     type = 'secp256k1';
     publicKey;
     constructor(init) {
         super({ ...init, type: 'secp256k1' });
-        this.publicKey = init.multihash.digest;
-    }
-}
-// these values are from https://github.com/multiformats/multicodec/blob/master/table.csv
-const TRANSPORT_IPFS_GATEWAY_HTTP_CODE = 0x0920;
-class URLPeerIdImpl {
-    type = 'url';
-    multihash;
-    privateKey;
-    publicKey;
-    url;
-    constructor(url) {
-        this.url = url.toString();
-        this.multihash = identity.digest(fromString(this.url));
-    }
-    [inspect]() {
-        return `PeerId(${this.url})`;
-    }
-    [peerIdSymbol] = true;
-    toString() {
-        return this.toCID().toString();
-    }
-    toCID() {
-        return CID.createV1(TRANSPORT_IPFS_GATEWAY_HTTP_CODE, this.multihash);
-    }
-    toBytes() {
-        return this.toCID().bytes;
-    }
-    equals(other) {
-        if (other == null) {
-            return false;
-        }
-        if (other instanceof Uint8Array) {
-            other = toString$1(other);
-        }
-        return other.toString() === this.toString();
-    }
-}
-function peerIdFromString(str, decoder) {
-    if (str.charAt(0) === '1' || str.charAt(0) === 'Q') {
-        // identity hash ed25519/secp256k1 key or sha2-256 hash of
-        // rsa public key - base58btc encoded either way
-        const multihash = decode$2(base58btc.decode(`z${str}`));
-        if (str.startsWith('12D')) {
-            return new Ed25519PeerIdImpl({ multihash });
-        }
-        else if (str.startsWith('16U')) {
-            return new Secp256k1PeerIdImpl({ multihash });
-        }
-        else {
-            return new RSAPeerIdImpl({ multihash });
-        }
-    }
-    return peerIdFromBytes(baseDecoder.decode(str));
-}
-function peerIdFromBytes(buf) {
-    try {
-        const multihash = decode$2(buf);
-        if (multihash.code === identity.code) {
-            if (multihash.digest.length === MARSHALLED_ED225519_PUBLIC_KEY_LENGTH) {
-                return new Ed25519PeerIdImpl({ multihash });
-            }
-            else if (multihash.digest.length === MARSHALLED_SECP256K1_PUBLIC_KEY_LENGTH) {
-                return new Secp256k1PeerIdImpl({ multihash });
-            }
-        }
-        if (multihash.code === sha256$1.code) {
-            return new RSAPeerIdImpl({ multihash });
-        }
-    }
-    catch {
-        return peerIdFromCID(CID.decode(buf));
-    }
-    throw new Error('Supplied PeerID CID is invalid');
-}
-function peerIdFromCID(cid) {
-    if (cid?.multihash == null || cid.version == null || (cid.version === 1 && (cid.code !== LIBP2P_KEY_CODE) && cid.code !== TRANSPORT_IPFS_GATEWAY_HTTP_CODE)) {
-        throw new Error('Supplied PeerID CID is invalid');
-    }
-    if (cid.code === TRANSPORT_IPFS_GATEWAY_HTTP_CODE) {
-        const url = toString$1(cid.multihash.digest);
-        return new URLPeerIdImpl(new URL(url));
-    }
-    const multihash = cid.multihash;
-    if (multihash.code === sha256$1.code) {
-        return new RSAPeerIdImpl({ multihash: cid.multihash });
-    }
-    else if (multihash.code === identity.code) {
-        if (multihash.digest.length === MARSHALLED_ED225519_PUBLIC_KEY_LENGTH) {
-            return new Ed25519PeerIdImpl({ multihash: cid.multihash });
-        }
-        else if (multihash.digest.length === MARSHALLED_SECP256K1_PUBLIC_KEY_LENGTH) {
-            return new Secp256k1PeerIdImpl({ multihash: cid.multihash });
-        }
+        this.publicKey = init.publicKey;
     }
-    throw new Error('Supplied PeerID CID is invalid');
 }
+
 /**
- * @param publicKey - A marshalled public key
- * @param privateKey - A marshalled private key
+ * @packageDocumentation
+ *
+ * An implementation of a peer id
+ *
+ * @example
+ *
+ * ```TypeScript
+ * import { peerIdFromString } from '@libp2p/peer-id'
+ * const peer = peerIdFromString('12D3KooWKnDdG3iXw9eTFijk3EWSunZcFi54Zka4wmtqtt6rPxc8')
+ *
+ * console.log(peer.toCID()) // CID(bafzaa...)
+ * console.log(peer.toString()) // "12D3K..."
+ * ```
  */
-async function peerIdFromKeys(publicKey, privateKey) {
-    if (publicKey.length === MARSHALLED_ED225519_PUBLIC_KEY_LENGTH) {
-        return new Ed25519PeerIdImpl({ multihash: create$1(identity.code, publicKey), privateKey });
+function peerIdFromPublicKey(publicKey) {
+    if (publicKey.type === 'Ed25519') {
+        return new Ed25519PeerId({
+            multihash: publicKey.toCID().multihash,
+            publicKey
+        });
     }
-    if (publicKey.length === MARSHALLED_SECP256K1_PUBLIC_KEY_LENGTH) {
-        return new Secp256k1PeerIdImpl({ multihash: create$1(identity.code, publicKey), privateKey });
+    else if (publicKey.type === 'secp256k1') {
+        return new Secp256k1PeerId({
+            multihash: publicKey.toCID().multihash,
+            publicKey
+        });
     }
-    return new RSAPeerIdImpl({ multihash: await sha256$1.digest(publicKey), publicKey, privateKey });
+    else if (publicKey.type === 'RSA') {
+        return new RSAPeerId({
+            multihash: publicKey.toCID().multihash,
+            publicKey
+        });
+    }
+    throw new UnsupportedKeyTypeError();
 }
 
+const ERR_TYPE_NOT_IMPLEMENTED = "Keypair type not implemented";
 function createPeerIdFromPublicKey(publicKey) {
-    const _publicKey = new supportedKeys.secp256k1.Secp256k1PublicKey(publicKey);
-    return peerIdFromKeys(_publicKey.bytes, undefined);
-}
-function getPublicKeyFromPeerId(peerId) {
-    if (peerId.type !== "secp256k1") {
-        throw new Error("Unsupported peer id type");
-    }
-    if (!peerId.publicKey) {
-        throw new Error("Public key not present on peer id");
-    }
-    return unmarshalPublicKey(peerId.publicKey).marshal();
-}
-// Only used in tests
-async function getPrivateKeyFromPeerId(peerId) {
-    if (peerId.type !== "secp256k1") {
-        throw new Error("Unsupported peer id type");
-    }
-    if (!peerId.privateKey) {
-        throw new Error("Private key not present on peer id");
+    const pubKey = publicKeyFromRaw(publicKey);
+    if (pubKey.type !== "secp256k1") {
+        throw new Error(ERR_TYPE_NOT_IMPLEMENTED);
     }
-    const privateKey = await unmarshalPrivateKey(peerId.privateKey);
-    return privateKey.marshal();
+    return peerIdFromPublicKey(pubKey);
 }
 
 function decodeMultiaddrs(bytes) {
@@ -14686,12 +14012,12 @@ var TransportProtocolPerIpVersion;
 class ENR extends RawEnr {
     static RECORD_PREFIX = "enr:";
     peerId;
-    static async create(kvs = {}, seq = BigInt(1), signature) {
+    static create(kvs = {}, seq = BigInt(1), signature) {
         const enr = new ENR(kvs, seq, signature);
         try {
             const publicKey = enr.publicKey;
             if (publicKey) {
-                enr.peerId = await createPeerIdFromPublicKey(publicKey);
+                enr.peerId = createPeerIdFromPublicKey(publicKey);
             }
         }
         catch (e) {
@@ -14813,7 +14139,7 @@ class EnrCreator {
     static fromPublicKey(publicKey, kvs = {}) {
         // EIP-778 specifies that the key must be in compressed format, 33 bytes
         if (publicKey.length !== 33) {
-            publicKey = compressPublicKey$1(publicKey);
+            publicKey = compressPublicKey(publicKey);
         }
         return ENR.create({
             ...kvs,
@@ -14824,7 +14150,7 @@ class EnrCreator {
     static async fromPeerId(peerId, kvs = {}) {
         switch (peerId.type) {
             case "secp256k1":
-                return EnrCreator.fromPublicKey(getPublicKeyFromPeerId(peerId), kvs);
+                return EnrCreator.fromPublicKey(peerId.publicKey.raw, kvs);
             default:
                 throw new Error();
         }
@@ -15478,7 +14804,7 @@ async function fromValues(values) {
         }
     }
     const _seq = decodeSeq(seq);
-    const enr = await ENR.create(obj, _seq, signature);
+    const enr = ENR.create(obj, _seq, signature);
     checkSignature(seq, kvs, enr, signature);
     return enr;
 }
@@ -15511,4 +14837,4 @@ function checkSignature(seq, kvs, enr, signature) {
     }
 }
 
-export { ENR, ERR_INVALID_ID, ERR_NO_SIGNATURE, EnrCreator, EnrDecoder, MAX_RECORD_SIZE, MULTIADDR_LENGTH_SIZE, TransportProtocol, TransportProtocolPerIpVersion, compressPublicKey$1 as compressPublicKey, createPeerIdFromPublicKey, decodeWaku2, encodeWaku2, getPrivateKeyFromPeerId, getPublicKeyFromPeerId, keccak256, sign$1 as sign, verifySignature };
+export { ENR, ERR_INVALID_ID, ERR_NO_SIGNATURE, ERR_TYPE_NOT_IMPLEMENTED, EnrCreator, EnrDecoder, MAX_RECORD_SIZE, MULTIADDR_LENGTH_SIZE, TransportProtocol, TransportProtocolPerIpVersion, compressPublicKey, createPeerIdFromPublicKey, decodeWaku2, encodeWaku2, keccak256, sign$1 as sign, verifySignature };