chore: release version v0.13.0

BREAKING CHANGE: API refactored to use async/await

.npmignore

@@ -1,28 +0,0 @@
-# Logs
-logs
-*.log
-
-# Runtime data
-pids
-*.pid
-*.seed
-
-# Directory for instrumented libs generated by jscoverage/JSCover
-lib-cov
-
-# Coverage directory used by tools like istanbul
-coverage
-
-# Grunt intermediate storage (http://gruntjs.com/creating-plugins#storing-task-files)
-.grunt
-
-# Compiled binary addons (http://nodejs.org/api/addons.html)
-build/Release
-
-# Optional npm cache directory
-.npm
-
-# Optional REPL history
-.node_repl_history
-
-test

.travis.yml

@@ -1,32 +1,46 @@
-# Warning: This file is automatically synced from https://github.com/ipfs/ci-sync so if you want to change it, please change it there and ask someone to sync all repositories.
-sudo: false
 language: node_js
+cache: npm
+stages:
+  - check
+  - test
+  - cov
 
-matrix:
+node_js:
+  - '10'
+
+os:
+  - linux
+  - osx
+
+script: npx nyc -s npm run test:node -- --bail
+after_success: npx nyc report --reporter=text-lcov > coverage.lcov && npx codecov
+
+jobs:
   include:
-  - node_js: 6
+    - os: windows
-    env: CXX=g++-4.8
+      cache: false
-  - node_js: 8
-    env: CXX=g++-4.8
-    #  - node_js: stable
-    #    env: CXX=g++-4.8
 
-script:
+    - stage: check
-  - npm run lint
+      script:
-  - npm run test
+        - npx aegir commitlint --travis
-  - npm run coverage
+        - npx aegir dep-check
+        - npm run lint
 
-before_script:
+    - stage: test
-  - export DISPLAY=:99.0
+      name: chrome
-  - sh -e /etc/init.d/xvfb start
+      addons:
+        chrome: stable
+      script:
+        - npx aegir test -t browser
+        - npx aegir test -t webworker
 
-after_success:
+    - stage: test
-  - npm run coverage-publish
+      name: firefox
+      addons:
+        firefox: latest
+      script:
+        - npx aegir test -t browser -- --browsers FirefoxHeadless
+        - npx aegir test -t webworker -- --browsers FirefoxHeadless
 
-addons:
+notifications:
-  firefox: 'latest'
+  email: false
-  apt:
-    sources:
-      - ubuntu-toolchain-r-test
-    packages:
-      - g++-4.8

CHANGELOG.md

@@ -1,3 +1,33 @@
+<a name="0.13.0"></a>
+# [0.13.0](https://github.com/libp2p/js-peer-id/compare/v0.12.2...v0.13.0) (2019-07-11)
+
+
+### Features
+
+* async await ([#87](https://github.com/libp2p/js-peer-id/issues/87)) ([c3463c7](https://github.com/libp2p/js-peer-id/commit/c3463c7))
+
+
+### BREAKING CHANGES
+
+* API refactored to use async/await
+
+
+
+<a name="0.12.2"></a>
+## [0.12.2](https://github.com/libp2p/js-peer-id/compare/v0.12.1...v0.12.2) (2019-01-09)
+
+
+### Bug Fixes
+
+* clean repo and bundle size reduction ([cd20993](https://github.com/libp2p/js-peer-id/commit/cd20993))
+
+
+
+<a name="0.12.1"></a>
+## [0.12.1](https://github.com/libp2p/js-peer-id/compare/v0.12.0...v0.12.1) (2019-01-03)
+
+
+
 <a name="0.12.0"></a>
 # [0.12.0](https://github.com/libp2p/js-peer-id/compare/v0.11.0...v0.12.0) (2018-10-18)
 

README.md

@@ -1,13 +1,13 @@
 # peer-id
 
-[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://ipn.io)
+[![](https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square)](http://protocol.ai)
-[![](https://img.shields.io/badge/freenode-%23ipfs-blue.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23ipfs)
+[![](https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square)](http://libp2p.io/)
-[![Build Status](https://travis-ci.org/libp2p/js-peer-id.svg?style=flat-square)](https://travis-ci.org/libp2p/js-peer-id)
+[![](https://img.shields.io/badge/freenode-%23libp2p-yellow.svg?style=flat-square)](http://webchat.freenode.net/?channels=%23libp2p)
-[![Coverage Status](https://coveralls.io/repos/github/libp2p/js-peer-id/badge.svg?branch=master)](https://coveralls.io/github/libp2p/js-peer-id?branch=master)
+[![Discourse posts](https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg)](https://discuss.libp2p.io)
+[![](https://img.shields.io/codecov/c/github/libp2p/js-peer-id.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-peer-id)
+[![](https://img.shields.io/travis/libp2p/js-peer-id.svg?style=flat-square)](https://travis-ci.com/libp2p/js-peer-id)
 [![Dependency Status](https://david-dm.org/libp2p/js-peer-id.svg?style=flat-square)](https://david-dm.org/libp2p/js-peer-id)
 [![js-standard-style](https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square)](https://github.com/feross/standard)
-![](https://img.shields.io/badge/npm-%3E%3D3.0.0-orange.svg?style=flat-square)
-![](https://img.shields.io/badge/Node.js-%3E%3D6.0.0-orange.svg?style=flat-square)
 
 > [IPFS](https://github.com/ipfs/ipfs) Peer ID implementation in JavaScript.
 
@@ -28,7 +28,7 @@
 - [API](#api)
   - [Create](#create)
     - [`new PeerId(id[, privKey, pubKey])`](#new-peeridid-privkey-pubkey)
-    - [`create([opts], callback)`](#createopts-callback)
+    - [`create([opts])`](#createopts)
   - [Import](#import)
     - [`createFromHexString(str)`](#createfromhexstringstr)
     - [`createFromBytes(buf)`](#createfrombytesbuf)
@@ -57,11 +57,10 @@ The public key is a base64 encoded string of a protobuf containing an RSA DER bu
 ```JavaScript
 const PeerId = require('peer-id')
 
-PeerId.create({ bits: 1024 }, (err, id) => {
+const id = await PeerId.create({ bits: 1024 })
-  if (err) { throw err }
+console.log(JSON.stringify(id.toJSON(), null, 2))
-  console.log(JSON.stringify(id.toJSON(), null, 2))
-})
 ```
+
 ```bash
 {
   "id": "Qma9T5YraSnpRDZqRR4krcSJabThc8nwZuJV3LercPHufi",
@@ -124,14 +123,13 @@ const PeerId = require('peer-id')
 
 The key format is detailed in [libp2p-crypto](https://github.com/libp2p/js-libp2p-crypto).
 
-### `create([opts], callback)`
+### `create([opts])`
 
 Generates a new Peer ID, complete with public/private keypair.
 
 - `opts: Object`: Default: `{bits: 2048}`
-- `callback: Function`
 
-Calls back `callback` with `err, id`.
+Returns `Promise<PeerId>`.
 
 ## Import
 
@@ -139,32 +137,44 @@ Calls back `callback` with `err, id`.
 
 Creates a Peer ID from hex string representing the key's multihash.
 
+Returns `PeerId.
+
 ### `createFromBytes(buf)`
 
 Creates a Peer ID from a buffer representing the key's multihash.
 
+Returns `PeerId`.
+
 ### `createFromB58String(str)`
 
 Creates a Peer ID from a Base58 string representing the key's multihash.
 
+Returns `PeerId`.
+
 ### `createFromPubKey(pubKey)`
 
 - `publicKey: Buffer`
 
 Creates a Peer ID from a buffer containing a public key.
 
+Returns `Promise<PeerId>`.
+
 ### `createFromPrivKey(privKey)`
 
 - `privKey: Buffer`
 
 Creates a Peer ID from a buffer containing a private key.
 
+Returns `Promise<PeerId>`.
+
 ### `createFromJSON(obj)`
 
 - `obj.id: String` - The multihash encoded in `base58`
 - `obj.pubKey: String` - The public key in protobuf format, encoded in `base64`
 - `obj.privKey: String` - The private key in protobuf format, encoded in `base64`
 
+Returns `Promise<PeerId>`.
+
 ## Export
 
 ### `toHexString()`

appveyor.yml

@@ -1,29 +0,0 @@
-# Warning: This file is automatically synced from https://github.com/ipfs/ci-sync so if you want to change it, please change it there and ask someone to sync all repositories.
-version: "{build}"
-
-environment:
-  matrix:
-    - nodejs_version: "6"
-    - nodejs_version: "8"
-
-matrix:
-  fast_finish: true
-
-install:
-  # Install Node.js
-  - ps: Install-Product node $env:nodejs_version
-
-  # Upgrade npm
-  - npm install -g npm
-
-  # Output our current versions for debugging
-  - node --version
-  - npm --version
-
-  # Install our package dependencies
-  - npm install
-
-test_script:
-  - npm run test:node
-
-build: off

ci/Jenkinsfile

@@ -1,2 +0,0 @@
-// Warning: This file is automatically synced from https://github.com/ipfs/ci-sync so if you want to change it, please change it there and ask someone to sync all repositories.
-javascript()

circle.yml

@@ -1,15 +0,0 @@
-# Warning: This file is automatically synced from https://github.com/ipfs/ci-sync so if you want to change it, please change it there and ask someone to sync all repositories.
-machine:
-  node:
-    version: stable
-
-dependencies:
-  pre:
-    - google-chrome --version
-    - curl -L -o google-chrome.deb https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
-    - sudo dpkg -i google-chrome.deb || true
-    - sudo apt-get update
-    - sudo apt-get install -f
-    - sudo apt-get install --only-upgrade lsb-base
-    - sudo dpkg -i google-chrome.deb
-    - google-chrome --version

package.json

@@ -1,6 +1,6 @@
 {
   "name": "peer-id",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "IPFS Peer Id implementation in Node.js",
   "leadMaintainer": "Pedro Teixeira <i@pgte.me>",
   "main": "src/index.js",
@@ -14,35 +14,35 @@
     "release": "aegir release",
     "release-minor": "aegir release --type minor",
     "release-major": "aegir release --type major",
-    "coverage": "aegir coverage"
+    "coverage": "aegir coverage",
+    "size": "bundlesize -f dist/index.min.js -s 140kB"
   },
+  "files": [
+    "src",
+    "dist"
+  ],
   "keywords": [
     "IPFS"
   ],
   "license": "MIT",
-  "pre-push": [
-    "lint",
-    "test"
-  ],
   "engines": {
-    "node": ">=6.0.0",
+    "node": ">=10.0.0",
-    "npm": ">=3.0.0"
+    "npm": ">=6.0.0"
   },
   "bugs": {
     "url": "https://github.com/libp2p/js-peer-id/issues"
   },
   "homepage": "https://github.com/libp2p/js-peer-id",
   "devDependencies": {
-    "aegir": "^14.0.0",
+    "aegir": "^19.0.5",
-    "chai": "^4.1.2",
+    "bundlesize": "~0.18.0",
+    "chai": "^4.2.0",
     "dirty-chai": "^2.0.1"
   },
   "dependencies": {
-    "async": "^2.6.1",
     "class-is": "^1.1.0",
-    "libp2p-crypto": "~0.13.0",
+    "libp2p-crypto": "~0.17.0",
-    "lodash": "^4.17.10",
+    "multihashes": "~0.4.14"
-    "multihashes": "~0.4.13"
   },
   "repository": {
     "type": "git",
@@ -52,6 +52,8 @@
     "David Dias <daviddias.p@gmail.com>",
     "David Dias <mail@daviddias.me>",
     "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
+    "Henrique Dias <hacdias@gmail.com>",
+    "Hugo Dias <hugomrdias@gmail.com>",
     "Maciej Krüger <mkg20001@gmail.com>",
     "Michael Garvin <gar+gh@danger.computer>",
     "Pedro Teixeira <i@pgte.me>",
@@ -59,6 +61,7 @@
     "Richard Littauer <richard.littauer@gmail.com>",
     "Richard Schneider <makaretu@gmail.com>",
     "Stephen Whitmore <stephen.whitmore@gmail.com>",
+    "Vasco Santos <vasco.santos@ua.pt>",
     "Vasco Santos <vasco.santos@moxy.studio>",
     "Yahya <ya7yaz@gmail.com>",
     "greenkeeperio-bot <support@greenkeeper.io>",

src/bin.js

@@ -4,10 +4,9 @@
 
 const PeerId = require('./index.js')
 
-PeerId.create((err, id) => {
+async function main () {
-  if (err) {
+  const id = await PeerId.create()
-    throw err
+  console.log(JSON.stringify(id.toJSON(), null, 2)) // eslint-disable-line no-console
-  }
+}
 
-  console.log(JSON.stringify(id.toJSON(), null, 2))
+main()
-})

src/index.js

@@ -5,9 +5,8 @@
 'use strict'
 
 const mh = require('multihashes')
-const crypto = require('libp2p-crypto')
+const cryptoKeys = require('libp2p-crypto/src/keys')
 const assert = require('assert')
-const waterfall = require('async/waterfall')
 const withIs = require('class-is')
 
 class PeerId {
@@ -57,14 +56,14 @@ class PeerId {
   // Return the protobuf version of the public key, matching go ipfs formatting
   marshalPubKey () {
     if (this.pubKey) {
-      return crypto.keys.marshalPublicKey(this.pubKey)
+      return cryptoKeys.marshalPublicKey(this.pubKey)
     }
   }
 
   // Return the protobuf version of the private key, matching go ipfs formatting
   marshalPrivKey () {
     if (this.privKey) {
-      return crypto.keys.marshalPrivateKey(this.privKey)
+      return cryptoKeys.marshalPrivateKey(this.privKey)
     }
   }
 
@@ -119,176 +118,111 @@ class PeerId {
   /*
    * Check if this PeerId instance is valid (privKey -> pubKey -> Id)
    */
-  isValid (callback) {
+  isValid () {
-    // TODO Needs better checking
+    // TODO: needs better checking
-    if (this.privKey &&
+    return Boolean(this.privKey &&
       this.privKey.public &&
       this.privKey.public.bytes &&
       Buffer.isBuffer(this.pubKey.bytes) &&
-      this.privKey.public.bytes.equals(this.pubKey.bytes)) {
+      this.privKey.public.bytes.equals(this.pubKey.bytes))
-      callback()
-    } else {
-      callback(new Error('Keys not match'))
-    }
   }
 }
 
-const PeerIdWithIs = withIs(PeerId, { className: 'PeerId', symbolName: '@libp2p/js-peer-id/PeerId' })
+const PeerIdWithIs = withIs(PeerId, {
+  className: 'PeerId',
+  symbolName: '@libp2p/js-peer-id/PeerId'
+})
 
 exports = module.exports = PeerIdWithIs
 
 // generation
-exports.create = function (opts, callback) {
+exports.create = async (opts) => {
-  if (typeof opts === 'function') {
-    callback = opts
-    opts = {}
-  }
   opts = opts || {}
   opts.bits = opts.bits || 2048
 
-  waterfall([
+  const key = await cryptoKeys.generateKeyPair('RSA', opts.bits)
-    (cb) => crypto.keys.generateKeyPair('RSA', opts.bits, cb),
+  const digest = await key.public.hash()
-    (privKey, cb) => privKey.public.hash((err, digest) => {
-      cb(err, digest, privKey)
-    })
-  ], (err, digest, privKey) => {
-    if (err) {
-      return callback(err)
-    }
 
-    callback(null, new PeerIdWithIs(digest, privKey))
+  return new PeerIdWithIs(digest, key)
-  })
 }
 
-exports.createFromHexString = function (str) {
+exports.createFromHexString = (str) => {
   return new PeerIdWithIs(mh.fromHexString(str))
 }
 
-exports.createFromBytes = function (buf) {
+exports.createFromBytes = (buf) => {
   return new PeerIdWithIs(buf)
 }
 
-exports.createFromB58String = function (str) {
+exports.createFromB58String = (str) => {
   return new PeerIdWithIs(mh.fromB58String(str))
 }
 
 // Public Key input will be a buffer
-exports.createFromPubKey = function (key, callback) {
+exports.createFromPubKey = async (key) => {
-  if (typeof callback !== 'function') {
+  let buf = key
-    throw new Error('callback is required')
+
+  if (typeof buf === 'string') {
+    buf = Buffer.from(key, 'base64')
   }
 
-  let pubKey
+  if (!Buffer.isBuffer(buf)) {
-
+    throw new Error('Supplied key is neither a base64 string nor a buffer')
-  try {
-    let buf = key
-    if (typeof buf === 'string') {
-      buf = Buffer.from(key, 'base64')
-    }
-
-    if (!Buffer.isBuffer(buf)) throw new Error('Supplied key is neither a base64 string nor a buffer')
-
-    pubKey = crypto.keys.unmarshalPublicKey(buf)
-  } catch (err) {
-    return callback(err)
   }
 
-  pubKey.hash((err, digest) => {
+  const pubKey = await cryptoKeys.unmarshalPublicKey(buf)
-    if (err) {
+  const digest = await pubKey.hash()
-      return callback(err)
+  return new PeerIdWithIs(digest, null, pubKey)
-    }
-
-    callback(null, new PeerIdWithIs(digest, null, pubKey))
-  })
 }
 
 // Private key input will be a string
-exports.createFromPrivKey = function (key, callback) {
+exports.createFromPrivKey = async (key) => {
-  if (typeof callback !== 'function') {
-    throw new Error('callback is required')
-  }
-
   let buf = key
 
-  try {
+  if (typeof buf === 'string') {
-    if (typeof buf === 'string') {
+    buf = Buffer.from(key, 'base64')
-      buf = Buffer.from(key, 'base64')
-    }
-
-    if (!Buffer.isBuffer(buf)) throw new Error('Supplied key is neither a base64 string nor a buffer')
-  } catch (err) {
-    return callback(err)
   }
 
-  waterfall([
+  if (!Buffer.isBuffer(buf)) {
-    (cb) => crypto.keys.unmarshalPrivateKey(buf, cb),
+    throw new Error('Supplied key is neither a base64 string nor a buffer')
-    (privKey, cb) => privKey.public.hash((err, digest) => {
+  }
-      cb(err, digest, privKey)
-    })
-  ], (err, digest, privKey) => {
-    if (err) {
-      return callback(err)
-    }
 
-    callback(null, new PeerIdWithIs(digest, privKey, privKey.public))
+  const privKey = await cryptoKeys.unmarshalPrivateKey(buf)
-  })
+  const digest = await privKey.public.hash()
+
+  return new PeerIdWithIs(digest, privKey, privKey.public)
 }
 
-exports.createFromJSON = function (obj, callback) {
+exports.createFromJSON = async (obj) => {
-  if (typeof callback !== 'function') {
+  let id = mh.fromB58String(obj.id)
-    throw new Error('callback is required')
+  let rawPrivKey = obj.privKey && Buffer.from(obj.privKey, 'base64')
+  let rawPubKey = obj.pubKey && Buffer.from(obj.pubKey, 'base64')
+  let pub = rawPubKey && await cryptoKeys.unmarshalPublicKey(rawPubKey)
+
+  if (!rawPrivKey) {
+    return new PeerIdWithIs(id, null, pub)
   }
 
-  let id
+  const privKey = await cryptoKeys.unmarshalPrivateKey(rawPrivKey)
-  let rawPrivKey
+  const privDigest = await privKey.public.hash()
-  let rawPubKey
+  let pubDigest
-  let pub
 
-  try {
+  if (pub) {
-    id = mh.fromB58String(obj.id)
+    pubDigest = await pub.hash()
-    rawPrivKey = obj.privKey && Buffer.from(obj.privKey, 'base64')
-    rawPubKey = obj.pubKey && Buffer.from(obj.pubKey, 'base64')
-    pub = rawPubKey && crypto.keys.unmarshalPublicKey(rawPubKey)
-  } catch (err) {
-    return callback(err)
   }
 
-  if (rawPrivKey) {
+  if (pub && !privDigest.equals(pubDigest)) {
-    waterfall([
+    throw new Error('Public and private key do not match')
-      (cb) => crypto.keys.unmarshalPrivateKey(rawPrivKey, cb),
-      (priv, cb) => priv.public.hash((err, digest) => {
-        cb(err, digest, priv)
-      }),
-      (privDigest, priv, cb) => {
-        if (pub) {
-          pub.hash((err, pubDigest) => {
-            cb(err, privDigest, priv, pubDigest)
-          })
-        } else {
-          cb(null, privDigest, priv)
-        }
-      }
-    ], (err, privDigest, priv, pubDigest) => {
-      if (err) {
-        return callback(err)
-      }
-
-      if (pub && !privDigest.equals(pubDigest)) {
-        return callback(new Error('Public and private key do not match'))
-      }
-
-      if (id && !privDigest.equals(id)) {
-        return callback(new Error('Id and private key do not match'))
-      }
-
-      callback(null, new PeerIdWithIs(id, priv, pub))
-    })
-  } else {
-    callback(null, new PeerIdWithIs(id, null, pub))
   }
+
+  if (id && !privDigest.equals(id)) {
+    throw new Error('Id and private key do not match')
+  }
+
+  return new PeerIdWithIs(id, privKey, pub)
 }
 
-exports.isPeerId = function (peerId) {
+exports.isPeerId = (peerId) => {
   return Boolean(typeof peerId === 'object' &&
     peerId._id &&
     peerId._idB58String)

test/peer-id.spec.js

@@ -8,7 +8,6 @@ chai.use(dirtyChai)
 const expect = chai.expect
 const crypto = require('libp2p-crypto')
 const mh = require('multihashes')
-const parallel = require('async/parallel')
 
 const PeerId = require('../src')
 
@@ -32,34 +31,24 @@ describe('PeerId', () => {
     expect(PeerId).to.throw(Error)
   })
 
-  it('create a new id', (done) => {
+  it('create a new id', async () => {
-    PeerId.create(testOpts, (err, id) => {
+    const id = await PeerId.create(testOpts)
-      expect(err).to.not.exist()
+    expect(id.toB58String().length).to.equal(46)
-      expect(id.toB58String().length).to.equal(46)
-      done()
-    })
   })
 
-  it('isPeerId', (done) => {
+  it('isPeerId', async () => {
-    PeerId.create(testOpts, (err, id) => {
+    const id = await PeerId.create(testOpts)
-      expect(err).to.not.exist()
+    expect(PeerId.isPeerId(id)).to.equal(true)
-      expect(PeerId.isPeerId(id)).to.equal(true)
+    expect(PeerId.isPeerId('aaa')).to.equal(false)
-      expect(PeerId.isPeerId('aaa')).to.equal(false)
+    expect(PeerId.isPeerId(Buffer.from('batatas'))).to.equal(false)
-      expect(PeerId.isPeerId(Buffer.from('batatas'))).to.equal(false)
-      done()
-    })
   })
 
-  it('throws on changing the id', function (done) {
+  it('throws on changing the id', async () => {
-    this.timeout(10000)
+    const id = await PeerId.create(testOpts)
-    PeerId.create(testOpts, (err, id) => {
+    expect(id.toB58String().length).to.equal(46)
-      expect(err).to.not.exist()
+    expect(() => {
-      expect(id.toB58String().length).to.equal(46)
+      id.id = Buffer.from('hello')
-      expect(() => {
+    }).to.throw(/immutable/)
-        id.id = Buffer.from('hello')
-      }).to.throw(/immutable/)
-      done()
-    })
   })
 
   it('recreate an Id from Hex string', () => {
@@ -77,72 +66,44 @@ describe('PeerId', () => {
     expect(testIdB58String).to.equal(id.toB58String())
   })
 
-  it('Recreate from a Public Key', (done) => {
+  it('Recreate from a Public Key', async () => {
-    PeerId.createFromPubKey(testId.pubKey, (err, id) => {
+    const id = await PeerId.createFromPubKey(testId.pubKey)
-      expect(err).to.not.exist()
+    expect(testIdB58String).to.equal(id.toB58String())
-      expect(testIdB58String).to.equal(id.toB58String())
-      done()
-    })
   })
 
-  it('Recreate from a Private Key', (done) => {
+  it('Recreate from a Private Key', async () => {
-    PeerId.createFromPrivKey(testId.privKey, (err, id) => {
+    const id = await PeerId.createFromPrivKey(testId.privKey)
-      expect(err).to.not.exist()
+    expect(testIdB58String).to.equal(id.toB58String())
-      expect(testIdB58String).to.equal(id.toB58String())
+    const encoded = Buffer.from(testId.privKey, 'base64')
-
+    const id2 = await PeerId.createFromPrivKey(encoded)
-      const encoded = Buffer.from(testId.privKey, 'base64')
+    expect(testIdB58String).to.equal(id2.toB58String())
-      PeerId.createFromPrivKey(encoded, (err, id2) => {
+    expect(id.marshalPubKey()).to.deep.equal(id2.marshalPubKey())
-        expect(err).to.not.exist()
-        expect(testIdB58String).to.equal(id2.toB58String())
-        expect(id.marshalPubKey()).to.deep.equal(id2.marshalPubKey())
-        done()
-      })
-    })
   })
 
-  it('Compare generated ID with one created from PubKey', (done) => {
+  it('Compare generated ID with one created from PubKey', async () => {
-    PeerId.create(testOpts, (err, id1) => {
+    const id1 = await PeerId.create(testOpts)
-      expect(err).to.not.exist()
+    const id2 = await PeerId.createFromPubKey(id1.marshalPubKey())
-
+    expect(id1.id).to.be.eql(id2.id)
-      PeerId.createFromPubKey(id1.marshalPubKey(), (err, id2) => {
-        expect(err).to.not.exist()
-        expect(id1.id).to.be.eql(id2.id)
-        done()
-      })
-    })
   })
 
-  it('Works with default options', function (done) {
+  it('Works with default options', async function () {
     this.timeout(10000)
-    PeerId.create((err, id) => {
+    const id = await PeerId.create()
-      expect(err).to.not.exist()
+    expect(id.toB58String().length).to.equal(46)
-      expect(id.toB58String().length).to.equal(46)
-      done()
-    })
   })
 
-  it('Non-default # of bits', function (done) {
+  it('Non-default # of bits', async function () {
     this.timeout(1000 * 60)
-    PeerId.create(testOpts, (err, shortId) => {
+    const shortId = await PeerId.create(testOpts)
-      expect(err).to.not.exist()
+    const longId = await PeerId.create({ bits: 1024 })
-      PeerId.create({ bits: 1024 }, (err, longId) => {
+    expect(shortId.privKey.bytes.length).is.below(longId.privKey.bytes.length)
-        expect(err).to.not.exist()
-        expect(shortId.privKey.bytes.length).is.below(longId.privKey.bytes.length)
-        done()
-      })
-    })
   })
 
-  it('Pretty printing', (done) => {
+  it('Pretty printing', async () => {
-    PeerId.create(testOpts, (err, id1) => {
+    const id1 = await PeerId.create(testOpts)
-      expect(err).to.not.exist()
+    const id2 = await PeerId.createFromPrivKey((id1.toJSON()).privKey)
-      PeerId.createFromPrivKey(id1.toJSON().privKey, (err, id2) => {
+    expect(id1.toPrint()).to.be.eql(id2.toPrint())
-        expect(err).to.not.exist()
+    expect(id1.toPrint()).to.equal('<peer.ID ' + id1.toB58String().substr(2, 6) + '>')
-        expect(id1.toPrint()).to.be.eql(id2.toPrint())
-        expect(id1.toPrint()).to.equal('<peer.ID ' + id1.toB58String().substr(2, 6) + '>')
-        done()
-      })
-    })
   })
 
   it('toBytes', () => {
@@ -150,120 +111,88 @@ describe('PeerId', () => {
     expect(id.toBytes().toString('hex')).to.equal(testIdBytes.toString('hex'))
   })
 
-  it('isEqual', (done) => {
+  it('isEqual', async () => {
-    parallel([
+    const ids = await Promise.all([
-      (cb) => PeerId.create(testOpts, cb),
+      PeerId.create(testOpts),
-      (cb) => PeerId.create(testOpts, cb)
+      PeerId.create(testOpts)
-    ], (err, ids) => {
+    ])
-      expect(err).to.not.exist()
+
-      expect(ids[0].isEqual(ids[0])).to.equal(true)
+    expect(ids[0].isEqual(ids[0])).to.equal(true)
-      expect(ids[0].isEqual(ids[1])).to.equal(false)
+    expect(ids[0].isEqual(ids[1])).to.equal(false)
-      expect(ids[0].isEqual(ids[0].id)).to.equal(true)
+    expect(ids[0].isEqual(ids[0].id)).to.equal(true)
-      expect(ids[0].isEqual(ids[1].id)).to.equal(false)
+    expect(ids[0].isEqual(ids[1].id)).to.equal(false)
-      done()
-    })
   })
 
   describe('fromJSON', () => {
-    it('full node', (done) => {
+    it('full node', async () => {
-      PeerId.create(testOpts, (err, id) => {
+      const id = await PeerId.create(testOpts)
-        expect(err).to.not.exist()
+      const other = await PeerId.createFromJSON(id.toJSON())
-
+      expect(id.toB58String()).to.equal(other.toB58String())
-        PeerId.createFromJSON(id.toJSON(), (err, other) => {
+      expect(id.privKey.bytes).to.eql(other.privKey.bytes)
-          expect(err).to.not.exist()
+      expect(id.pubKey.bytes).to.eql(other.pubKey.bytes)
-          expect(id.toB58String()).to.equal(other.toB58String())
-          expect(id.privKey.bytes).to.eql(other.privKey.bytes)
-          expect(id.pubKey.bytes).to.eql(other.pubKey.bytes)
-          done()
-        })
-      })
     })
 
-    it('only id', (done) => {
+    it('only id', async () => {
-      crypto.keys.generateKeyPair('RSA', 1024, (err, key) => {
+      const key = await crypto.keys.generateKeyPair('RSA', 1024)
-        expect(err).to.not.exist()
+      const digest = await key.public.hash()
-        key.public.hash((err, digest) => {
+      const id = PeerId.createFromBytes(digest)
-          expect(err).to.not.exist()
+      expect(id.privKey).to.not.exist()
-
+      expect(id.pubKey).to.not.exist()
-          const id = PeerId.createFromBytes(digest)
+      const other = await PeerId.createFromJSON(id.toJSON())
-          expect(id.privKey).to.not.exist()
+      expect(id.toB58String()).to.equal(other.toB58String())
-          expect(id.pubKey).to.not.exist()
-
-          PeerId.createFromJSON(id.toJSON(), (err, other) => {
-            expect(err).to.not.exist()
-            expect(id.toB58String()).to.equal(other.toB58String())
-            done()
-          })
-        })
-      })
     })
 
-    it('go interop', (done) => {
+    it('go interop', async () => {
-      PeerId.createFromJSON(goId, (err, id) => {
+      const id = await PeerId.createFromJSON(goId)
-        expect(err).to.not.exist()
+      const digest = await id.privKey.public.hash()
-        id.privKey.public.hash((err, digest) => {
+      expect(mh.toB58String(digest)).to.eql(goId.id)
-          expect(err).to.not.exist()
-          expect(mh.toB58String(digest)).to.eql(goId.id)
-          done()
-        })
-      })
     })
   })
 
-  it('set privKey (valid)', (done) => {
+  it('set privKey (valid)', async () => {
-    PeerId.create(testOpts, (err, peerId) => {
+    const peerId = await PeerId.create(testOpts)
-      expect(err).to.not.exist()
+    peerId.privKey = peerId._privKey
-      peerId.privKey = peerId._privKey
+    expect(peerId.isValid()).to.equal(true)
-      peerId.isValid(done)
-    })
   })
 
-  it('set pubKey (valid)', (done) => {
+  it('set pubKey (valid)', async () => {
-    PeerId.create(testOpts, (err, peerId) => {
+    const peerId = await PeerId.create(testOpts)
-      expect(err).to.not.exist()
+    peerId.pubKey = peerId._pubKey
-      peerId.pubKey = peerId._pubKey
+    expect(peerId.isValid()).to.equal(true)
-      peerId.isValid(done)
-    })
   })
 
-  it('set privKey (invalid)', (done) => {
+  it('set privKey (invalid)', async () => {
-    PeerId.create(testOpts, (err, peerId) => {
+    const peerId = await PeerId.create(testOpts)
-      expect(err).to.not.exist()
+    peerId.privKey = Buffer.from('bufff')
-      peerId.privKey = Buffer.from('bufff')
+    expect(peerId.isValid()).to.equal(false)
-      peerId.isValid((err) => {
-        expect(err).to.exist()
-        done()
-      })
-    })
   })
 
-  it('set pubKey (invalid)', (done) => {
+  it('set pubKey (invalid)', async () => {
-    PeerId.create(testOpts, (err, peerId) => {
+    const peerId = await PeerId.create(testOpts)
-      expect(err).to.not.exist()
+    peerId.pubKey = Buffer.from('bufff')
-      peerId.pubKey = Buffer.from('buffff')
+    expect(peerId.isValid()).to.equal(false)
-      peerId.isValid((err) => {
-        expect(err).to.exist()
-        done()
-      })
-    })
   })
 
   describe('returns error via cb instead of crashing', () => {
-    const garbage = [Buffer.from('00010203040506070809', 'hex'), {}, null, false, undefined, true, 1, 0, Buffer.from(''), 'aGVsbG93b3JsZA==', 'helloworld', '']
+    const garbage = [
+      Buffer.from('00010203040506070809', 'hex'),
+      {}, null, false, undefined, true, 1, 0,
+      Buffer.from(''), 'aGVsbG93b3JsZA==', 'helloworld', ''
+    ]
 
     const fncs = ['createFromPubKey', 'createFromPrivKey', 'createFromJSON']
 
-    garbage.forEach(garbage => {
+    for (const gb of garbage) {
-      fncs.forEach(fnc => {
+      for (const fn of fncs) {
-        it(fnc + '(' + util.inspect(garbage) + ')', cb => {
+        it(`${fn} (${util.inspect(gb)})`, async () => {
-          PeerId[fnc](garbage, (err, res) => {
+          try {
+            await PeerId[fn](gb)
+          } catch (err) {
             expect(err).to.exist()
-            expect(res).to.not.exist()
+          }
-            cb()
-          })
         })
-      })
+      }
-    })
+    }
   })
 
   describe('throws on inconsistent data', () => {
@@ -271,37 +200,30 @@ describe('PeerId', () => {
     let k2
     let k3
 
-    before((done) => {
+    before(async () => {
-      parallel([
+      const keys = await Promise.all([
-        (cb) => crypto.keys.generateKeyPair('RSA', 512, cb),
+        crypto.keys.generateKeyPair('RSA', 512),
-        (cb) => crypto.keys.generateKeyPair('RSA', 512, cb),
+        crypto.keys.generateKeyPair('RSA', 512),
-        (cb) => crypto.keys.generateKeyPair('RSA', 512, cb)
+        crypto.keys.generateKeyPair('RSA', 512)
-      ], (err, keys) => {
+      ])
-        expect(err).to.not.exist()
 
-        k1 = keys[0]
+      k1 = keys[0]
-        k2 = keys[1]
+      k2 = keys[1]
-        k3 = keys[2]
+      k3 = keys[2]
-        done()
-      })
     })
 
-    it('missmatch private - public key', (done) => {
+    it('missmatch private - public key', async () => {
-      k1.public.hash((err, digest) => {
+      const digest = await k1.public.hash()
-        expect(err).to.not.exist()
+      expect(() => {
-        expect(() => new PeerId(digest, k1, k2.public))
+        new PeerId(digest, k1, k2.public) // eslint-disable-line no-new
-          .to.throw(/inconsistent arguments/)
+      }).to.throw(/inconsistent arguments/)
-        done()
-      })
     })
 
-    it('missmatch id - private - public key', (done) => {
+    it('missmatch id - private - public key', async () => {
-      k1.public.hash((err, digest) => {
+      const digest = await k1.public.hash()
-        expect(err).to.not.exist()
+      expect(() => {
-        expect(() => new PeerId(digest, k1, k3.public))
+        new PeerId(digest, k1, k3.public) // eslint-disable-line no-new
-          .to.throw(/inconsistent arguments/)
+      }).to.throw(/inconsistent arguments/)
-        done()
-      })
     })
 
     it('invalid id', () => {