chore: release version v0.12.4

* chore: revert async dep change

* chore: update async to 2.6.3

CHANGELOG.md

@@ -1,25 +1,15 @@
-<a name="0.13.1"></a>
-## [0.13.1](https://github.com/libp2p/js-peer-id/compare/v0.13.0...v0.13.1) (2019-07-11)
+<a name="0.12.4"></a>
+## [0.12.4](https://github.com/libp2p/js-peer-id/compare/v0.12.3...v0.12.4) (2019-07-23)
+
+
+
+<a name="0.12.3"></a>
+## [0.12.3](https://github.com/libp2p/js-peer-id/compare/v0.12.2...v0.12.3) (2019-07-11)
 
 
 ### Features
 
-* **peerid:** support creating from secp256k1; harmonize algo with Go ([#95](https://github.com/libp2p/js-peer-id/issues/95)) ([17440a3](https://github.com/libp2p/js-peer-id/commit/17440a3))
-
-
-
-<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
+* **peerid:** support creating from secp256k1; harmonize algo with Go ([fd07221](https://github.com/libp2p/js-peer-id/commit/fd07221))
 
 
 

README.md

@@ -28,7 +28,7 @@
 - [API](#api)
   - [Create](#create)
     - [`new PeerId(id[, privKey, pubKey])`](#new-peeridid-privkey-pubkey)
-    - [`create([opts])`](#createopts)
+    - [`create([opts], callback)`](#createopts-callback)
   - [Import](#import)
     - [`createFromHexString(str)`](#createfromhexstringstr)
     - [`createFromBytes(buf)`](#createfrombytesbuf)
@@ -57,10 +57,11 @@ The public key is a base64 encoded string of a protobuf containing an RSA DER bu
 ```JavaScript
 const PeerId = require('peer-id')
 
-const id = await PeerId.create({ bits: 1024, keyType: 'rsa' })
-console.log(JSON.stringify(id.toJSON(), null, 2))
+PeerId.create({ bits: 1024, keyType: 'rsa' }, (err, id) => {
+  if (err) { throw err }
+  console.log(JSON.stringify(id.toJSON(), null, 2))
+})
 ```
-
 ```bash
 {
   "id": "Qma9T5YraSnpRDZqRR4krcSJabThc8nwZuJV3LercPHufi",
@@ -123,13 +124,14 @@ const PeerId = require('peer-id')
 
 The key format is detailed in [libp2p-crypto](https://github.com/libp2p/js-libp2p-crypto).
 
-### `create([opts])`
+### `create([opts], callback)`
 
 Generates a new Peer ID, complete with public/private keypair.
 
 - `opts: Object`: Default: `{bits: 2048, keyType: 'rsa'}`
+- `callback: Function`
 
-Returns `Promise<PeerId>`.
+Calls back `callback` with `err, id`.
 
 ## Import
 
@@ -137,44 +139,32 @@ Returns `Promise<PeerId>`.
 
 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()`

package.json

@@ -1,6 +1,6 @@
 {
   "name": "peer-id",
-  "version": "0.13.1",
+  "version": "0.12.4",
   "description": "IPFS Peer Id implementation in Node.js",
   "leadMaintainer": "Pedro Teixeira <i@pgte.me>",
   "main": "src/index.js",
@@ -34,14 +34,15 @@
   },
   "homepage": "https://github.com/libp2p/js-peer-id",
   "devDependencies": {
-    "aegir": "^19.0.5",
-    "bundlesize": "~0.18.0",
+    "aegir": "^20.0.0",
+    "bundlesize": "~0.17.1",
     "chai": "^4.2.0",
     "dirty-chai": "^2.0.1"
   },
   "dependencies": {
+    "libp2p-crypto": "~0.16.1",
+    "async": "^2.6.3",
     "class-is": "^1.1.0",
-    "libp2p-crypto": "~0.17.0",
     "multihashes": "~0.4.15"
   },
   "repository": {
@@ -53,7 +54,6 @@
     "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>",
     "Jacob Heun <jacobheun@gmail.com>",
     "Maciej Krüger <mkg20001@gmail.com>",

src/bin.js

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

src/index.js

@@ -7,6 +7,7 @@
 const mh = require('multihashes')
 const cryptoKeys = require('libp2p-crypto/src/keys')
 const assert = require('assert')
+const waterfall = require('async/waterfall')
 const withIs = require('class-is')
 
 class PeerId {
@@ -118,121 +119,185 @@ class PeerId {
   /*
    * Check if this PeerId instance is valid (privKey -> pubKey -> Id)
    */
-  isValid () {
-    // TODO: needs better checking
-    return Boolean(this.privKey &&
+  isValid (callback) {
+    // TODO Needs better checking
+    if (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
 
-const computeDigest = (pubKey) => {
+const computeDigest = (pubKey, cb) => {
   if (pubKey.bytes.length <= 42) {
-    return mh.encode(pubKey.bytes, 'identity')
+    const digest = mh.encode(pubKey.bytes, 'identity')
+    cb(null, digest)
   } else {
-    return pubKey.hash()
+    pubKey.hash((err, digest) => {
+      cb(err, digest)
+    })
   }
 }
 
-const computePeerId = async (privKey, pubKey) => {
-  const digest = await computeDigest(pubKey)
-  return new PeerIdWithIs(digest, privKey, pubKey)
+const computePeerId = (privKey, pubKey, cb) => {
+  computeDigest(pubKey, (err, digest) => {
+    if (err != null) {
+      cb(err)
+    } else {
+      cb(null, new PeerIdWithIs(digest, privKey, pubKey))
+    }
+  })
 }
 
 // generation
-exports.create = async (opts) => {
+exports.create = function (opts, callback) {
+  if (typeof opts === 'function') {
+    callback = opts
+    opts = {}
+  }
   opts = opts || {}
   opts.bits = opts.bits || 2048
   opts.keyType = opts.keyType || 'RSA'
 
-  const key = await cryptoKeys.generateKeyPair(opts.keyType, opts.bits)
-  return computePeerId(key, key.public)
+  cryptoKeys.generateKeyPair(opts.keyType, opts.bits, (err, privKey) => {
+    if (err != null) {
+      callback(err)
+    } else {
+      computePeerId(privKey, privKey.public, callback)
+    }
+  })
 }
 
-exports.createFromHexString = (str) => {
+exports.createFromHexString = function (str) {
   return new PeerIdWithIs(mh.fromHexString(str))
 }
 
-exports.createFromBytes = (buf) => {
+exports.createFromBytes = function (buf) {
   return new PeerIdWithIs(buf)
 }
 
-exports.createFromB58String = (str) => {
+exports.createFromB58String = function (str) {
   return new PeerIdWithIs(mh.fromB58String(str))
 }
 
 // Public Key input will be a buffer
-exports.createFromPubKey = async (key) => {
-  let buf = key
-
-  if (typeof buf === 'string') {
-    buf = Buffer.from(key, 'base64')
+exports.createFromPubKey = function (key, callback) {
+  if (typeof callback !== 'function') {
+    throw new Error('callback is required')
   }
 
-  if (!Buffer.isBuffer(buf)) {
-    throw new Error('Supplied key is neither a base64 string nor a buffer')
+  let pubKey
+
+  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 = cryptoKeys.unmarshalPublicKey(buf)
+  } catch (err) {
+    return callback(err)
   }
 
-  const pubKey = await cryptoKeys.unmarshalPublicKey(buf)
-  return computePeerId(null, pubKey)
+  computePeerId(null, pubKey, callback)
 }
 
 // Private key input will be a string
-exports.createFromPrivKey = async (key) => {
+exports.createFromPrivKey = function (key, callback) {
+  if (typeof callback !== 'function') {
+    throw new Error('callback is required')
+  }
+
   let buf = key
 
-  if (typeof buf === 'string') {
-    buf = Buffer.from(key, 'base64')
+  try {
+    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')
+  } catch (err) {
+    return callback(err)
   }
 
-  if (!Buffer.isBuffer(buf)) {
-    throw new Error('Supplied key is neither a base64 string nor a buffer')
-  }
-
-  const privKey = await cryptoKeys.unmarshalPrivateKey(buf)
-  return computePeerId(privKey, privKey.public)
+  cryptoKeys.unmarshalPrivateKey(buf, (err, privKey) => {
+    if (err != null) {
+      callback(err)
+    } else {
+      computePeerId(privKey, privKey.public, callback)
+    }
+  })
 }
 
-exports.createFromJSON = async (obj) => {
-  let id = mh.fromB58String(obj.id)
-  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)
+exports.createFromJSON = function (obj, callback) {
+  if (typeof callback !== 'function') {
+    throw new Error('callback is required')
+  }
+
+  let id
+  let rawPrivKey
+  let rawPubKey
+  let pub
+
+  try {
+    id = mh.fromB58String(obj.id)
+    rawPrivKey = obj.privKey && Buffer.from(obj.privKey, 'base64')
+    rawPubKey = obj.pubKey && Buffer.from(obj.pubKey, 'base64')
+    pub = rawPubKey && cryptoKeys.unmarshalPublicKey(rawPubKey)
+  } catch (err) {
+    return callback(err)
+  }
 
   if (!rawPrivKey) {
-    return new PeerIdWithIs(id, null, pub)
+    callback(null, new PeerIdWithIs(id, null, pub))
+    return
   }
 
-  const privKey = await cryptoKeys.unmarshalPrivateKey(rawPrivKey)
-  const privDigest = await computeDigest(privKey.public)
+  waterfall([
+    (cb) => cryptoKeys.unmarshalPrivateKey(rawPrivKey, cb),
+    (priv, cb) => {
+      computeDigest(priv.public, (err, digest) => {
+        cb(err, digest, priv)
+      })
+    },
+    (privDigest, priv, cb) => {
+      if (pub) {
+        computeDigest(pub, (err, pubDigest) => {
+          cb(err, privDigest, priv, pubDigest)
+        })
+      } else {
+        cb(null, privDigest, priv)
+      }
+    }
+  ], (err, privDigest, priv, pubDigest) => {
+    if (err) {
+      return callback(err)
+    }
 
-  let pubDigest
+    if (pub && !privDigest.equals(pubDigest)) {
+      return callback(new Error('Public and private key do not match'))
+    }
 
-  if (pub) {
-    pubDigest = await computeDigest(pub)
-  }
+    if (id && !privDigest.equals(id)) {
+      return callback(new Error('Id and private key do not match'))
+    }
 
-  if (pub && !privDigest.equals(pubDigest)) {
-    throw new Error('Public and private key do not match')
-  }
-
-  if (id && !privDigest.equals(id)) {
-    throw new Error('Id and private key do not match')
-  }
-
-  return new PeerIdWithIs(id, privKey, pub)
+    callback(null, new PeerIdWithIs(id, priv, pub))
+  })
 }
 
-exports.isPeerId = (peerId) => {
+exports.isPeerId = function (peerId) {
   return Boolean(typeof peerId === 'object' &&
     peerId._id &&
     peerId._idB58String)

test/peer-id.spec.js

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