@libp2p/crypto 0.22.9 → 0.22.12

package/src/keys/index.ts

@@ -11,11 +11,14 @@ import { importer } from './importer.js'
 import * as RSA from './rsa-class.js'
 import * as Ed25519 from './ed25519-class.js'
 import * as Secp256k1 from './secp256k1-class.js'
+import type { PrivateKey, PublicKey } from '@libp2p/interfaces/keys'
 
 export { keyStretcher }
 export { generateEphemeralKeyPair }
 export { keysPBM }
 
+export type KeyTypes = 'RSA' | 'Ed25519' | 'secp256k1'
+
 export const supportedKeys = {
   rsa: RSA,
   ed25519: Ed25519,
@@ -38,13 +41,13 @@ function typeToKey (type: string) {
 }
 
 // Generates a keypair of the given type and bitsize
-export async function generateKeyPair (type: 'RSA' | 'Ed25519' | 'secp256k1', bits?: number) { // eslint-disable-line require-await
+export async function generateKeyPair (type: KeyTypes, bits?: number): Promise<PrivateKey> { // eslint-disable-line require-await
   return await typeToKey(type).generateKeyPair(bits ?? 2048)
 }
 
 // Generates a keypair of the given type and bitsize
 // seed is a 32 byte uint8array
-export async function generateKeyPairFromSeed (type: 'RSA' | 'Ed25519' | 'secp256k1', seed: Uint8Array, bits?: number) { // eslint-disable-line require-await
+export async function generateKeyPairFromSeed (type: KeyTypes, seed: Uint8Array, bits?: number): Promise<PrivateKey> { // eslint-disable-line require-await
   if (type.toLowerCase() !== 'ed25519') {
     throw errcode(new Error('Seed key derivation is unimplemented for RSA or secp256k1'), 'ERR_UNSUPPORTED_KEY_DERIVATION_TYPE')
   }
@@ -54,7 +57,7 @@ export async function generateKeyPairFromSeed (type: 'RSA' | 'Ed25519' | 'secp25
 
 // Converts a protobuf serialized public key into its
 // representative object
-export function unmarshalPublicKey (buf: Uint8Array) {
+export function unmarshalPublicKey (buf: Uint8Array): PublicKey {
   const decoded = keysPBM.PublicKey.decode(buf)
   const data = decoded.Data
 
@@ -71,7 +74,7 @@ export function unmarshalPublicKey (buf: Uint8Array) {
 }
 
 // Converts a public key object into a protobuf serialized public key
-export function marshalPublicKey (key: { bytes: Uint8Array }, type?: string) {
+export function marshalPublicKey (key: { bytes: Uint8Array }, type?: string): Uint8Array {
   type = (type ?? 'rsa').toLowerCase()
   typeToKey(type) // check type
   return key.bytes
@@ -79,7 +82,7 @@ export function marshalPublicKey (key: { bytes: Uint8Array }, type?: string) {
 
 // Converts a protobuf serialized private key into its
 // representative object
-export async function unmarshalPrivateKey (buf: Uint8Array) { // eslint-disable-line require-await
+export async function unmarshalPrivateKey (buf: Uint8Array): Promise<PrivateKey> { // eslint-disable-line require-await
   const decoded = keysPBM.PrivateKey.decode(buf)
   const data = decoded.Data
 
@@ -96,7 +99,7 @@ export async function unmarshalPrivateKey (buf: Uint8Array) { // eslint-disable-
 }
 
 // Converts a private key object into a protobuf serialized private key
-export function marshalPrivateKey (key: { bytes: Uint8Array }, type?: string) {
+export function marshalPrivateKey (key: { bytes: Uint8Array }, type?: string): Uint8Array {
   type = (type ?? 'rsa').toLowerCase()
   typeToKey(type) // check type
   return key.bytes
@@ -107,7 +110,7 @@ export function marshalPrivateKey (key: { bytes: Uint8Array }, type?: string) {
  * @param {string} encryptedKey
  * @param {string} password
  */
-export async function importKey (encryptedKey: string, password: string) { // eslint-disable-line require-await
+export async function importKey (encryptedKey: string, password: string): Promise<PrivateKey> { // eslint-disable-line require-await
   try {
     const key = await importer(encryptedKey, password)
     return await unmarshalPrivateKey(key)

package/src/keys/keys.ts

@@ -0,0 +1,66 @@
+/* eslint-disable import/export */
+/* eslint-disable @typescript-eslint/no-namespace */
+
+import { enumeration, encodeMessage, decodeMessage, message, bytes } from 'protons-runtime'
+import type { Codec } from 'protons-runtime'
+
+export enum KeyType {
+  RSA = 'RSA',
+  Ed25519 = 'Ed25519',
+  Secp256k1 = 'Secp256k1'
+}
+
+enum __KeyTypeValues {
+  RSA = 0,
+  Ed25519 = 1,
+  Secp256k1 = 2
+}
+
+export namespace KeyType {
+  export const codec = () => {
+    return enumeration<typeof KeyType>(__KeyTypeValues)
+  }
+}
+export interface PublicKey {
+  Type: KeyType
+  Data: Uint8Array
+}
+
+export namespace PublicKey {
+  export const codec = (): Codec<PublicKey> => {
+    return message<PublicKey>({
+      1: { name: 'Type', codec: KeyType.codec() },
+      2: { name: 'Data', codec: bytes }
+    })
+  }
+
+  export const encode = (obj: PublicKey): Uint8Array => {
+    return encodeMessage(obj, PublicKey.codec())
+  }
+
+  export const decode = (buf: Uint8Array): PublicKey => {
+    return decodeMessage(buf, PublicKey.codec())
+  }
+}
+
+export interface PrivateKey {
+  Type: KeyType
+  Data: Uint8Array
+}
+
+export namespace PrivateKey {
+  export const codec = (): Codec<PrivateKey> => {
+    return message<PrivateKey>({
+      1: { name: 'Type', codec: KeyType.codec() },
+      2: { name: 'Data', codec: bytes }
+    })
+  }
+
+  export const encode = (obj: PrivateKey): Uint8Array => {
+    return encodeMessage(obj, PrivateKey.codec())
+  }
+
+  export const decode = (buf: Uint8Array): PrivateKey => {
+    return decodeMessage(buf, PrivateKey.codec())
+  }
+}

package/src/keys/rsa-class.ts

@@ -29,7 +29,7 @@ export class RsaPublicKey {
     return pbm.PublicKey.encode({
       Type: pbm.KeyType.RSA,
       Data: this.marshal()
-    }).finish()
+    })
   }
 
   encrypt (bytes: Uint8Array) {
@@ -84,7 +84,7 @@ export class RsaPrivateKey {
     return pbm.PrivateKey.encode({
       Type: pbm.KeyType.RSA,
       Data: this.marshal()
-    }).finish()
+    })
   }
 
   equals (key: any) {

package/src/keys/secp256k1-class.ts

@@ -26,7 +26,7 @@ export class Secp256k1PublicKey {
     return keysProtobuf.PublicKey.encode({
       Type: keysProtobuf.KeyType.Secp256k1,
       Data: this.marshal()
-    }).finish()
+    })
   }
 
   equals (key: any) {
@@ -67,7 +67,7 @@ export class Secp256k1PrivateKey {
     return keysProtobuf.PrivateKey.encode({
       Type: keysProtobuf.KeyType.Secp256k1,
       Data: this.marshal()
-    }).finish()
+    })
   }
 
   equals (key: any) {

package/src/keys/keys.d.ts

@@ -1,146 +0,0 @@
-import $protobuf from 'protobufjs'
-
-/** KeyType enum. */
-export enum KeyType {
-  RSA = 0,
-  Ed25519 = 1,
-  Secp256k1 = 2
-}
-
-export interface IPublicKey {
-
-  /** PublicKey Type. */
-  Type: KeyType
-
-  /** PublicKey Data. */
-  Data: Uint8Array
-}
-
-/** Represents a PublicKey. */
-export class PublicKey implements IPublicKey {
-  /**
-   * Constructs a new PublicKey.
-   *
-   * @param [p] - Properties to set
-   */
-  constructor (p?: IPublicKey);
-
-  /** PublicKey Type. */
-  public Type: KeyType
-
-  /** PublicKey Data. */
-  public Data: Uint8Array
-
-  /**
-   * Encodes the specified PublicKey message. Does not implicitly {@link PublicKey.verify|verify} messages.
-   *
-   * @param m - PublicKey message or plain object to encode
-   * @param [w] - Writer to encode to
-   * @returns Writer
-   */
-  public static encode (m: IPublicKey, w?: $protobuf.Writer): $protobuf.Writer;
-
-  /**
-   * Decodes a PublicKey message from the specified reader or buffer.
-   *
-   * @param r - Reader or buffer to decode from
-   * @param [l] - Message length if known beforehand
-   * @returns PublicKey
-   * @throws {Error} If the payload is not a reader or valid buffer
-   * @throws {$protobuf.util.ProtocolError} If required fields are missing
-   */
-  public static decode (r: ($protobuf.Reader|Uint8Array), l?: number): PublicKey;
-
-  /**
-   * Creates a PublicKey message from a plain object. Also converts values to their respective internal types.
-   *
-   * @param d - Plain object
-   * @returns PublicKey
-   */
-  public static fromObject (d: { [k: string]: any }): PublicKey;
-
-  /**
-   * Creates a plain object from a PublicKey message. Also converts values to other types if specified.
-   *
-   * @param m - PublicKey
-   * @param [o] - Conversion options
-   * @returns Plain object
-   */
-  public static toObject (m: PublicKey, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-  /**
-   * Converts this PublicKey to JSON.
-   *
-   * @returns JSON object
-   */
-  public toJSON (): { [k: string]: any };
-}
-
-export interface IPrivateKey {
-
-  /** PrivateKey Type. */
-  Type: KeyType
-
-  /** PrivateKey Data. */
-  Data: Uint8Array
-}
-
-/** Represents a PrivateKey. */
-export class PrivateKey implements IPrivateKey {
-  /**
-   * Constructs a new PrivateKey.
-   *
-   * @param [p] - Properties to set
-   */
-  constructor (p?: IPrivateKey);
-
-  /** PrivateKey Type. */
-  public Type: KeyType
-
-  /** PrivateKey Data. */
-  public Data: Uint8Array
-
-  /**
-   * Encodes the specified PrivateKey message. Does not implicitly {@link PrivateKey.verify|verify} messages.
-   *
-   * @param m - PrivateKey message or plain object to encode
-   * @param [w] - Writer to encode to
-   * @returns Writer
-   */
-  public static encode (m: IPrivateKey, w?: $protobuf.Writer): $protobuf.Writer;
-
-  /**
-   * Decodes a PrivateKey message from the specified reader or buffer.
-   *
-   * @param r - Reader or buffer to decode from
-   * @param [l] - Message length if known beforehand
-   * @returns PrivateKey
-   * @throws {Error} If the payload is not a reader or valid buffer
-   * @throws {$protobuf.util.ProtocolError} If required fields are missing
-   */
-  public static decode (r: ($protobuf.Reader|Uint8Array), l?: number): PrivateKey;
-
-  /**
-   * Creates a PrivateKey message from a plain object. Also converts values to their respective internal types.
-   *
-   * @param d - Plain object
-   * @returns PrivateKey
-   */
-  public static fromObject (d: { [k: string]: any }): PrivateKey;
-
-  /**
-   * Creates a plain object from a PrivateKey message. Also converts values to other types if specified.
-   *
-   * @param m - PrivateKey
-   * @param [o] - Conversion options
-   * @returns Plain object
-   */
-  public static toObject (m: PrivateKey, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-  /**
-   * Converts this PrivateKey to JSON.
-   *
-   * @returns JSON object
-   */
-  public toJSON (): { [k: string]: any };
-}

package/src/keys/keys.js

@@ -1,366 +0,0 @@
-// @ts-nocheck
-
-/*eslint-disable*/
-import $protobuf from "protobufjs/minimal.js";
-
-// Common aliases
-const $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
-
-// Exported root namespace
-const $root = $protobuf.roots["libp2p-crypto-keys"] || ($protobuf.roots["libp2p-crypto-keys"] = {});
-
-/**
- * KeyType enum.
- * @exports KeyType
- * @enum {number}
- * @property {number} RSA=0 RSA value
- * @property {number} Ed25519=1 Ed25519 value
- * @property {number} Secp256k1=2 Secp256k1 value
- */
-export const KeyType = $root.KeyType = (() => {
-    const valuesById = {}, values = Object.create(valuesById);
-    values[valuesById[0] = "RSA"] = 0;
-    values[valuesById[1] = "Ed25519"] = 1;
-    values[valuesById[2] = "Secp256k1"] = 2;
-    return values;
-})();
-
-/**
- * Properties of a PublicKey.
- * @exports IPublicKey
- * @interface IPublicKey
- * @property {KeyType} Type PublicKey Type
- * @property {Uint8Array} Data PublicKey Data
- */
-
-/**
- * Constructs a new PublicKey.
- * @exports PublicKey
- * @classdesc Represents a PublicKey.
- * @implements IPublicKey
- * @constructor
- * @param {IPublicKey=} [p] Properties to set
- */
-export function PublicKey(p) {
-    if (p)
-        for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
-            if (p[ks[i]] != null)
-                this[ks[i]] = p[ks[i]];
-}
-
-/**
- * PublicKey Type.
- * @member {KeyType} Type
- * @memberof PublicKey
- * @instance
- */
-PublicKey.prototype.Type = 0;
-
-/**
- * PublicKey Data.
- * @member {Uint8Array} Data
- * @memberof PublicKey
- * @instance
- */
-PublicKey.prototype.Data = $util.newBuffer([]);
-
-/**
- * Encodes the specified PublicKey message. Does not implicitly {@link PublicKey.verify|verify} messages.
- * @function encode
- * @memberof PublicKey
- * @static
- * @param {IPublicKey} m PublicKey message or plain object to encode
- * @param {$protobuf.Writer} [w] Writer to encode to
- * @returns {$protobuf.Writer} Writer
- */
-PublicKey.encode = function encode(m, w) {
-    if (!w)
-        w = $Writer.create();
-    w.uint32(8).int32(m.Type);
-    w.uint32(18).bytes(m.Data);
-    return w;
-};
-
-/**
- * Decodes a PublicKey message from the specified reader or buffer.
- * @function decode
- * @memberof PublicKey
- * @static
- * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
- * @param {number} [l] Message length if known beforehand
- * @returns {PublicKey} PublicKey
- * @throws {Error} If the payload is not a reader or valid buffer
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
- */
-PublicKey.decode = function decode(r, l) {
-    if (!(r instanceof $Reader))
-        r = $Reader.create(r);
-    var c = l === undefined ? r.len : r.pos + l, m = new PublicKey();
-    while (r.pos < c) {
-        var t = r.uint32();
-        switch (t >>> 3) {
-        case 1:
-            m.Type = r.int32();
-            break;
-        case 2:
-            m.Data = r.bytes();
-            break;
-        default:
-            r.skipType(t & 7);
-            break;
-        }
-    }
-    if (!m.hasOwnProperty("Type"))
-        throw $util.ProtocolError("missing required 'Type'", { instance: m });
-    if (!m.hasOwnProperty("Data"))
-        throw $util.ProtocolError("missing required 'Data'", { instance: m });
-    return m;
-};
-
-/**
- * Creates a PublicKey message from a plain object. Also converts values to their respective internal types.
- * @function fromObject
- * @memberof PublicKey
- * @static
- * @param {Object.<string,*>} d Plain object
- * @returns {PublicKey} PublicKey
- */
-PublicKey.fromObject = function fromObject(d) {
-    if (d instanceof PublicKey)
-        return d;
-    var m = new PublicKey();
-    switch (d.Type) {
-    case "RSA":
-    case 0:
-        m.Type = 0;
-        break;
-    case "Ed25519":
-    case 1:
-        m.Type = 1;
-        break;
-    case "Secp256k1":
-    case 2:
-        m.Type = 2;
-        break;
-    }
-    if (d.Data != null) {
-        if (typeof d.Data === "string")
-            $util.base64.decode(d.Data, m.Data = $util.newBuffer($util.base64.length(d.Data)), 0);
-        else if (d.Data.length)
-            m.Data = d.Data;
-    }
-    return m;
-};
-
-/**
- * Creates a plain object from a PublicKey message. Also converts values to other types if specified.
- * @function toObject
- * @memberof PublicKey
- * @static
- * @param {PublicKey} m PublicKey
- * @param {$protobuf.IConversionOptions} [o] Conversion options
- * @returns {Object.<string,*>} Plain object
- */
-PublicKey.toObject = function toObject(m, o) {
-    if (!o)
-        o = {};
-    var d = {};
-    if (o.defaults) {
-        d.Type = o.enums === String ? "RSA" : 0;
-        if (o.bytes === String)
-            d.Data = "";
-        else {
-            d.Data = [];
-            if (o.bytes !== Array)
-                d.Data = $util.newBuffer(d.Data);
-        }
-    }
-    if (m.Type != null && m.hasOwnProperty("Type")) {
-        d.Type = o.enums === String ? $root.KeyType[m.Type] : m.Type;
-    }
-    if (m.Data != null && m.hasOwnProperty("Data")) {
-        d.Data = o.bytes === String ? $util.base64.encode(m.Data, 0, m.Data.length) : o.bytes === Array ? Array.prototype.slice.call(m.Data) : m.Data;
-    }
-    return d;
-};
-
-/**
- * Converts this PublicKey to JSON.
- * @function toJSON
- * @memberof PublicKey
- * @instance
- * @returns {Object.<string,*>} JSON object
- */
-PublicKey.prototype.toJSON = function toJSON() {
-    return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
-};
-
-/**
- * Properties of a PrivateKey.
- * @exports IPrivateKey
- * @interface IPrivateKey
- * @property {KeyType} Type PrivateKey Type
- * @property {Uint8Array} Data PrivateKey Data
- */
-
-/**
- * Constructs a new PrivateKey.
- * @exports PrivateKey
- * @classdesc Represents a PrivateKey.
- * @implements IPrivateKey
- * @constructor
- * @param {IPrivateKey=} [p] Properties to set
- */
-export function PrivateKey(p) {
-    if (p)
-        for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
-            if (p[ks[i]] != null)
-                this[ks[i]] = p[ks[i]];
-}
-
-/**
- * PrivateKey Type.
- * @member {KeyType} Type
- * @memberof PrivateKey
- * @instance
- */
-PrivateKey.prototype.Type = 0;
-
-/**
- * PrivateKey Data.
- * @member {Uint8Array} Data
- * @memberof PrivateKey
- * @instance
- */
-PrivateKey.prototype.Data = $util.newBuffer([]);
-
-/**
- * Encodes the specified PrivateKey message. Does not implicitly {@link PrivateKey.verify|verify} messages.
- * @function encode
- * @memberof PrivateKey
- * @static
- * @param {IPrivateKey} m PrivateKey message or plain object to encode
- * @param {$protobuf.Writer} [w] Writer to encode to
- * @returns {$protobuf.Writer} Writer
- */
-PrivateKey.encode = function encode(m, w) {
-    if (!w)
-        w = $Writer.create();
-    w.uint32(8).int32(m.Type);
-    w.uint32(18).bytes(m.Data);
-    return w;
-};
-
-/**
- * Decodes a PrivateKey message from the specified reader or buffer.
- * @function decode
- * @memberof PrivateKey
- * @static
- * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
- * @param {number} [l] Message length if known beforehand
- * @returns {PrivateKey} PrivateKey
- * @throws {Error} If the payload is not a reader or valid buffer
- * @throws {$protobuf.util.ProtocolError} If required fields are missing
- */
-PrivateKey.decode = function decode(r, l) {
-    if (!(r instanceof $Reader))
-        r = $Reader.create(r);
-    var c = l === undefined ? r.len : r.pos + l, m = new PrivateKey();
-    while (r.pos < c) {
-        var t = r.uint32();
-        switch (t >>> 3) {
-        case 1:
-            m.Type = r.int32();
-            break;
-        case 2:
-            m.Data = r.bytes();
-            break;
-        default:
-            r.skipType(t & 7);
-            break;
-        }
-    }
-    if (!m.hasOwnProperty("Type"))
-        throw $util.ProtocolError("missing required 'Type'", { instance: m });
-    if (!m.hasOwnProperty("Data"))
-        throw $util.ProtocolError("missing required 'Data'", { instance: m });
-    return m;
-};
-
-/**
- * Creates a PrivateKey message from a plain object. Also converts values to their respective internal types.
- * @function fromObject
- * @memberof PrivateKey
- * @static
- * @param {Object.<string,*>} d Plain object
- * @returns {PrivateKey} PrivateKey
- */
-PrivateKey.fromObject = function fromObject(d) {
-    if (d instanceof PrivateKey)
-        return d;
-    var m = new PrivateKey();
-    switch (d.Type) {
-    case "RSA":
-    case 0:
-        m.Type = 0;
-        break;
-    case "Ed25519":
-    case 1:
-        m.Type = 1;
-        break;
-    case "Secp256k1":
-    case 2:
-        m.Type = 2;
-        break;
-    }
-    if (d.Data != null) {
-        if (typeof d.Data === "string")
-            $util.base64.decode(d.Data, m.Data = $util.newBuffer($util.base64.length(d.Data)), 0);
-        else if (d.Data.length)
-            m.Data = d.Data;
-    }
-    return m;
-};
-
-/**
- * Creates a plain object from a PrivateKey message. Also converts values to other types if specified.
- * @function toObject
- * @memberof PrivateKey
- * @static
- * @param {PrivateKey} m PrivateKey
- * @param {$protobuf.IConversionOptions} [o] Conversion options
- * @returns {Object.<string,*>} Plain object
- */
-PrivateKey.toObject = function toObject(m, o) {
-    if (!o)
-        o = {};
-    var d = {};
-    if (o.defaults) {
-        d.Type = o.enums === String ? "RSA" : 0;
-        if (o.bytes === String)
-            d.Data = "";
-        else {
-            d.Data = [];
-            if (o.bytes !== Array)
-                d.Data = $util.newBuffer(d.Data);
-        }
-    }
-    if (m.Type != null && m.hasOwnProperty("Type")) {
-        d.Type = o.enums === String ? $root.KeyType[m.Type] : m.Type;
-    }
-    if (m.Data != null && m.hasOwnProperty("Data")) {
-        d.Data = o.bytes === String ? $util.base64.encode(m.Data, 0, m.Data.length) : o.bytes === Array ? Array.prototype.slice.call(m.Data) : m.Data;
-    }
-    return d;
-};
-
-/**
- * Converts this PrivateKey to JSON.
- * @function toJSON
- * @memberof PrivateKey
- * @instance
- * @returns {Object.<string,*>} JSON object
- */
-PrivateKey.prototype.toJSON = function toJSON() {
-    return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
-};