@libp2p/crypto 4.1.9 → 5.0.0-1210884ed

package/dist/src/keys/secp256k1/secp256k1.d.ts

@@ -0,0 +1,24 @@
+import { CID } from 'multiformats/cid';
+import type { Secp256k1PublicKey as Secp256k1PublicKeyInterface, Secp256k1PrivateKey as Secp256k1PrivateKeyInterface } from '@libp2p/interface';
+import type { Digest } from 'multiformats/hashes/digest';
+import type { Uint8ArrayList } from 'uint8arraylist';
+export declare class Secp256k1PublicKey implements Secp256k1PublicKeyInterface {
+    readonly type = "secp256k1";
+    readonly raw: Uint8Array;
+    readonly _key: Uint8Array;
+    constructor(key: Uint8Array);
+    toMultihash(): Digest<0x0, number>;
+    toCID(): CID<unknown, 114, 0x0, 1>;
+    toString(): string;
+    equals(key: any): boolean;
+    verify(data: Uint8Array | Uint8ArrayList, sig: Uint8Array): boolean;
+}
+export declare class Secp256k1PrivateKey implements Secp256k1PrivateKeyInterface {
+    readonly type = "secp256k1";
+    readonly raw: Uint8Array;
+    readonly publicKey: Secp256k1PublicKey;
+    constructor(key: Uint8Array, publicKey?: Uint8Array);
+    equals(key?: any): boolean;
+    sign(message: Uint8Array | Uint8ArrayList): Uint8Array | Promise<Uint8Array>;
+}
+//# sourceMappingURL=secp256k1.d.ts.map

package/dist/src/keys/secp256k1/secp256k1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"secp256k1.d.ts","sourceRoot":"","sources":["../../../../src/keys/secp256k1/secp256k1.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AAMtC,OAAO,KAAK,EAAE,kBAAkB,IAAI,2BAA2B,EAAE,mBAAmB,IAAI,4BAA4B,EAAE,MAAM,mBAAmB,CAAA;AAC/I,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAA;AACxD,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,qBAAa,kBAAmB,YAAW,2BAA2B;IACpE,SAAgB,IAAI,eAAc;IAClC,SAAgB,GAAG,EAAE,UAAU,CAAA;IAC/B,SAAgB,IAAI,EAAE,UAAU,CAAA;gBAEnB,GAAG,EAAE,UAAU;IAK5B,WAAW,IAAK,MAAM,CAAC,GAAG,EAAE,MAAM,CAAC;IAInC,KAAK,IAAK,GAAG,CAAC,OAAO,EAAE,GAAG,EAAE,GAAG,EAAE,CAAC,CAAC;IAInC,QAAQ,IAAK,MAAM;IAInB,MAAM,CAAE,GAAG,EAAE,GAAG,GAAG,OAAO;IAQ1B,MAAM,CAAE,IAAI,EAAE,UAAU,GAAG,cAAc,EAAE,GAAG,EAAE,UAAU,GAAG,OAAO;CAGrE;AAED,qBAAa,mBAAoB,YAAW,4BAA4B;IACtE,SAAgB,IAAI,eAAc;IAClC,SAAgB,GAAG,EAAE,UAAU,CAAA;IAC/B,SAAgB,SAAS,EAAE,kBAAkB,CAAA;gBAEhC,GAAG,EAAE,UAAU,EAAE,SAAS,CAAC,EAAE,UAAU;IAKpD,MAAM,CAAE,GAAG,CAAC,EAAE,GAAG,GAAG,OAAO;IAQ3B,IAAI,CAAE,OAAO,EAAE,UAAU,GAAG,cAAc,GAAG,UAAU,GAAG,OAAO,CAAC,UAAU,CAAC;CAG9E"}

package/dist/src/keys/secp256k1/secp256k1.js

@@ -0,0 +1,53 @@
+import { base58btc } from 'multiformats/bases/base58';
+import { CID } from 'multiformats/cid';
+import { identity } from 'multiformats/hashes/identity';
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals';
+import { publicKeyToProtobuf } from '../index.js';
+import { validateSecp256k1PublicKey, compressSecp256k1PublicKey, computeSecp256k1PublicKey, validateSecp256k1PrivateKey } from './utils.js';
+import { hashAndVerify, hashAndSign } from './index.js';
+export class Secp256k1PublicKey {
+    type = 'secp256k1';
+    raw;
+    _key;
+    constructor(key) {
+        this._key = validateSecp256k1PublicKey(key);
+        this.raw = compressSecp256k1PublicKey(this._key);
+    }
+    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;
+        }
+        return uint8ArrayEquals(this.raw, key.raw);
+    }
+    verify(data, sig) {
+        return hashAndVerify(this._key, sig, data);
+    }
+}
+export class Secp256k1PrivateKey {
+    type = 'secp256k1';
+    raw;
+    publicKey;
+    constructor(key, publicKey) {
+        this.raw = validateSecp256k1PrivateKey(key);
+        this.publicKey = new Secp256k1PublicKey(publicKey ?? computeSecp256k1PublicKey(key));
+    }
+    equals(key) {
+        if (key == null || !(key.raw instanceof Uint8Array)) {
+            return false;
+        }
+        return uint8ArrayEquals(this.raw, key.raw);
+    }
+    sign(message) {
+        return hashAndSign(this.raw, message);
+    }
+}
+//# sourceMappingURL=secp256k1.js.map

package/dist/src/keys/secp256k1/secp256k1.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"secp256k1.js","sourceRoot":"","sources":["../../../../src/keys/secp256k1/secp256k1.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,2BAA2B,CAAA;AACrD,OAAO,EAAE,GAAG,EAAE,MAAM,kBAAkB,CAAA;AACtC,OAAO,EAAE,QAAQ,EAAE,MAAM,8BAA8B,CAAA;AACvD,OAAO,EAAE,MAAM,IAAI,gBAAgB,EAAE,MAAM,oBAAoB,CAAA;AAC/D,OAAO,EAAE,mBAAmB,EAAE,MAAM,aAAa,CAAA;AACjD,OAAO,EAAE,0BAA0B,EAAE,0BAA0B,EAAE,yBAAyB,EAAE,2BAA2B,EAAE,MAAM,YAAY,CAAA;AAC3I,OAAO,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAKvD,MAAM,OAAO,kBAAkB;IACb,IAAI,GAAG,WAAW,CAAA;IAClB,GAAG,CAAY;IACf,IAAI,CAAY;IAEhC,YAAa,GAAe;QAC1B,IAAI,CAAC,IAAI,GAAG,0BAA0B,CAAC,GAAG,CAAC,CAAA;QAC3C,IAAI,CAAC,GAAG,GAAG,0BAA0B,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;IAClD,CAAC;IAED,WAAW;QACT,OAAO,QAAQ,CAAC,MAAM,CAAC,mBAAmB,CAAC,IAAI,CAAC,CAAC,CAAA;IACnD,CAAC;IAED,KAAK;QACH,OAAO,GAAG,CAAC,QAAQ,CAAC,GAAG,EAAE,IAAI,CAAC,WAAW,EAAE,CAAC,CAAA;IAC9C,CAAC;IAED,QAAQ;QACN,OAAO,SAAS,CAAC,MAAM,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,KAAK,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;IAChE,CAAC;IAED,MAAM,CAAE,GAAQ;QACd,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,YAAY,UAAU,CAAC,EAAE,CAAC;YACpD,OAAO,KAAK,CAAA;QACd,CAAC;QAED,OAAO,gBAAgB,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAA;IAC5C,CAAC;IAED,MAAM,CAAE,IAAiC,EAAE,GAAe;QACxD,OAAO,aAAa,CAAC,IAAI,CAAC,IAAI,EAAE,GAAG,EAAE,IAAI,CAAC,CAAA;IAC5C,CAAC;CACF;AAED,MAAM,OAAO,mBAAmB;IACd,IAAI,GAAG,WAAW,CAAA;IAClB,GAAG,CAAY;IACf,SAAS,CAAoB;IAE7C,YAAa,GAAe,EAAE,SAAsB;QAClD,IAAI,CAAC,GAAG,GAAG,2BAA2B,CAAC,GAAG,CAAC,CAAA;QAC3C,IAAI,CAAC,SAAS,GAAG,IAAI,kBAAkB,CAAC,SAAS,IAAI,yBAAyB,CAAC,GAAG,CAAC,CAAC,CAAA;IACtF,CAAC;IAED,MAAM,CAAE,GAAS;QACf,IAAI,GAAG,IAAI,IAAI,IAAI,CAAC,CAAC,GAAG,CAAC,GAAG,YAAY,UAAU,CAAC,EAAE,CAAC;YACpD,OAAO,KAAK,CAAA;QACd,CAAC;QAED,OAAO,gBAAgB,CAAC,IAAI,CAAC,GAAG,EAAE,GAAG,CAAC,GAAG,CAAC,CAAA;IAC5C,CAAC;IAED,IAAI,CAAE,OAAoC;QACxC,OAAO,WAAW,CAAC,IAAI,CAAC,GAAG,EAAE,OAAO,CAAC,CAAA;IACvC,CAAC;CACF"}

package/dist/src/keys/secp256k1/utils.d.ts

@@ -0,0 +1,13 @@
+import type { Secp256k1PublicKey, Secp256k1PrivateKey } from '@libp2p/interface';
+declare const PRIVATE_KEY_BYTE_LENGTH = 32;
+export { PRIVATE_KEY_BYTE_LENGTH as privateKeyLength };
+export declare function unmarshalSecp256k1PrivateKey(bytes: Uint8Array): Secp256k1PrivateKey;
+export declare function unmarshalSecp256k1PublicKey(bytes: Uint8Array): Secp256k1PublicKey;
+export declare function generateSecp256k1KeyPair(): Promise<Secp256k1PrivateKey>;
+export declare function compressSecp256k1PublicKey(key: Uint8Array): Uint8Array;
+export declare function decompressSecp256k1PublicKey(key: Uint8Array): Uint8Array;
+export declare function validateSecp256k1PrivateKey(key: Uint8Array): Uint8Array;
+export declare function validateSecp256k1PublicKey(key: Uint8Array): Uint8Array;
+export declare function computeSecp256k1PublicKey(privateKey: Uint8Array): Uint8Array;
+export declare function generateSecp256k1PrivateKey(): Uint8Array;
+//# sourceMappingURL=utils.d.ts.map

package/dist/src/keys/secp256k1/utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/keys/secp256k1/utils.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,kBAAkB,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAA;AAEhF,QAAA,MAAM,uBAAuB,KAAK,CAAA;AAElC,OAAO,EAAE,uBAAuB,IAAI,gBAAgB,EAAE,CAAA;AAEtD,wBAAgB,4BAA4B,CAAE,KAAK,EAAE,UAAU,GAAG,mBAAmB,CAEpF;AAED,wBAAgB,2BAA2B,CAAE,KAAK,EAAE,UAAU,GAAG,kBAAkB,CAElF;AAED,wBAAsB,wBAAwB,IAAK,OAAO,CAAC,mBAAmB,CAAC,CAG9E;AAED,wBAAgB,0BAA0B,CAAE,GAAG,EAAE,UAAU,GAAG,UAAU,CAGvE;AAED,wBAAgB,4BAA4B,CAAE,GAAG,EAAE,UAAU,GAAG,UAAU,CAGzE;AAED,wBAAgB,2BAA2B,CAAE,GAAG,EAAE,UAAU,GAAG,UAAU,CAQxE;AAED,wBAAgB,0BAA0B,CAAE,GAAG,EAAE,UAAU,GAAG,UAAU,CAQvE;AAED,wBAAgB,yBAAyB,CAAE,UAAU,EAAE,UAAU,GAAG,UAAU,CAM7E;AAED,wBAAgB,2BAA2B,IAAK,UAAU,CAEzD"}

package/dist/src/keys/secp256k1/utils.js

@@ -0,0 +1,53 @@
+import { InvalidPrivateKeyError, InvalidPublicKeyError } from '@libp2p/interface';
+import { secp256k1 as secp } from '@noble/curves/secp256k1';
+import { Secp256k1PublicKey as Secp256k1PublicKeyClass, Secp256k1PrivateKey as Secp256k1PrivateKeyClass } from './secp256k1.js';
+const PRIVATE_KEY_BYTE_LENGTH = 32;
+export { PRIVATE_KEY_BYTE_LENGTH as privateKeyLength };
+export function unmarshalSecp256k1PrivateKey(bytes) {
+    return new Secp256k1PrivateKeyClass(bytes);
+}
+export function unmarshalSecp256k1PublicKey(bytes) {
+    return new Secp256k1PublicKeyClass(bytes);
+}
+export async function generateSecp256k1KeyPair() {
+    const privateKeyBytes = generateSecp256k1PrivateKey();
+    return new Secp256k1PrivateKeyClass(privateKeyBytes);
+}
+export function compressSecp256k1PublicKey(key) {
+    const point = secp.ProjectivePoint.fromHex(key).toRawBytes(true);
+    return point;
+}
+export function decompressSecp256k1PublicKey(key) {
+    const point = secp.ProjectivePoint.fromHex(key).toRawBytes(false);
+    return point;
+}
+export function validateSecp256k1PrivateKey(key) {
+    try {
+        secp.getPublicKey(key, true);
+        return key;
+    }
+    catch (err) {
+        throw new InvalidPrivateKeyError(String(err));
+    }
+}
+export function validateSecp256k1PublicKey(key) {
+    try {
+        secp.ProjectivePoint.fromHex(key);
+        return key;
+    }
+    catch (err) {
+        throw new InvalidPublicKeyError(String(err));
+    }
+}
+export function computeSecp256k1PublicKey(privateKey) {
+    try {
+        return secp.getPublicKey(privateKey, true);
+    }
+    catch (err) {
+        throw new InvalidPrivateKeyError(String(err));
+    }
+}
+export function generateSecp256k1PrivateKey() {
+    return secp.utils.randomPrivateKey();
+}
+//# sourceMappingURL=utils.js.map

package/dist/src/keys/secp256k1/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sourceRoot":"","sources":["../../../../src/keys/secp256k1/utils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAA;AACjF,OAAO,EAAE,SAAS,IAAI,IAAI,EAAE,MAAM,yBAAyB,CAAA;AAC3D,OAAO,EAAE,kBAAkB,IAAI,uBAAuB,EAAE,mBAAmB,IAAI,wBAAwB,EAAE,MAAM,gBAAgB,CAAA;AAG/H,MAAM,uBAAuB,GAAG,EAAE,CAAA;AAElC,OAAO,EAAE,uBAAuB,IAAI,gBAAgB,EAAE,CAAA;AAEtD,MAAM,UAAU,4BAA4B,CAAE,KAAiB;IAC7D,OAAO,IAAI,wBAAwB,CAAC,KAAK,CAAC,CAAA;AAC5C,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAE,KAAiB;IAC5D,OAAO,IAAI,uBAAuB,CAAC,KAAK,CAAC,CAAA;AAC3C,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,wBAAwB;IAC5C,MAAM,eAAe,GAAG,2BAA2B,EAAE,CAAA;IACrD,OAAO,IAAI,wBAAwB,CAAC,eAAe,CAAC,CAAA;AACtD,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAE,GAAe;IACzD,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,IAAI,CAAC,CAAA;IAChE,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,UAAU,4BAA4B,CAAE,GAAe;IAC3D,MAAM,KAAK,GAAG,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAC,UAAU,CAAC,KAAK,CAAC,CAAA;IACjE,OAAO,KAAK,CAAA;AACd,CAAC;AAED,MAAM,UAAU,2BAA2B,CAAE,GAAe;IAC1D,IAAI,CAAC;QACH,IAAI,CAAC,YAAY,CAAC,GAAG,EAAE,IAAI,CAAC,CAAA;QAE5B,OAAO,GAAG,CAAA;IACZ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,sBAAsB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;IAC/C,CAAC;AACH,CAAC;AAED,MAAM,UAAU,0BAA0B,CAAE,GAAe;IACzD,IAAI,CAAC;QACH,IAAI,CAAC,eAAe,CAAC,OAAO,CAAC,GAAG,CAAC,CAAA;QAEjC,OAAO,GAAG,CAAA;IACZ,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,qBAAqB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;IAC9C,CAAC;AACH,CAAC;AAED,MAAM,UAAU,yBAAyB,CAAE,UAAsB;IAC/D,IAAI,CAAC;QACH,OAAO,IAAI,CAAC,YAAY,CAAC,UAAU,EAAE,IAAI,CAAC,CAAA;IAC5C,CAAC;IAAC,OAAO,GAAG,EAAE,CAAC;QACb,MAAM,IAAI,sBAAsB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAA;IAC/C,CAAC;AACH,CAAC;AAED,MAAM,UAAU,2BAA2B;IACzC,OAAO,IAAI,CAAC,KAAK,CAAC,gBAAgB,EAAE,CAAA;AACtC,CAAC"}

package/dist/src/pbkdf2.js

@@ -1,4 +1,4 @@
-import { CodeError } from '@libp2p/interface';
+import { InvalidParametersError } from '@libp2p/interface';
 import { pbkdf2 as pbkdf2Sync } from '@noble/hashes/pbkdf2';
 import { sha1 } from '@noble/hashes/sha1';
 import { sha256 } from '@noble/hashes/sha256';
@@ -22,7 +22,7 @@ const hashName = {
 export default function pbkdf2(password, salt, iterations, keySize, hash) {
     if (hash !== 'sha1' && hash !== 'sha2-256' && hash !== 'sha2-512') {
         const types = Object.keys(hashName).join(' / ');
-        throw new CodeError(`Hash '${hash}' is unknown or not supported. Must be ${types}`, 'ERR_UNSUPPORTED_HASH_TYPE');
+        throw new InvalidParametersError(`Hash '${hash}' is unknown or not supported. Must be ${types}`);
     }
     const hasher = hashName[hash];
     const dek = pbkdf2Sync(hasher, password, salt, {

package/dist/src/pbkdf2.js.map

@@ -1 +1 @@
-{"version":3,"file":"pbkdf2.js","sourceRoot":"","sources":["../../src/pbkdf2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AAElD;;;;;;GAMG;AACH,MAAM,QAAQ,GAAG;IACf,IAAI;IACJ,UAAU,EAAE,MAAM;IAClB,UAAU,EAAE,MAAM;CACnB,CAAA;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,MAAM,CAAE,QAAgB,EAAE,IAAyB,EAAE,UAAkB,EAAE,OAAe,EAAE,IAAY;IAC5H,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,UAAU,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;QAClE,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAC/C,MAAM,IAAI,SAAS,CAAC,SAAS,IAAI,0CAA0C,KAAK,EAAE,EAAE,2BAA2B,CAAC,CAAA;IAClH,CAAC;IAED,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC7B,MAAM,GAAG,GAAG,UAAU,CACpB,MAAM,EACN,QAAQ,EACR,IAAI,EAAE;QACJ,CAAC,EAAE,UAAU;QACb,KAAK,EAAE,OAAO;KACf,CACF,CAAA;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;AACxC,CAAC"}
+{"version":3,"file":"pbkdf2.js","sourceRoot":"","sources":["../../src/pbkdf2.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC1D,OAAO,EAAE,MAAM,IAAI,UAAU,EAAE,MAAM,sBAAsB,CAAA;AAC3D,OAAO,EAAE,IAAI,EAAE,MAAM,oBAAoB,CAAA;AACzC,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAA;AAC7C,OAAO,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AAElD;;;;;;GAMG;AACH,MAAM,QAAQ,GAAG;IACf,IAAI;IACJ,UAAU,EAAE,MAAM;IAClB,UAAU,EAAE,MAAM;CACnB,CAAA;AAED;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,MAAM,CAAE,QAAgB,EAAE,IAAyB,EAAE,UAAkB,EAAE,OAAe,EAAE,IAAY;IAC5H,IAAI,IAAI,KAAK,MAAM,IAAI,IAAI,KAAK,UAAU,IAAI,IAAI,KAAK,UAAU,EAAE,CAAC;QAClE,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;QAC/C,MAAM,IAAI,sBAAsB,CAAC,SAAS,IAAI,0CAA0C,KAAK,EAAE,CAAC,CAAA;IAClG,CAAC;IAED,MAAM,MAAM,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAA;IAC7B,MAAM,GAAG,GAAG,UAAU,CACpB,MAAM,EACN,QAAQ,EACR,IAAI,EAAE;QACJ,CAAC,EAAE,UAAU;QACb,KAAK,EAAE,OAAO;KACf,CACF,CAAA;IAED,OAAO,MAAM,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,CAAA;AACxC,CAAC"}

package/dist/src/random-bytes.js

@@ -1,11 +1,11 @@
-import { CodeError } from '@libp2p/interface';
+import { InvalidParametersError } from '@libp2p/interface';
 import { randomBytes as randB } from '@noble/hashes/utils';
 /**
  * Generates a Uint8Array with length `number` populated by random bytes
  */
 export default function randomBytes(length) {
     if (isNaN(length) || length <= 0) {
-        throw new CodeError('random bytes length must be a Number bigger than 0', 'ERR_INVALID_LENGTH');
+        throw new InvalidParametersError('random bytes length must be a Number bigger than 0');
     }
     return randB(length);
 }

package/dist/src/random-bytes.js.map

@@ -1 +1 @@
-{"version":3,"file":"random-bytes.js","sourceRoot":"","sources":["../../src/random-bytes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,mBAAmB,CAAA;AAC7C,OAAO,EAAE,WAAW,IAAI,KAAK,EAAE,MAAM,qBAAqB,CAAA;AAE1D;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CAAE,MAAc;IACjD,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,SAAS,CAAC,oDAAoD,EAAE,oBAAoB,CAAC,CAAA;IACjG,CAAC;IACD,OAAO,KAAK,CAAC,MAAM,CAAC,CAAA;AACtB,CAAC"}
+{"version":3,"file":"random-bytes.js","sourceRoot":"","sources":["../../src/random-bytes.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,mBAAmB,CAAA;AAC1D,OAAO,EAAE,WAAW,IAAI,KAAK,EAAE,MAAM,qBAAqB,CAAA;AAE1D;;GAEG;AACH,MAAM,CAAC,OAAO,UAAU,WAAW,CAAE,MAAc;IACjD,IAAI,KAAK,CAAC,MAAM,CAAC,IAAI,MAAM,IAAI,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,sBAAsB,CAAC,oDAAoD,CAAC,CAAA;IACxF,CAAC;IACD,OAAO,KAAK,CAAC,MAAM,CAAC,CAAA;AACtB,CAAC"}

package/dist/src/webcrypto/index.d.ts

@@ -0,0 +1,3 @@
+import webcrypto from './webcrypto.js';
+export default webcrypto;
+//# sourceMappingURL=index.d.ts.map

package/dist/src/webcrypto/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/webcrypto/index.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAEtC,eAAe,SAAS,CAAA"}

package/dist/src/webcrypto/index.js

@@ -0,0 +1,3 @@
+import webcrypto from './webcrypto.js';
+export default webcrypto;
+//# sourceMappingURL=index.js.map

package/dist/src/webcrypto/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/webcrypto/index.ts"],"names":[],"mappings":"AAAA,OAAO,SAAS,MAAM,gBAAgB,CAAA;AAEtC,eAAe,SAAS,CAAA"}

package/dist/src/{webcrypto-browser.d.ts → webcrypto/webcrypto.browser.d.ts}

@@ -2,4 +2,4 @@ declare const _default: {
     get(win?: typeof globalThis): Crypto;
 };
 export default _default;
-//# sourceMappingURL=webcrypto-browser.d.ts.map
+//# sourceMappingURL=webcrypto.browser.d.ts.map

package/dist/src/webcrypto/webcrypto.browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.browser.d.ts","sourceRoot":"","sources":["../../../src/webcrypto/webcrypto.browser.ts"],"names":[],"mappings":";;;AAMA,wBAgBC"}

package/dist/src/{webcrypto-browser.js → webcrypto/webcrypto.browser.js}

@@ -1,17 +1,18 @@
 /* eslint-env browser */
+import { WebCryptoMissingError } from '../errors.js';
 // Check native crypto exists and is enabled (In insecure context `self.crypto`
 // exists but `self.crypto.subtle` does not).
 export default {
     get(win = globalThis) {
         const nativeCrypto = win.crypto;
         if (nativeCrypto?.subtle == null) {
-            throw Object.assign(new Error('Missing Web Crypto API. ' +
+            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'), { code: 'ERR_MISSING_WEB_CRYPTO' });
+                'https://github.com/libp2p/js-libp2p/blob/main/packages/crypto/README.md#web-crypto-api');
         }
         return nativeCrypto;
     }
 };
-//# sourceMappingURL=webcrypto-browser.js.map
+//# sourceMappingURL=webcrypto.browser.js.map

package/dist/src/webcrypto/webcrypto.browser.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.browser.js","sourceRoot":"","sources":["../../../src/webcrypto/webcrypto.browser.ts"],"names":[],"mappings":"AAAA,wBAAwB;AAExB,OAAO,EAAE,qBAAqB,EAAE,MAAM,cAAc,CAAA;AAEpD,+EAA+E;AAC/E,6CAA6C;AAC7C,eAAe;IACb,GAAG,CAAE,GAAG,GAAG,UAAU;QACnB,MAAM,YAAY,GAAG,GAAG,CAAC,MAAM,CAAA;QAE/B,IAAI,YAAY,EAAE,MAAM,IAAI,IAAI,EAAE,CAAC;YACjC,MAAM,IAAI,qBAAqB,CAC7B,0BAA0B;gBAC1B,0EAA0E;gBAC1E,sEAAsE;gBACtE,2BAA2B;gBAC3B,wFAAwF,CACzF,CAAA;QACH,CAAC;QAED,OAAO,YAAY,CAAA;IACrB,CAAC;CACF,CAAA"}

package/dist/src/webcrypto/webcrypto.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.d.ts","sourceRoot":"","sources":["../../../src/webcrypto/webcrypto.ts"],"names":[],"mappings":";AAEA,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;;;;AAIlC,wBAIC"}

package/dist/src/webcrypto/webcrypto.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"webcrypto.js","sourceRoot":"","sources":["../../../src/webcrypto/webcrypto.ts"],"names":[],"mappings":"AAAA,wBAAwB;AAExB,OAAO,EAAE,SAAS,EAAE,MAAM,QAAQ,CAAA;AAElC,6EAA6E;AAC7E,kEAAkE;AAClE,eAAe;IACb,GAAG,CAAE,GAAG,GAAG,UAAU;QACnB,OAAO,SAAS,CAAA;IAClB,CAAC;CACF,CAAA"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/crypto",
-  "version": "4.1.9",
+  "version": "5.0.0-1210884ed",
   "description": "Crypto primitives for libp2p",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/crypto#readme",
@@ -51,6 +51,10 @@
       "types": "./src/index.d.ts",
       "import": "./dist/src/index.js"
     },
+    "./ciphers": {
+      "types": "./dist/src/ciphers/index.d.ts",
+      "import": "./dist/src/ciphers/index.js"
+    },
     "./hmac": {
       "types": "./dist/src/hmac/index.d.ts",
       "import": "./dist/src/hmac/index.js"
@@ -58,6 +62,10 @@
     "./keys": {
       "types": "./dist/src/keys/index.d.ts",
       "import": "./dist/src/keys/index.js"
+    },
+    "./webcrypto": {
+      "types": "./dist/src/webcrypto/index.d.ts",
+      "import": "./dist/src/webcrypto/index.js"
     }
   },
   "eslintConfig": {
@@ -84,7 +92,7 @@
     "generate": "protons ./src/keys/keys.proto"
   },
   "dependencies": {
-    "@libp2p/interface": "^1.7.0",
+    "@libp2p/interface": "2.0.0-1210884ed",
     "@noble/curves": "^1.4.0",
     "@noble/hashes": "^1.4.0",
     "asn1js": "^3.0.5",
@@ -101,12 +109,12 @@
   },
   "browser": {
     "./dist/src/ciphers/aes-gcm.js": "./dist/src/ciphers/aes-gcm.browser.js",
-    "./dist/src/hmac/index.js": "./dist/src/hmac/index-browser.js",
-    "./dist/src/keys/ecdh.js": "./dist/src/keys/ecdh-browser.js",
-    "./dist/src/keys/ed25519.js": "./dist/src/keys/ed25519-browser.js",
-    "./dist/src/keys/rsa.js": "./dist/src/keys/rsa-browser.js",
-    "./dist/src/keys/secp256k1.js": "./dist/src/keys/secp256k1-browser.js",
-    "./dist/src/webcrypto.js": "./dist/src/webcrypto-browser.js"
+    "./dist/src/hmac/index.js": "./dist/src/hmac/index.browser.js",
+    "./dist/src/keys/ecdh/index.js": "./dist/src/keys/ecdh/index.browser.js",
+    "./dist/src/keys/ed25519/index.js": "./dist/src/keys/ed25519/index.browser.js",
+    "./dist/src/keys/rsa/index.js": "./dist/src/keys/rsa/index.browser.js",
+    "./dist/src/keys/secp256k1/index.js": "./dist/src/keys/secp256k1/index.browser.js",
+    "./dist/src/webcrypto/webcrypto.js": "./dist/src/webcrypto/webcrypto.browser.js"
   },
   "sideEffects": false
 }

package/src/ciphers/aes-gcm.browser.ts

@@ -1,6 +1,6 @@
 import { concat } from 'uint8arrays/concat'
 import { fromString } from 'uint8arrays/from-string'
-import webcrypto from '../webcrypto.js'
+import webcrypto from '../webcrypto/index.js'
 import type { CreateOptions, AESCipher } from './interface.js'
 
 // WebKit on Linux does not support deriving a key from an empty PBKDF2 key.

package/src/ciphers/index.ts

@@ -0,0 +1 @@
+export * as AES_GCM from './aes-gcm.js'

package/src/errors.ts

@@ -0,0 +1,29 @@
+/**
+ * Signing a message failed
+ */
+export class SigningError extends Error {
+  constructor (message = 'An error occurred while signing a message') {
+    super(message)
+    this.name = 'SigningError'
+  }
+}
+
+/**
+ * Verifying a message signature failed
+ */
+export class VerificationError extends Error {
+  constructor (message = 'An error occurred while verifying a message') {
+    super(message)
+    this.name = 'VerificationError'
+  }
+}
+
+/**
+ * WebCrypto was not available in the current context
+ */
+export class WebCryptoMissingError extends Error {
+  constructor (message = 'Missing Web Crypto API') {
+    super(message)
+    this.name = 'WebCryptoMissingError'
+  }
+}

package/src/hmac/{index-browser.ts → index.browser.ts}

@@ -1,4 +1,4 @@
-import webcrypto from '../webcrypto.js'
+import webcrypto from '../webcrypto/index.js'
 import lengths from './lengths.js'
 
 const hashTypes = {

package/src/keys/{ecdh-browser.ts → ecdh/index.browser.ts}

@@ -1,10 +1,11 @@
-import { CodeError } from '@libp2p/interface'
+import { InvalidParametersError } from '@libp2p/interface'
 import { concat as uint8ArrayConcat } from 'uint8arrays/concat'
 import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
 import { toString as uint8ArrayToString } from 'uint8arrays/to-string'
-import { base64urlToBuffer } from '../util.js'
-import webcrypto from '../webcrypto.js'
-import type { ECDHKey, ECDHKeyPair, JWKEncodedPrivateKey, JWKEncodedPublicKey } from './interface.js'
+import { base64urlToBuffer } from '../../util.js'
+import webcrypto from '../../webcrypto/index.js'
+import type { Curve } from './index.js'
+import type { ECDHKey, ECDHKeyPair, JWKEncodedPrivateKey, JWKEncodedPublicKey } from '../interface.js'
 
 const bits = {
   'P-256': 256,
@@ -15,9 +16,9 @@ const bits = {
 const curveTypes = Object.keys(bits)
 const names = curveTypes.join(' / ')
 
-export async function generateEphmeralKeyPair (curve: string): Promise<ECDHKey> {
+export async function generateEphemeralKeyPair (curve: Curve): Promise<ECDHKey> {
   if (curve !== 'P-256' && curve !== 'P-384' && curve !== 'P-521') {
-    throw new CodeError(`Unknown curve: ${curve}. Must be ${names}`, 'ERR_INVALID_CURVE')
+    throw new InvalidParametersError(`Unknown curve: ${curve}. Must be ${names}`)
   }
 
   const pair = await webcrypto.get().subtle.generateKey(
@@ -94,11 +95,11 @@ const curveLengths = {
 // go-ipfs uses)
 function marshalPublicKey (jwk: JsonWebKey): Uint8Array {
   if (jwk.crv == null || jwk.x == null || jwk.y == null) {
-    throw new CodeError('JWK was missing components', 'ERR_INVALID_PARAMETERS')
+    throw new InvalidParametersError('JWK was missing components')
   }
 
   if (jwk.crv !== 'P-256' && jwk.crv !== 'P-384' && jwk.crv !== 'P-521') {
-    throw new CodeError(`Unknown curve: ${jwk.crv}. Must be ${names}`, 'ERR_INVALID_CURVE')
+    throw new InvalidParametersError(`Unknown curve: ${jwk.crv}. Must be ${names}`)
   }
 
   const byteLen = curveLengths[jwk.crv]
@@ -110,16 +111,18 @@ function marshalPublicKey (jwk: JsonWebKey): Uint8Array {
   ], 1 + byteLen * 2)
 }
 
-// Unmarshal converts a point, serialized by Marshal, into an jwk encoded key
-function unmarshalPublicKey (curve: string, key: Uint8Array): JWKEncodedPublicKey {
+/**
+ * Unmarshal converts a point, serialized by Marshal, into an jwk encoded key
+ */
+function unmarshalPublicKey (curve: Curve, key: Uint8Array): JWKEncodedPublicKey {
   if (curve !== 'P-256' && curve !== 'P-384' && curve !== 'P-521') {
-    throw new CodeError(`Unknown curve: ${curve}. Must be ${names}`, 'ERR_INVALID_CURVE')
+    throw new InvalidParametersError(`Unknown curve: ${curve}. Must be ${names}`)
   }
 
   const byteLen = curveLengths[curve]
 
   if (!uint8ArrayEquals(key.subarray(0, 1), Uint8Array.from([4]))) {
-    throw new CodeError('Cannot unmarshal public key - invalid key format', 'ERR_INVALID_KEY_FORMAT')
+    throw new InvalidParametersError('Cannot unmarshal public key - invalid key format')
   }
 
   return {
@@ -131,7 +134,7 @@ function unmarshalPublicKey (curve: string, key: Uint8Array): JWKEncodedPublicKe
   }
 }
 
-const unmarshalPrivateKey = (curve: string, key: ECDHKeyPair): JWKEncodedPrivateKey => ({
+const unmarshalPrivateKey = (curve: Curve, key: ECDHKeyPair): JWKEncodedPrivateKey => ({
   ...unmarshalPublicKey(curve, key.public),
   d: uint8ArrayToString(key.private, 'base64url')
 })

package/src/keys/{ecdh.ts → ecdh/index.ts}

@@ -1,6 +1,8 @@
 import crypto from 'crypto'
-import { CodeError } from '@libp2p/interface'
-import type { ECDHKey, ECDHKeyPair } from './interface.js'
+import { InvalidParametersError } from '@libp2p/interface'
+import type { ECDHKey, ECDHKeyPair } from '../interface.js'
+
+export type Curve = 'P-256' | 'P-384' | 'P-521'
 
 const curves = {
   'P-256': 'prime256v1',
@@ -16,9 +18,9 @@ const names = curveTypes.join(' / ')
  *
  * Focuses only on ECDH now, but can be made more general in the future.
  */
-export async function generateEphmeralKeyPair (curve: string): Promise<ECDHKey> {
+export async function generateEphemeralKeyPair (curve: Curve): Promise<ECDHKey> {
   if (curve !== 'P-256' && curve !== 'P-384' && curve !== 'P-521') {
-    throw new CodeError(`Unknown curve: ${curve}. Must be ${names}`, 'ERR_INVALID_CURVE')
+    throw new InvalidParametersError(`Unknown curve: ${curve}. Must be ${names}`)
   }
 
   const ecdh = crypto.createECDH(curves[curve])

package/src/keys/ed25519/ed25519.ts

@@ -0,0 +1,68 @@
+import { base58btc } from 'multiformats/bases/base58'
+import { CID } from 'multiformats/cid'
+import { type Digest } from 'multiformats/hashes/digest'
+import { identity } from 'multiformats/hashes/identity'
+import { equals as uint8ArrayEquals } from 'uint8arrays/equals'
+import { publicKeyToProtobuf } from '../index.js'
+import { ensureEd25519Key } from './utils.js'
+import * as crypto from './index.js'
+import type { Ed25519PublicKey as Ed25519PublicKeyInterface, Ed25519PrivateKey as Ed25519PrivateKeyInterface } from '@libp2p/interface'
+import type { Uint8ArrayList } from 'uint8arraylist'
+
+export class Ed25519PublicKey implements Ed25519PublicKeyInterface {
+  public readonly type = 'Ed25519'
+  public readonly raw: Uint8Array
+
+  constructor (key: Uint8Array) {
+    this.raw = ensureEd25519Key(key, crypto.publicKeyLength)
+  }
+
+  toMultihash (): Digest<0x0, number> {
+    return identity.digest(publicKeyToProtobuf(this))
+  }
+
+  toCID (): CID<unknown, 114, 0x0, 1> {
+    return CID.createV1(114, this.toMultihash())
+  }
+
+  toString (): string {
+    return base58btc.encode(this.toMultihash().bytes).substring(1)
+  }
+
+  equals (key?: any): boolean {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false
+    }
+
+    return uint8ArrayEquals(this.raw, key.raw)
+  }
+
+  verify (data: Uint8Array | Uint8ArrayList, sig: Uint8Array): boolean {
+    return crypto.hashAndVerify(this.raw, sig, data)
+  }
+}
+
+export class Ed25519PrivateKey implements Ed25519PrivateKeyInterface {
+  public readonly type = 'Ed25519'
+  public readonly raw: Uint8Array
+  public readonly publicKey: Ed25519PublicKey
+
+  // key       - 64 byte Uint8Array containing private key
+  // publicKey - 32 byte Uint8Array containing public key
+  constructor (key: Uint8Array, publicKey: Uint8Array) {
+    this.raw = ensureEd25519Key(key, crypto.privateKeyLength)
+    this.publicKey = new Ed25519PublicKey(publicKey)
+  }
+
+  equals (key?: any): boolean {
+    if (key == null || !(key.raw instanceof Uint8Array)) {
+      return false
+    }
+
+    return uint8ArrayEquals(this.raw, key.raw)
+  }
+
+  sign (message: Uint8Array | Uint8ArrayList): Uint8Array {
+    return crypto.hashAndSign(this.raw, message)
+  }
+}

package/src/keys/{ed25519-browser.ts → ed25519/index.browser.ts}

@@ -1,5 +1,5 @@
 import { ed25519 as ed } from '@noble/curves/ed25519'
-import type { Uint8ArrayKeyPair } from './interface.js'
+import type { Uint8ArrayKeyPair } from '../interface.js'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 const PUBLIC_KEY_BYTE_LENGTH = 32

package/src/keys/{ed25519.ts → ed25519/index.ts}

@@ -2,7 +2,7 @@ import crypto from 'crypto'
 import { concat as uint8arrayConcat } from 'uint8arrays/concat'
 import { fromString as uint8arrayFromString } from 'uint8arrays/from-string'
 import { toString as uint8arrayToString } from 'uint8arrays/to-string'
-import type { Uint8ArrayKeyPair } from './interface.js'
+import type { Uint8ArrayKeyPair } from '../interface.js'
 import type { Uint8ArrayList } from 'uint8arraylist'
 
 const keypair = crypto.generateKeyPairSync

package/src/keys/ed25519/utils.ts

@@ -0,0 +1,42 @@
+import { InvalidParametersError } from '@libp2p/interface'
+import { Ed25519PublicKey as Ed25519PublicKeyClass, Ed25519PrivateKey as Ed25519PrivateKeyClass } from './ed25519.js'
+import * as crypto from './index.js'
+import type { Ed25519PublicKey, Ed25519PrivateKey } from '@libp2p/interface'
+
+export function unmarshalEd25519PrivateKey (bytes: Uint8Array): Ed25519PrivateKey {
+  // Try the old, redundant public key version
+  if (bytes.length > crypto.privateKeyLength) {
+    bytes = ensureEd25519Key(bytes, crypto.privateKeyLength + crypto.publicKeyLength)
+    const privateKeyBytes = bytes.subarray(0, crypto.privateKeyLength)
+    const publicKeyBytes = bytes.subarray(crypto.privateKeyLength, bytes.length)
+    return new Ed25519PrivateKeyClass(privateKeyBytes, publicKeyBytes)
+  }
+
+  bytes = ensureEd25519Key(bytes, crypto.privateKeyLength)
+  const privateKeyBytes = bytes.subarray(0, crypto.privateKeyLength)
+  const publicKeyBytes = bytes.subarray(crypto.publicKeyLength)
+  return new Ed25519PrivateKeyClass(privateKeyBytes, publicKeyBytes)
+}
+
+export function unmarshalEd25519PublicKey (bytes: Uint8Array): Ed25519PublicKey {
+  bytes = ensureEd25519Key(bytes, crypto.publicKeyLength)
+  return new Ed25519PublicKeyClass(bytes)
+}
+
+export async function generateEd25519KeyPair (): Promise<Ed25519PrivateKey> {
+  const { privateKey, publicKey } = crypto.generateKey()
+  return new Ed25519PrivateKeyClass(privateKey, publicKey)
+}
+
+export async function generateEd25519KeyPairFromSeed (seed: Uint8Array): Promise<Ed25519PrivateKey> {
+  const { privateKey, publicKey } = crypto.generateKeyFromSeed(seed)
+  return new Ed25519PrivateKeyClass(privateKey, publicKey)
+}
+
+export function ensureEd25519Key (key: Uint8Array, length: number): Uint8Array {
+  key = Uint8Array.from(key ?? [])
+  if (key.length !== length) {
+    throw new InvalidParametersError(`Key must be a Uint8Array of length ${length}, got ${key.length}`)
+  }
+  return key
+}

package/src/keys/ephemeral-keys.ts

@@ -1,4 +1,4 @@
-import { generateEphmeralKeyPair } from './ecdh.js'
+import { generateEphemeralKeyPair } from './ecdh/index.js'
 
 /**
  * Generates an ephemeral public key and returns a function that will compute
@@ -6,4 +6,4 @@ import { generateEphmeralKeyPair } from './ecdh.js'
  *
  * Focuses only on ECDH now, but can be made more general in the future.
  */
-export default generateEphmeralKeyPair
+export default generateEphemeralKeyPair