chore: update travis

.aegir.js

@@ -1,3 +0,0 @@
-module.exports = {
-  bundlesize: { maxSize: '124kB' }
-}

.travis.yml

@@ -1,15 +1,19 @@
 language: node_js
-
 cache: npm
 
+branches:
+  only:
+  - master
+  - /^release\/.*$/
+
 stages:
   - check
   - test
   - cov
 
 node_js:
-  - '10'
-  - '12'
+  - 'lts/*'
+  - 'node'
 
 os:
   - linux
@@ -23,7 +27,7 @@ jobs:
   include:
     - stage: check
       script:
-        - npx aegir build --bundlesize
+        - npx aegir build --no-types
         - npx aegir dep-check
         - npm run lint
 

package.json

@@ -18,8 +18,8 @@
   ],
   "scripts": {
     "lint": "aegir lint",
-    "build": "aegir build",
-    "build-proto": "pbjs --wrap commonjs --target static-module src/keys/keys.proto > src/keys/keys.proto.js",
+    "build": "npm run build:proto && aegir build --no-types",
+    "build:proto": "pbjs -t static-module -w commonjs --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/keys/keys.js ./src/keys/keys.proto",
     "test": "aegir test",
     "test:node": "aegir test -t node",
     "test:browser": "aegir test -t browser -t webworker",
@@ -39,19 +39,19 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "err-code": "^2.0.0",
+    "err-code": "^3.0.1",
     "is-typedarray": "^1.0.0",
-    "iso-random-stream": "^1.1.0",
+    "iso-random-stream": "^2.0.0",
     "keypair": "^1.0.1",
-    "multibase": "^3.0.0",
-    "multicodec": "^2.0.0",
+    "multibase": "^4.0.3",
+    "multicodec": "^3.0.1",
     "multihashes": "^4.0.2",
-    "multihashing-async": "^2.0.1",
+    "multihashing-async": "^2.1.2",
     "node-forge": "^0.10.0",
     "pem-jwk": "^2.0.0",
-    "protons": "^2.0.0",
+    "protobufjs": "^6.10.2",
     "secp256k1": "^4.0.0",
-    "uint8arrays": "^1.1.0",
+    "uint8arrays": "^2.1.4",
     "ursa-optional": "^0.10.1"
   },
   "devDependencies": {
@@ -59,16 +59,21 @@
     "@types/chai-string": "^1.4.2",
     "@types/dirty-chai": "^2.0.2",
     "@types/mocha": "^8.0.1",
-    "aegir": "^25.0.0",
+    "aegir": "^33.0.0",
     "benchmark": "^2.1.4",
     "chai": "^4.2.0",
     "chai-string": "^1.5.0",
     "dirty-chai": "^2.0.1",
-    "sinon": "^9.0.0"
+    "sinon": "^10.0.0",
+    "util": "^0.12.3"
+  },
+  "aegir": {
+    "build": {
+      "bundlesizeMax": "118kB"
+    }
   },
   "engines": {
-    "node": ">=10.0.0",
-    "npm": ">=6.0.0"
+    "node": ">=12.0.0"
   },
   "repository": {
     "type": "git",

src/ciphers/aes-gcm.browser.js

@@ -11,11 +11,11 @@ const webcrypto = require('../webcrypto')
  *
  * @param {object} [options]
  * @param {string} [options.algorithm=AES-GCM]
- * @param {Number} [options.nonceLength=12]
- * @param {Number} [options.keyLength=16]
+ * @param {number} [options.nonceLength=12]
+ * @param {number} [options.keyLength=16]
  * @param {string} [options.digest=sha256]
- * @param {Number} [options.saltLength=16]
- * @param {Number} [options.iterations=32767]
+ * @param {number} [options.saltLength=16]
+ * @param {number} [options.iterations=32767]
  * @returns {*}
  */
 function create ({
@@ -33,8 +33,8 @@ function create ({
    * Uses the provided password to derive a pbkdf2 key. The key
    * will then be used to encrypt the data.
    *
-   * @param {Uint8Array} data The data to decrypt
-   * @param {string} password A plain password
+   * @param {Uint8Array} data - The data to decrypt
+   * @param {string} password - A plain password
    * @returns {Promise<Uint8Array>}
    */
   async function encrypt (data, password) { // eslint-disable-line require-await
@@ -58,8 +58,8 @@ function create ({
    * this decryption cipher must be the same as those used to create
    * the encryption cipher.
    *
-   * @param {Uint8Array} data The data to decrypt
-   * @param {string} password A plain password
+   * @param {Uint8Array} data - The data to decrypt
+   * @param {string} password - A plain password
    * @returns {Promise<Uint8Array>}
    */
   async function decrypt (data, password) {

src/ciphers/aes-gcm.js

@@ -9,12 +9,12 @@ const uint8ArrayFromString = require('uint8arrays/from-string')
 /**
  *
  * @param {object} [options]
- * @param {Number} [options.algorithmTagLength=16]
- * @param {Number} [options.nonceLength=12]
- * @param {Number} [options.keyLength=16]
+ * @param {number} [options.algorithmTagLength=16]
+ * @param {number} [options.nonceLength=12]
+ * @param {number} [options.keyLength=16]
  * @param {string} [options.digest=sha256]
- * @param {Number} [options.saltLength=16]
- * @param {Number} [options.iterations=32767]
+ * @param {number} [options.saltLength=16]
+ * @param {number} [options.iterations=32767]
  * @returns {*}
  */
 function create ({
@@ -49,8 +49,8 @@ function create ({
    * Uses the provided password to derive a pbkdf2 key. The key
    * will then be used to encrypt the data.
    *
-   * @param {Uint8Array} data The data to decrypt
-   * @param {string|Uint8Array} password A plain password
+   * @param {Uint8Array} data - The data to decrypt
+   * @param {string|Uint8Array} password - A plain password
    * @returns {Promise<Uint8Array>}
    */
   async function encrypt (data, password) { // eslint-disable-line require-await
@@ -76,7 +76,7 @@ function create ({
    * the encryption cipher.
    *
    * @private
-   * @param {Uint8Array} ciphertextAndNonce The data to decrypt
+   * @param {Uint8Array} ciphertextAndNonce - The data to decrypt
    * @param {Uint8Array} key
    * @returns {Promise<Uint8Array>}
    */
@@ -100,8 +100,8 @@ function create ({
    * this decryption cipher must be the same as those used to create
    * the encryption cipher.
    *
-   * @param {Uint8Array} data The data to decrypt
-   * @param {string|Uint8Array} password A plain password
+   * @param {Uint8Array} data - The data to decrypt
+   * @param {string|Uint8Array} password - A plain password
    */
   async function decrypt (data, password) { // eslint-disable-line require-await
     // Create Uint8Arrays of salt and ciphertextAndNonce.

src/keys/ed25519-class.js

@@ -1,12 +1,11 @@
 'use strict'
 
 const sha = require('multihashing-async/src/sha')
-const protobuf = require('protons')
 const errcode = require('err-code')
 const uint8ArrayEquals = require('uint8arrays/equals')
 const mh = require('multihashes')
 const crypto = require('./ed25519')
-const pbm = protobuf(require('./keys.proto'))
+const pbm = require('./keys')
 const exporter = require('./exporter')
 
 class Ed25519PublicKey {
@@ -26,7 +25,7 @@ class Ed25519PublicKey {
     return pbm.PublicKey.encode({
       Type: pbm.KeyType.Ed25519,
       Data: this.marshal()
-    })
+    }).finish()
   }
 
   equals (key) {
@@ -62,7 +61,7 @@ class Ed25519PrivateKey {
     return pbm.PrivateKey.encode({
       Type: pbm.KeyType.Ed25519,
       Data: this.marshal()
-    })
+    }).finish()
   }
 
   equals (key) {
@@ -80,7 +79,7 @@ class Ed25519PrivateKey {
    * The public key is a protobuf encoding containing a type and the DER encoding
    * of the PKCS SubjectPublicKeyInfo.
    *
-   * @returns {Promise<String>}
+   * @returns {Promise<string>}
    */
   async id () {
     const encoding = mh.encode(this.public.bytes, 'identity')

src/keys/exporter.js

@@ -9,7 +9,7 @@ module.exports = {
    * The PrivateKey is encrypted via a password derived PBKDF2 key
    * leveraging the aes-gcm cipher algorithm.
    *
-   * @param {Uint8Array} privateKey The PrivateKey protobuf
+   * @param {Uint8Array} privateKey - The PrivateKey protobuf
    * @param {string} password
    * @returns {Promise<string>} A base64 encoded string
    */

src/keys/importer.js

@@ -9,7 +9,7 @@ module.exports = {
    * with the given password. The privateKey must have been exported
    * using the same password and underlying cipher (aes-gcm)
    *
-   * @param {string} privateKey A base64 encoded encrypted key
+   * @param {string} privateKey - A base64 encoded encrypted key
    * @param {string} password
    * @returns {Promise<Uint8Array>} The private key protobuf
    */

src/keys/index.js

@@ -1,7 +1,6 @@
 'use strict'
 
-const protobuf = require('protons')
-const keysPBM = protobuf(require('./keys.proto'))
+const keysPBM = require('./keys')
 require('node-forge/lib/asn1')
 require('node-forge/lib/pbe')
 const forge = require('node-forge/lib/forge')
@@ -10,17 +9,12 @@ const uint8ArrayFromString = require('uint8arrays/from-string')
 
 const importer = require('./importer')
 
-exports = module.exports
-
 const supportedKeys = {
   rsa: require('./rsa-class'),
   ed25519: require('./ed25519-class'),
   secp256k1: require('./secp256k1-class')(keysPBM, require('../random-bytes'))
 }
 
-exports.supportedKeys = supportedKeys
-exports.keysPBM = keysPBM
-
 const ErrMissingSecp256K1 = {
   message: 'secp256k1 support requires libp2p-crypto-secp256k1 package',
   code: 'ERR_MISSING_PACKAGE'
@@ -35,17 +29,14 @@ function typeToKey (type) {
   return key
 }
 
-exports.keyStretcher = require('./key-stretcher')
-exports.generateEphemeralKeyPair = require('./ephemeral-keys')
-
 // Generates a keypair of the given type and bitsize
-exports.generateKeyPair = async (type, bits) => { // eslint-disable-line require-await
+const generateKeyPair = async (type, bits) => { // eslint-disable-line require-await
   return typeToKey(type).generateKeyPair(bits)
 }
 
 // Generates a keypair of the given type and bitsize
 // seed is a 32 byte uint8array
-exports.generateKeyPairFromSeed = async (type, seed, bits) => { // eslint-disable-line require-await
+const generateKeyPairFromSeed = async (type, seed, bits) => { // eslint-disable-line require-await
   const key = typeToKey(type)
   if (type.toLowerCase() !== 'ed25519') {
     throw errcode(new Error('Seed key derivation is unimplemented for RSA or secp256k1'), 'ERR_UNSUPPORTED_KEY_DERIVATION_TYPE')
@@ -55,7 +46,7 @@ exports.generateKeyPairFromSeed = async (type, seed, bits) => { // eslint-disabl
 
 // Converts a protobuf serialized public key into its
 // representative object
-exports.unmarshalPublicKey = (buf) => {
+const unmarshalPublicKey = (buf) => {
   const decoded = keysPBM.PublicKey.decode(buf)
   const data = decoded.Data
 
@@ -76,7 +67,7 @@ exports.unmarshalPublicKey = (buf) => {
 }
 
 // Converts a public key object into a protobuf serialized public key
-exports.marshalPublicKey = (key, type) => {
+const marshalPublicKey = (key, type) => {
   type = (type || 'rsa').toLowerCase()
   typeToKey(type) // check type
   return key.bytes
@@ -84,7 +75,7 @@ exports.marshalPublicKey = (key, type) => {
 
 // Converts a protobuf serialized private key into its
 // representative object
-exports.unmarshalPrivateKey = async (buf) => { // eslint-disable-line require-await
+const unmarshalPrivateKey = async (buf) => { // eslint-disable-line require-await
   const decoded = keysPBM.PrivateKey.decode(buf)
   const data = decoded.Data
 
@@ -105,7 +96,7 @@ exports.unmarshalPrivateKey = async (buf) => { // eslint-disable-line require-aw
 }
 
 // Converts a private key object into a protobuf serialized private key
-exports.marshalPrivateKey = (key, type) => {
+const marshalPrivateKey = (key, type) => {
   type = (type || 'rsa').toLowerCase()
   typeToKey(type) // check type
   return key.bytes
@@ -116,10 +107,10 @@ exports.marshalPrivateKey = (key, type) => {
  * @param {string} encryptedKey
  * @param {string} password
  */
-exports.import = async (encryptedKey, password) => { // eslint-disable-line require-await
+const importKey = async (encryptedKey, password) => { // eslint-disable-line require-await
   try {
     const key = await importer.import(encryptedKey, password)
-    return exports.unmarshalPrivateKey(key)
+    return unmarshalPrivateKey(key)
   } catch (_) {
     // Ignore and try the old pem decrypt
   }
@@ -133,3 +124,17 @@ exports.import = async (encryptedKey, password) => { // eslint-disable-line requ
   der = uint8ArrayFromString(der.getBytes(), 'ascii')
   return supportedKeys.rsa.unmarshalRsaPrivateKey(der)
 }
+
+module.exports = {
+  supportedKeys,
+  keysPBM,
+  keyStretcher: require('./key-stretcher'),
+  generateEphemeralKeyPair: require('./ephemeral-keys'),
+  generateKeyPair,
+  generateKeyPairFromSeed,
+  unmarshalPublicKey,
+  marshalPublicKey,
+  unmarshalPrivateKey,
+  marshalPrivateKey,
+  import: importKey
+}

src/keys/keys.js

@@ -0,0 +1,378 @@
+/*eslint-disable*/
+"use strict";
+
+var $protobuf = require("protobufjs/minimal");
+
+// Common aliases
+var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
+
+// Exported root namespace
+var $root = $protobuf.roots["default"] || ($protobuf.roots["default"] = {});
+
+/**
+ * KeyType enum.
+ * @exports KeyType
+ * @enum {number}
+ * @property {number} RSA=0 RSA value
+ * @property {number} Ed25519=1 Ed25519 value
+ * @property {number} Secp256k1=2 Secp256k1 value
+ */
+$root.KeyType = (function() {
+    var valuesById = {}, values = Object.create(valuesById);
+    values[valuesById[0] = "RSA"] = 0;
+    values[valuesById[1] = "Ed25519"] = 1;
+    values[valuesById[2] = "Secp256k1"] = 2;
+    return values;
+})();
+
+$root.PublicKey = (function() {
+
+    /**
+     * 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
+     */
+    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 $root.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 $root.PublicKey)
+            return d;
+        var m = new $root.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);
+    };
+
+    return PublicKey;
+})();
+
+$root.PrivateKey = (function() {
+
+    /**
+     * 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
+     */
+    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 $root.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 $root.PrivateKey)
+            return d;
+        var m = new $root.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);
+    };
+
+    return PrivateKey;
+})();
+
+module.exports = $root;

src/keys/keys.proto

@@ -1,6 +1,6 @@
-'use strict'
+syntax = "proto3";
 
-module.exports = `enum KeyType {
+enum KeyType {
   RSA = 0;
   Ed25519 = 1;
   Secp256k1 = 2;
@@ -12,4 +12,4 @@ message PublicKey {
 message PrivateKey {
   required KeyType Type = 1;
   required bytes Data = 2;
-}`
+}

src/keys/rsa-class.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const sha = require('multihashing-async/src/sha')
-const protobuf = require('protons')
 const errcode = require('err-code')
 const uint8ArrayEquals = require('uint8arrays/equals')
 const uint8ArrayToString = require('uint8arrays/to-string')
@@ -11,7 +10,7 @@ require('node-forge/lib/ed25519')
 const forge = require('node-forge/lib/forge')
 
 const crypto = require('./rsa')
-const pbm = protobuf(require('./keys.proto'))
+const pbm = require('./keys')
 const exporter = require('./exporter')
 
 class RsaPublicKey {
@@ -31,7 +30,7 @@ class RsaPublicKey {
     return pbm.PublicKey.encode({
       Type: pbm.KeyType.RSA,
       Data: this.marshal()
-    })
+    }).finish()
   }
 
   encrypt (bytes) {
@@ -83,7 +82,7 @@ class RsaPrivateKey {
     return pbm.PrivateKey.encode({
       Type: pbm.KeyType.RSA,
       Data: this.marshal()
-    })
+    }).finish()
   }
 
   equals (key) {
@@ -101,7 +100,7 @@ class RsaPrivateKey {
    * The public key is a protobuf encoding containing a type and the DER encoding
    * of the PKCS SubjectPublicKeyInfo.
    *
-   * @returns {Promise<String>}
+   * @returns {Promise<string>}
    */
   async id () {
     const hash = await this.public.hash()

src/keys/secp256k1-class.js

@@ -28,7 +28,7 @@ module.exports = (keysProtobuf, randomBytes, crypto) => {
       return keysProtobuf.PublicKey.encode({
         Type: keysProtobuf.KeyType.Secp256k1,
         Data: this.marshal()
-      })
+      }).finish()
     }
 
     equals (key) {
@@ -64,7 +64,7 @@ module.exports = (keysProtobuf, randomBytes, crypto) => {
       return keysProtobuf.PrivateKey.encode({
         Type: keysProtobuf.KeyType.Secp256k1,
         Data: this.marshal()
-      })
+      }).finish()
     }
 
     equals (key) {

src/pbkdf2.js

@@ -23,7 +23,7 @@ const hashName = {
  * @param {string} password
  * @param {string} salt
  * @param {number} iterations
- * @param {number} keySize (in bytes)
+ * @param {number} keySize - (in bytes)
  * @param {string} hash - The hash name ('sha1', 'sha2-512, ...)
  * @returns {string} - A new password
  */

test/crypto.spec.js

@@ -51,7 +51,7 @@ describe('libp2p-crypto', function () {
   })
 
   it('generateKeyPairFromSeed', () => {
-    var seed = crypto.randomBytes(32)
+    const seed = crypto.randomBytes(32)
     return expectErrCode(crypto.keys.generateKeyPairFromSeed('invalid-key-type', seed, 512), 'ERR_UNSUPPORTED_KEY_TYPE')
   })
 

test/keys/ed25519.spec.js

@@ -33,7 +33,7 @@ describe('ed25519', function () {
   })
 
   it('generates a valid key from seed', async () => {
-    var seed = crypto.randomBytes(32)
+    const seed = crypto.randomBytes(32)
     const seededkey = await crypto.keys.generateKeyPairFromSeed('Ed25519', seed, 512)
     expect(seededkey).to.be.an.instanceof(ed25519.Ed25519PrivateKey)
     const digest = await seededkey.hash()