feat: use async/await

This PR changes this module to remove callbacks and use async/await. The API is unchanged aside from the obvious removal of the `callback` parameter.

depends on `multihashing-async` PR TODO

refs ipfs/js-ipfs#1670

License: MIT
Signed-off-by: Alan Shaw <[email protected]>

Author: Alan Shaw

.gitignore

@@ -32,3 +32,5 @@ build
 node_modules
 
 dist
+
+package-lock.json

.travis.yml

@@ -4,10 +4,10 @@ language: node_js
 
 matrix:
   include:
-  - node_js: 6
-    env: CXX=g++-4.8
   - node_js: 8
     env: CXX=g++-4.8
+  - node_js: 10
+    env: CXX=g++-4.8
     #  - node_js: stable
     #    env: CXX=g++-4.8
 

README.md

@@ -10,9 +10,9 @@
 
 > Support for secp256k1 keys in js-libp2p-crypto
 
-This repo contains a [js-libp2p-crypto](https://github.com/libp2p/js-libp2p-crypto)-compatible 
-implementation of cryptographic signature generation and verification using the 
-[secp256k1 elliptic curve](https://en.bitcoin.it/wiki/Secp256k1) popularized by Bitcoin and other 
+This repo contains a [js-libp2p-crypto](https://github.com/libp2p/js-libp2p-crypto)-compatible
+implementation of cryptographic signature generation and verification using the
+[secp256k1 elliptic curve](https://en.bitcoin.it/wiki/Secp256k1) popularized by Bitcoin and other
 crypto currencies.  
 
 ## Lead Captain
@@ -25,14 +25,14 @@ crypto currencies.
 - [Usage](#usage)
   - [Example](#example)
 - [API](#api)
-  - [`generateKeyPair([bits,] callback)`](#generatekeypairbits-callback)
+  - [`generateKeyPair([bits])`](#generatekeypairbits)
   - [`unmarshalSecp256k1PublicKey(bytes)`](#unmarshalsecp256k1publickeybytes)
-  - [`unmarshalSecp256k1PrivateKey(bytes, callback)`](#unmarshalsecp256k1privatekeybytes-callback)
+  - [`unmarshalSecp256k1PrivateKey(bytes)`](#unmarshalsecp256k1privatekeybytes)
   - [`Secp256k1PublicKey`](#secp256k1publickey)
-    - [`.verify(data, sig, callback)`](#verifydata-sig-callback)
+    - [`.verify(data, sig)`](#verifydata-sig)
   - [`Secp256k1PrivateKey`](#secp256k1privatekey)
     - [`.public`](#public)
-    - [`.sign(data, callback)`](#signdata-callback)
+    - [`.sign(data)`](#signdata)
 - [Contribute](#contribute)
 - [License](#license)
 
@@ -54,63 +54,65 @@ instances of the `Secp256k1PublicKey` or `Secp256k1PrivateKey` classes provided
 
 ```js
 const crypto = require('libp2p-crypto')
-
 const msg = Buffer.from('Hello World')
 
-crypto.generateKeyPair('secp256k1', 256, (err, key) => {
-  // assuming no error, key will be an instance of Secp256k1PrivateKey
-  // the public key is available as key.public
-  key.sign(msg, (err, sig) => {
-    key.public.verify(msg, sig, (err, valid) => {
-      assert(valid, 'Something went horribly wrong')
-    })
-  })
-})
+const key = await crypto.generateKeyPair('secp256k1', 256)
+// assuming no error, key will be an instance of Secp256k1PrivateKey
+// the public key is available as key.public
+const sig = await key.sign(msg)
+
+const valid = await key.public.verify(msg, sig)
+assert(valid, 'Something went horribly wrong')
 ```
 
 ## API
 
 The functions below are the public API of this module.
-For usage within libp2p-crypto, see the [libp2p-crypto API documentation](https://github.com/libp2p/js-libp2p-crypto#api).
+For usage within `libp2p-crypto`, see the [`libp2p-crypto` API documentation](https://github.com/libp2p/js-libp2p-crypto#api).
 
-### `generateKeyPair([bits, ] callback)`
+### `generateKeyPair([bits])`
 - `bits: Number` - Optional, included for compatibility with js-libp2p-crypto. Ignored if present; private keys will always be 256 bits.
-- `callback: Function`
+
+Returns `Promise<Secp256k1PrivateKey>`
 
 ### `unmarshalSecp256k1PublicKey(bytes)`
 - `bytes: Buffer`
 
 Converts a serialized secp256k1 public key into an instance of `Secp256k1PublicKey` and returns it
 
-### `unmarshalSecp256k1PrivateKey(bytes, callback)`
+### `unmarshalSecp256k1PrivateKey(bytes)`
 - `bytes: Buffer`
-- `callback: Function`
 
-Converts a serialized secp256k1 private key into an instance of `Secp256k1PrivateKey`, passing it to `callback` on success
+Returns `Promise<Secp256k1PrivateKey>`
+
+Converts a serialized secp256k1 private key into an instance of `Secp256k1PrivateKey`.
 
 ### `Secp256k1PublicKey`
 
-#### `.verify(data, sig, callback)`
+#### `.verify(data, sig)`
 - `data: Buffer`
 - `sig: Buffer`
-- `callback: Function`
 
-Calculates the SHA-256 hash of `data`, and verifies the DER-encoded signature in `sig`, passing the result to `callback`
+Returns `Promise<Boolean>`
+
+Calculates the SHA-256 hash of `data`, and verifies the DER-encoded signature in `sig`.
 
 ### `Secp256k1PrivateKey`
 
 #### `.public`
 
 Accessor for the `Secp256k1PublicKey` associated with this private key.
 
-#### `.sign(data, callback)`
+#### `.sign(data)`
 - `data: Buffer`
 
-Calculates the SHA-256 hash of `data` and signs it, passing the DER-encoded signature to `callback`
+Returns `Promise<Buffer>`
+
+Calculates the SHA-256 hash of `data` and signs it, resolves with the DER-encoded signature.
 
 ## Contribute
 
-Feel free to join in. All welcome. Open an [issue](https://github.com/libp2p/js-libp2p-crypto/issues)!
+Feel free to join in. All welcome. Open an [issue](https://github.com/libp2p/js-libp2p-crypto-secp256k1/issues)!
 
 This repository falls under the IPFS [Code of Conduct](https://github.com/ipfs/community/blob/master/code-of-conduct.md).
 

package.json

@@ -8,16 +8,16 @@
     "secp256k1": "secp256k1/js"
   },
   "scripts": {
-    "lint": "aegir-lint",
-    "build": "aegir-build",
+    "lint": "aegir lint",
+    "build": "aegir build",
     "test": "npm run test:node && npm run test:browser",
-    "test:node": "aegir-test --env node",
-    "test:browser": "aegir-test --env browser",
-    "release": "aegir-release",
-    "release-minor": "aegir-release --type minor",
-    "release-major": "aegir-release --type major",
-    "coverage": "aegir-coverage",
-    "coverage-publish": "aegir-coverage publish"
+    "test:node": "aegir test -t node",
+    "test:browser": "aegir test -t browser",
+    "release": "aegir release",
+    "release-minor": "aegir release --type minor",
+    "release-major": "aegir release --type major",
+    "coverage": "aegir coverage",
+    "coverage-publish": "aegir coverage publish"
   },
   "keywords": [
     "IPFS",
@@ -27,18 +27,15 @@
   ],
   "license": "MIT",
   "dependencies": {
-    "async": "^2.6.0",
-    "multihashing-async": "~0.4.8",
-    "nodeify": "^1.0.1",
-    "safe-buffer": "^5.1.2",
+    "multihashing-async": "^0.5.1",
     "secp256k1": "^3.5.0"
   },
   "devDependencies": {
-    "aegir": "^13.1.0",
+    "aegir": "^17.0.0",
     "benchmark": "^2.1.4",
-    "libp2p-crypto": "~0.13.0",
     "chai": "^4.1.2",
-    "dirty-chai": "^2.0.1"
+    "dirty-chai": "^2.0.1",
+    "libp2p-crypto": "^0.14.0"
   },
   "engines": {
     "node": ">=6.0.0",

src/crypto.js

@@ -2,49 +2,40 @@
 
 const secp256k1 = require('secp256k1')
 const multihashing = require('multihashing-async')
-const setImmediate = require('async/setImmediate')
 
 const HASH_ALGORITHM = 'sha2-256'
 
 module.exports = (randomBytes) => {
   const privateKeyLength = 32
 
-  function generateKey (callback) {
-    const done = (err, res) => setImmediate(() => callback(err, res))
-
+  async function generateKey () {
     let privateKey
     do {
       privateKey = randomBytes(32)
     } while (!secp256k1.privateKeyVerify(privateKey))
-
-    done(null, privateKey)
+    return privateKey
   }
 
-  function hashAndSign (key, msg, callback) {
-    const done = (err, res) => setImmediate(() => callback(err, res))
-
-    multihashing.digest(msg, HASH_ALGORITHM, (err, digest) => {
-      if (err) { return done(err) }
-
-      try {
-        const sig = secp256k1.sign(digest, key)
-        const sigDER = secp256k1.signatureExport(sig.signature)
-        return done(null, sigDER)
-      } catch (err) { done(err) }
+  async function hashAndSign (key, msg) {
+    const digest = await new Promise((resolve, reject) => {
+      multihashing.digest(msg, HASH_ALGORITHM, (err, digest) => {
+        if (err) return reject(err)
+        resolve(digest)
+      })
     })
+    const sig = secp256k1.sign(digest, key)
+    return secp256k1.signatureExport(sig.signature)
   }
 
-  function hashAndVerify (key, sig, msg, callback) {
-    const done = (err, res) => setImmediate(() => callback(err, res))
-
-    multihashing.digest(msg, HASH_ALGORITHM, (err, digest) => {
-      if (err) { return done(err) }
-      try {
-        sig = secp256k1.signatureImport(sig)
-        const valid = secp256k1.verify(digest, sig, key)
-        return done(null, valid)
-      } catch (err) { done(err) }
+  async function hashAndVerify (key, sig, msg) {
+    const digest = await new Promise((resolve, reject) => {
+      multihashing.digest(msg, HASH_ALGORITHM, (err, digest) => {
+        if (err) return reject(err)
+        resolve(digest)
+      })
     })
+    sig = secp256k1.signatureImport(sig)
+    return secp256k1.verify(digest, sig, key)
   }
 
   function compressPublicKey (key) {
@@ -76,14 +67,14 @@ module.exports = (randomBytes) => {
   }
 
   return {
-    generateKey: generateKey,
-    privateKeyLength: privateKeyLength,
-    hashAndSign: hashAndSign,
-    hashAndVerify: hashAndVerify,
-    compressPublicKey: compressPublicKey,
-    decompressPublicKey: decompressPublicKey,
-    validatePrivateKey: validatePrivateKey,
-    validatePublicKey: validatePublicKey,
-    computePublicKey: computePublicKey
+    generateKey,
+    privateKeyLength,
+    hashAndSign,
+    hashAndVerify,
+    compressPublicKey,
+    decompressPublicKey,
+    validatePrivateKey,
+    validatePublicKey,
+    computePublicKey
   }
 }

src/index.js

@@ -11,9 +11,8 @@ module.exports = (keysProtobuf, randomBytes, crypto) => {
       this._key = key
     }
 
-    verify (data, sig, callback) {
-      ensure(callback)
-      crypto.hashAndVerify(this._key, sig, data, callback)
+    async verify (data, sig) {
+      return crypto.hashAndVerify(this._key, sig, data)
     }
 
     marshal () {
@@ -31,9 +30,13 @@ module.exports = (keysProtobuf, randomBytes, crypto) => {
       return this.bytes.equals(key.bytes)
     }
 
-    hash (callback) {
-      ensure(callback)
-      multihashing(this.bytes, 'sha2-256', callback)
+    async hash () {
+      return new Promise((resolve, reject) => {
+        multihashing(this.bytes, 'sha2-256', (err, res) => {
+          if (err) return reject(err)
+          resolve(res)
+        })
+      })
     }
   }
 
@@ -45,9 +48,8 @@ module.exports = (keysProtobuf, randomBytes, crypto) => {
       crypto.validatePublicKey(this._publicKey)
     }
 
-    sign (message, callback) {
-      ensure(callback)
-      crypto.hashAndSign(this._key, message, callback)
+    async sign (message) {
+      return crypto.hashAndSign(this._key, message)
     }
 
     get public () {
@@ -69,43 +71,27 @@ module.exports = (keysProtobuf, randomBytes, crypto) => {
       return this.bytes.equals(key.bytes)
     }
 
-    hash (callback) {
-      ensure(callback)
-      multihashing(this.bytes, 'sha2-256', callback)
+    async hash () {
+      return new Promise((resolve, reject) => {
+        multihashing(this.bytes, 'sha2-256', (err, res) => {
+          if (err) return reject(err)
+          resolve(res)
+        })
+      })
     }
   }
 
-  function unmarshalSecp256k1PrivateKey (bytes, callback) {
-    callback(null, new Secp256k1PrivateKey(bytes), null)
+  async function unmarshalSecp256k1PrivateKey (bytes) {
+    return new Secp256k1PrivateKey(bytes)
   }
 
   function unmarshalSecp256k1PublicKey (bytes) {
     return new Secp256k1PublicKey(bytes)
   }
 
-  function generateKeyPair (_bits, callback) {
-    if (callback === undefined && typeof _bits === 'function') {
-      callback = _bits
-    }
-
-    ensure(callback)
-
-    crypto.generateKey((err, privateKeyBytes) => {
-      if (err) { return callback(err) }
-
-      let privkey
-      try {
-        privkey = new Secp256k1PrivateKey(privateKeyBytes)
-      } catch (err) { return callback(err) }
-
-      callback(null, privkey)
-    })
-  }
-
-  function ensure (callback) {
-    if (typeof callback !== 'function') {
-      throw new Error('callback is required')
-    }
+  async function generateKeyPair () {
+    const privateKeyBytes = await crypto.generateKey()
+    return new Secp256k1PrivateKey(privateKeyBytes)
   }
 
   return {