chore: release version v0.10.1

* chore: update deps

* chore: update gitignore

* chore: update CI

* chore: update README badge

.gitignore

@@ -1,7 +1,14 @@
+**/node_modules/
+**/*.log
+test/repo-tests*
+**/bundle.js
+
 # Logs
 logs
 *.log
 
+coverage
+
 # Runtime data
 pids
 *.pid
@@ -19,11 +26,19 @@ coverage
 # node-waf configuration
 .lock-wscript
 
-# Compiled binary addons (http://nodejs.org/api/addons.html)
+build
-build/Release
 
 # Dependency directory
 # https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
 node_modules
 
+docs
+lib
 dist
+test/test-data/go-ipfs-repo/LOCK
+test/test-data/go-ipfs-repo/LOG
+test/test-data/go-ipfs-repo/LOG.old
+
+# while testing npm5
+package-lock.json
+yarn.lock

.travis.yml

@@ -3,23 +3,17 @@ language: node_js
 
 matrix:
   include:
-  - node_js: 4
-    env: CXX=g++-4.8
   - node_js: 6
-    env:
-      - SAUCE=true
-      - CXX=g++-4.8
-  - node_js: stable
     env: CXX=g++-4.8
-
+  - node_js: 8
-# Make sure we have new NPM.
+    env: CXX=g++-4.8
-before_install:
+    #  - node_js: stable
-  - npm install -g npm
+    #    env: CXX=g++-4.8
 
 script:
   - npm run lint
-  - npm test
+  - npm run test
-  - npm run coverage
+  - npm run coverage -- --upload
 
 before_script:
   - export DISPLAY=:99.0
@@ -29,7 +23,7 @@ after_success:
   - npm run coverage-publish
 
 addons:
-  firefox: latest
+  firefox: 'latest'
   apt:
     sources:
       - ubuntu-toolchain-r-test

CHANGELOG.md

@@ -0,0 +1,196 @@
+<a name="0.10.1"></a>
+## [0.10.1](https://github.com/libp2p/js-peer-id/compare/v0.10.0...v0.10.1) (2017-09-07)
+
+
+### Features
+
+* **deps:** update aegir and libp2p-crypto ([#67](https://github.com/libp2p/js-peer-id/issues/67)) ([d7088d6](https://github.com/libp2p/js-peer-id/commit/d7088d6))
+
+
+
+<a name="0.10.0"></a>
+# [0.10.0](https://github.com/libp2p/js-peer-id/compare/v0.9.0...v0.10.0) (2017-09-03)
+
+
+### Features
+
+* p2p addrs situation ([#66](https://github.com/libp2p/js-peer-id/issues/66)) ([63428fa](https://github.com/libp2p/js-peer-id/commit/63428fa))
+
+
+
+<a name="0.9.0"></a>
+# [0.9.0](https://github.com/libp2p/js-peer-id/compare/v0.8.8...v0.9.0) (2017-07-22)
+
+
+### Features
+
+* use next libp2p-crypto ([#64](https://github.com/libp2p/js-peer-id/issues/64)) ([442df13](https://github.com/libp2p/js-peer-id/commit/442df13))
+
+
+
+<a name="0.8.8"></a>
+## [0.8.8](https://github.com/libp2p/js-peer-id/compare/v0.8.7...v0.8.8) (2017-07-21)
+
+
+
+<a name="0.8.7"></a>
+## [0.8.7](https://github.com/libp2p/js-peer-id/compare/v0.8.6...v0.8.7) (2017-04-03)
+
+
+### Features
+
+* set privKey pubKey ([ac27907](https://github.com/libp2p/js-peer-id/commit/ac27907))
+
+
+
+<a name="0.8.6"></a>
+## [0.8.6](https://github.com/libp2p/js-peer-id/compare/v0.8.5...v0.8.6) (2017-03-30)
+
+
+### Features
+
+* isEqual ([3f4f670](https://github.com/libp2p/js-peer-id/commit/3f4f670))
+
+
+
+<a name="0.8.5"></a>
+## [0.8.5](https://github.com/libp2p/js-peer-id/compare/v0.8.4...v0.8.5) (2017-03-27)
+
+
+### Bug Fixes
+
+* avoid using constructor.name ([a3fe1a2](https://github.com/libp2p/js-peer-id/commit/a3fe1a2))
+
+
+### Features
+
+* isPeerId ([0acc572](https://github.com/libp2p/js-peer-id/commit/0acc572))
+
+
+
+<a name="0.8.4"></a>
+## [0.8.4](https://github.com/libp2p/js-peer-id/compare/v0.8.2...v0.8.4) (2017-03-16)
+
+
+
+<a name="0.8.2"></a>
+## [0.8.2](https://github.com/libp2p/js-peer-id/compare/v0.8.1...v0.8.2) (2017-02-09)
+
+
+
+<a name="0.8.1"></a>
+## [0.8.1](https://github.com/libp2p/js-peer-id/compare/v0.8.0...v0.8.1) (2016-12-18)
+
+
+### Features
+
+* cache b58 id ([bebb0a7](https://github.com/libp2p/js-peer-id/commit/bebb0a7))
+* create b58 string on creation and throw on id mutation ([78d96d0](https://github.com/libp2p/js-peer-id/commit/78d96d0))
+
+
+
+<a name="0.8.0"></a>
+# [0.8.0](https://github.com/libp2p/js-peer-id/compare/v0.7.0...v0.8.0) (2016-11-03)
+
+
+* Async Crypto Endeavour (#33) ([31701e2](https://github.com/libp2p/js-peer-id/commit/31701e2))
+
+
+### BREAKING CHANGES
+
+* This changes the interface of .create, .createFromPrivKey,
+.createFromPubKey, .createFromJSON
+
+
+
+<a name="0.7.0"></a>
+# [0.7.0](https://github.com/libp2p/js-peer-id/compare/v0.6.7...v0.7.0) (2016-05-26)
+
+
+### Bug Fixes
+
+* code review and docs and go interop ([58f1933](https://github.com/libp2p/js-peer-id/commit/58f1933))
+* use new version of libp2p-crypto ([ab55046](https://github.com/libp2p/js-peer-id/commit/ab55046))
+
+
+
+<a name="0.6.7"></a>
+## [0.6.7](https://github.com/libp2p/js-peer-id/compare/v0.6.6...v0.6.7) (2016-05-23)
+
+
+
+<a name="0.6.6"></a>
+## [0.6.6](https://github.com/libp2p/js-peer-id/compare/v0.6.5...v0.6.6) (2016-04-12)
+
+
+
+<a name="0.6.5"></a>
+## [0.6.5](https://github.com/libp2p/js-peer-id/compare/v0.6.1...v0.6.5) (2016-04-12)
+
+
+
+<a name="0.6.1"></a>
+## [0.6.1](https://github.com/libp2p/js-peer-id/compare/v0.6.0...v0.6.1) (2016-03-15)
+
+
+
+<a name="0.6.0"></a>
+# [0.6.0](https://github.com/libp2p/js-peer-id/compare/v0.5.3...v0.6.0) (2016-03-10)
+
+
+
+<a name="0.5.3"></a>
+## [0.5.3](https://github.com/libp2p/js-peer-id/compare/v0.5.1...v0.5.3) (2016-03-05)
+
+
+
+<a name="0.5.1"></a>
+## [0.5.1](https://github.com/libp2p/js-peer-id/compare/v0.5.0...v0.5.1) (2016-03-03)
+
+
+
+<a name="0.5.0"></a>
+# [0.5.0](https://github.com/libp2p/js-peer-id/compare/v0.4.0...v0.5.0) (2016-02-14)
+
+
+
+<a name="0.4.0"></a>
+# [0.4.0](https://github.com/libp2p/js-peer-id/compare/v0.3.4...v0.4.0) (2015-11-05)
+
+
+
+<a name="0.3.4"></a>
+## [0.3.4](https://github.com/libp2p/js-peer-id/compare/v0.3.3...v0.3.4) (2015-10-28)
+
+
+
+<a name="0.3.3"></a>
+## [0.3.3](https://github.com/libp2p/js-peer-id/compare/v0.3.2...v0.3.3) (2015-09-15)
+
+
+
+<a name="0.3.2"></a>
+## [0.3.2](https://github.com/libp2p/js-peer-id/compare/v0.3.1...v0.3.2) (2015-09-14)
+
+
+
+<a name="0.3.1"></a>
+## [0.3.1](https://github.com/libp2p/js-peer-id/compare/v0.3.0...v0.3.1) (2015-08-25)
+
+
+
+<a name="0.3.0"></a>
+# [0.3.0](https://github.com/libp2p/js-peer-id/compare/v0.2.0...v0.3.0) (2015-07-19)
+
+
+
+<a name="0.2.0"></a>
+# [0.2.0](https://github.com/libp2p/js-peer-id/compare/v0.1.0...v0.2.0) (2015-07-17)
+
+
+
+<a name="0.1.0"></a>
+# 0.1.0 (2015-07-08)
+
+
+

README.md

@@ -7,9 +7,7 @@
 [![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%3D4.0.0-orange.svg?style=flat-square)
+![](https://img.shields.io/badge/Node.js-%3E%3D6.0.0-orange.svg?style=flat-square)
-
-[![Sauce Test Status](https://saucelabs.com/browser-matrix/ipfs-js-peer-id.svg)](https://saucelabs.com/u/ipfs-js-peer-id)
 
 > [IPFS](https://github.com/ipfs/ipfs) Peer ID implementation in JavaScript.
 
@@ -44,25 +42,21 @@
 
 Generate, import, and export PeerIDs, for use with [IPFS](https://github.com/ipfs/ipfs).
 
-*A Peer ID is the SHA-256 [multihash](https://github.com/multiformats/multihash) of a
+A Peer ID is the SHA-256 [multihash](https://github.com/multiformats/multihash) of a public key.
-public key.*
 
-*The public key is a base64 encoded string of a protobuf containing an RSA DER
+The public key is a base64 encoded string of a protobuf containing an RSA DER buffer. This uses a node buffer to pass the base64 encoded public key protobuf to the multihash for ID generation.
-buffer. This uses a node buffer to pass the base64 encoded public key protobuf
-to the multihash for ID generation.*
 
 # Example
 
-```js
+```JavaScript
-var PeerId = require('peer-id')
+const PeerId = require('peer-id')
-var bs58 = require('bs58')
 
 PeerId.create({ bits: 1024 }, (err, id) => {
-  console.log(JSON.stringify(id.toJSON(), null, 2)
+  if (err) { throw err }
+  console.log(JSON.stringify(id.toJSON(), null, 2))
 })
 ```
-
+```bash
-```
 {
   "id": "Qma9T5YraSnpRDZqRR4krcSJabThc8nwZuJV3LercPHufi",
   "privKey": "CAAS4AQwggJcAgEAAoGBAMBgbIqyOL26oV3nGPBYrdpbv..",
@@ -83,7 +77,7 @@ PeerId.create({ bits: 1024 }, (err, id) => {
 ## Node.js
 
 ```js
-var PeerId = require('peer-id')
+const PeerId = require('peer-id')
 ```
 
 ## Browser: Browserify, Webpack, other bundlers
@@ -94,7 +88,7 @@ it and use with your favourite bundler without having to adjust asset management
 process.
 
 ```js
-var PeerId = require('peer-id')
+const PeerId = require('peer-id')
 ```
 
 ## Browser: `<script>` Tag
@@ -203,6 +197,9 @@ Returns an `obj` of the form
 
 Alias for `.toJSON()`.
 
+### `isEqual(id)`
+
+- `id` can be a PeerId or a Buffer containing the id
 
 # License
 

circle.yml

@@ -5,8 +5,10 @@ machine:
 dependencies:
   pre:
     - google-chrome --version
-    - wget -q -O - https://dl-ssl.google.com/linux/linux_signing_key.pub | sudo apt-key add -
+    - curl -L -o google-chrome.deb https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb
-    - sudo sh -c 'echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list'
+    - sudo dpkg -i google-chrome.deb || true
     - sudo apt-get update
-    - sudo apt-get --only-upgrade install google-chrome-stable
+    - 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,20 +1,19 @@
 {
   "name": "peer-id",
-  "version": "0.8.0",
+  "version": "0.10.1",
   "description": "IPFS Peer Id implementation in Node.js",
   "main": "src/index.js",
   "bin": "src/bin.js",
   "scripts": {
-    "lint": "aegir-lint",
+    "lint": "aegir lint",
-    "build": "aegir-build",
+    "build": "aegir build",
-    "test": "aegir-test",
+    "test": "aegir test",
-    "test:node": "aegir-test node",
+    "test:node": "aegir test -t node",
-    "test:browser": "aegir-test browser",
+    "test:browser": "aegir test -t browser -t webworker",
-    "release": "aegir-release",
+    "release": "aegir release",
-    "release-minor": "aegir-release --type minor",
+    "release-minor": "aegir release --type minor",
-    "release-major": "aegir-release --type major",
+    "release-major": "aegir release --type major",
-    "coverage": "aegir-coverage",
+    "coverage": "aegir coverage"
-    "coverage-publish": "aegir-coverage publish"
   },
   "keywords": [
     "IPFS"
@@ -26,21 +25,24 @@
     "test"
   ],
   "engines": {
-    "node": ">=4.0.0"
+    "node": ">=6.0.0",
+    "npm": ">=3.0.0"
   },
   "bugs": {
     "url": "https://github.com/libp2p/js-peer-id/issues"
   },
   "homepage": "https://github.com/libp2p/js-peer-id",
   "devDependencies": {
-    "aegir": "^9.1.2",
+    "aegir": "^12.0.6",
-    "chai": "^3.5.0",
+    "chai": "^4.1.2",
-    "pre-commit": "^1.1.3"
+    "dirty-chai": "^2.0.1",
+    "pre-commit": "^1.2.2"
   },
   "dependencies": {
-    "async": "^2.0.1",
+    "async": "^2.5.0",
-    "libp2p-crypto": "^0.7.0",
+    "libp2p-crypto": "~0.10.3",
-    "multihashes": "^0.3.0"
+    "lodash": "^4.17.4",
+    "multihashes": "~0.4.9"
   },
   "repository": {
     "type": "git",
@@ -50,10 +52,11 @@
     "David Dias <daviddias.p@gmail.com>",
     "David Dias <mail@daviddias.me>",
     "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
+    "Prashanth Chandra <coolshanth94@gmail.com>",
     "Richard Littauer <richard.littauer@gmail.com>",
     "Stephen Whitmore <stephen.whitmore@gmail.com>",
     "greenkeeperio-bot <support@greenkeeper.io>",
     "nginnever <ginneversource@gmail.com>",
     "npmcdn-to-unpkg-bot <npmcdn-to-unpkg-bot@users.noreply.github.com>"
   ]
-}
+}

src/index.js

@@ -17,38 +17,53 @@ class PeerId {
       assert(privKey.public.bytes.equals(pubKey.bytes), 'inconsistent arguments')
     }
 
-    this.id = id
+    this._id = id
+    this._idB58String = mh.toB58String(this.id)
     this._privKey = privKey
     this._pubKey = pubKey
   }
 
+  get id () {
+    return this._id
+  }
+
+  set id (val) {
+    throw new Error('Id is immutable')
+  }
+
   get privKey () {
     return this._privKey
   }
 
+  set privKey (privKey) {
+    this._privKey = privKey
+  }
+
   get pubKey () {
     if (this._pubKey) {
       return this._pubKey
     }
 
-    if (this.privKey) {
+    if (this._privKey) {
-      return this.privKey.public
+      return this._privKey.public
     }
   }
 
-  // Return the protobuf version of the public key,
+  set pubKey (pubKey) {
-  // matching go ipfs formatting
+    this._pubKey = pubKey
+  }
+
+  // Return the protobuf version of the public key, matching go ipfs formatting
   marshalPubKey () {
     if (this.pubKey) {
-      return crypto.marshalPublicKey(this.pubKey)
+      return crypto.keys.marshalPublicKey(this.pubKey)
     }
   }
 
-  // Return the protobuf version of the private key,
+  // Return the protobuf version of the private key, matching go ipfs formatting
-  // matching go ipfs formatting
   marshalPrivKey () {
     if (this.privKey) {
-      return crypto.marshalPrivateKey(this.privKey)
+      return crypto.keys.marshalPrivateKey(this.privKey)
     }
   }
 
@@ -61,7 +76,7 @@ class PeerId {
   // of go-ipfs for its config file
   toJSON () {
     return {
-      id: mh.toB58String(this.id),
+      id: this.toB58String(),
       privKey: toB64Opt(this.marshalPrivKey()),
       pubKey: toB64Opt(this.marshalPubKey())
     }
@@ -77,12 +92,37 @@ class PeerId {
   }
 
   toB58String () {
-    return mh.toB58String(this.id)
+    return this._idB58String
+  }
+
+  isEqual (id) {
+    if (Buffer.isBuffer(id)) {
+      return this.id.equals(id)
+    } else if (id.id) {
+      return this.id.equals(id.id)
+    } else {
+      throw new Error('not valid Id')
+    }
+  }
+
+  /*
+   * Check if this PeerId instance is valid (privKey -> pubKey -> Id)
+   */
+  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)) {
+      callback()
+    } else {
+      callback(new Error('Keys not match'))
+    }
   }
 }
 
 exports = module.exports = PeerId
-exports.Buffer = Buffer
 
 // generation
 exports.create = function (opts, callback) {
@@ -94,7 +134,7 @@ exports.create = function (opts, callback) {
   opts.bits = opts.bits || 2048
 
   waterfall([
-    (cb) => crypto.generateKeyPair('RSA', opts.bits, cb),
+    (cb) => crypto.keys.generateKeyPair('RSA', opts.bits, cb),
     (privKey, cb) => privKey.public.hash((err, digest) => {
       cb(err, digest, privKey)
     })
@@ -121,16 +161,17 @@ exports.createFromB58String = function (str) {
 
 // Public Key input will be a buffer
 exports.createFromPubKey = function (key, callback) {
-  let buf = key
-  if (typeof buf === 'string') {
-    buf = new Buffer(key, 'base64')
-  }
-
   if (typeof callback !== 'function') {
     throw new Error('callback is required')
   }
 
-  const pubKey = crypto.unmarshalPublicKey(buf)
+  let buf = key
+  if (typeof buf === 'string') {
+    buf = Buffer.from(key, 'base64')
+  }
+
+  const pubKey = crypto.keys.unmarshalPublicKey(buf)
+
   pubKey.hash((err, digest) => {
     if (err) {
       return callback(err)
@@ -144,7 +185,7 @@ exports.createFromPubKey = function (key, callback) {
 exports.createFromPrivKey = function (key, callback) {
   let buf = key
   if (typeof buf === 'string') {
-    buf = new Buffer(key, 'base64')
+    buf = Buffer.from(key, 'base64')
   }
 
   if (typeof callback !== 'function') {
@@ -152,7 +193,7 @@ exports.createFromPrivKey = function (key, callback) {
   }
 
   waterfall([
-    (cb) => crypto.unmarshalPrivateKey(buf, cb),
+    (cb) => crypto.keys.unmarshalPrivateKey(buf, cb),
     (privKey, cb) => privKey.public.hash((err, digest) => {
       cb(err, digest, privKey)
     })
@@ -171,13 +212,13 @@ exports.createFromJSON = function (obj, callback) {
   }
 
   const id = mh.fromB58String(obj.id)
-  const rawPrivKey = obj.privKey && new Buffer(obj.privKey, 'base64')
+  const rawPrivKey = obj.privKey && Buffer.from(obj.privKey, 'base64')
-  const rawPubKey = obj.pubKey && new Buffer(obj.pubKey, 'base64')
+  const rawPubKey = obj.pubKey && Buffer.from(obj.pubKey, 'base64')
-  const pub = rawPubKey && crypto.unmarshalPublicKey(rawPubKey)
+  const pub = rawPubKey && crypto.keys.unmarshalPublicKey(rawPubKey)
 
   if (rawPrivKey) {
     waterfall([
-      (cb) => crypto.unmarshalPrivateKey(rawPrivKey, cb),
+      (cb) => crypto.keys.unmarshalPrivateKey(rawPrivKey, cb),
       (priv, cb) => priv.public.hash((err, digest) => {
         cb(err, digest, priv)
       }),
@@ -210,6 +251,12 @@ exports.createFromJSON = function (obj, callback) {
   }
 }
 
+exports.isPeerId = function (peerId) {
+  return Boolean(typeof peerId === 'object' &&
+    peerId._id &&
+    peerId._idB58String)
+}
+
 function toB64Opt (val) {
   if (val) {
     return val.toString('base64')

test/index.spec.js

@@ -1,225 +0,0 @@
-/* eslint max-nested-callbacks: ["error", 8] */
-/* eslint-env mocha */
-'use strict'
-
-const expect = require('chai').expect
-const crypto = require('libp2p-crypto')
-const mh = require('multihashes')
-const parallel = require('async/parallel')
-
-const PeerId = require('../src')
-
-const testId = require('./fixtures/sample-id')
-const testIdHex = testId.id
-const testIdBytes = mh.fromHexString(testId.id)
-const testIdB58String = mh.toB58String(testIdBytes)
-
-const goId = require('./fixtures/go-private-key')
-
-describe('PeerId', () => {
-  it('create an id without \'new\'', () => {
-    expect(PeerId).to.throw(Error)
-  })
-
-  it('create a new id', (done) => {
-    PeerId.create((err, id) => {
-      expect(err).to.not.exist
-      expect(id.toB58String().length).to.equal(46)
-      done()
-    })
-  })
-
-  it('recreate an Id from Hex string', () => {
-    const id = PeerId.createFromHexString(testIdHex)
-    expect(testIdBytes).to.deep.equal(id.id)
-  })
-
-  it('Recreate an Id from a Buffer', () => {
-    const id = PeerId.createFromBytes(testIdBytes)
-    expect(testId.id).to.equal(id.toHexString())
-  })
-
-  it('Recreate a B58 String', () => {
-    const id = PeerId.createFromB58String(testIdB58String)
-    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', (done) => {
-    PeerId.createFromPrivKey(testId.privKey, (err, id) => {
-      expect(err).to.not.exist
-      expect(testIdB58String).to.equal(id.toB58String())
-
-      const encoded = new Buffer(testId.privKey, 'base64')
-      PeerId.createFromPrivKey(encoded, (err, id2) => {
-        expect(err).to.not.exist
-        expect(testIdB58String).to.equal(id2.toB58String())
-        done()
-      })
-    })
-  })
-
-  it('Compare generated ID with one created from PubKey', (done) => {
-    PeerId.create((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('Non-default # of bits', (done) => {
-    PeerId.create({ bits: 1024 }, (err, shortId) => {
-      expect(err).to.not.exist
-      PeerId.create({ bits: 4096 }, (err, longId) => {
-        expect(err).to.not.exist
-        expect(shortId.privKey.bytes.length).is.below(longId.privKey.bytes.length)
-        done()
-      })
-    })
-  })
-
-  it('Pretty printing', (done) => {
-    PeerId.create((err, id1) => {
-      expect(err).to.not.exist
-      PeerId.createFromPrivKey(id1.toPrint().privKey, (err, id2) => {
-        expect(err).to.not.exist
-        expect(id1.toPrint()).to.be.eql(id2.toPrint())
-        done()
-      })
-    })
-  })
-
-  it('toBytes', () => {
-    const id = PeerId.createFromHexString(testIdHex)
-    expect(id.toBytes().toString('hex')).to.equal(testIdBytes.toString('hex'))
-  })
-
-  describe('fromJSON', () => {
-    it('full node', (done) => {
-      PeerId.create({bits: 1024}, (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.deep.equal(
-            other.privKey.bytes
-          )
-          expect(
-            id.pubKey.bytes
-          ).to.deep.equal(
-            other.pubKey.bytes
-          )
-          done()
-        })
-      })
-    })
-
-    it('only id', (done) => {
-      crypto.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', (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.be.eql(
-            goId.id
-          )
-          done()
-        })
-      })
-    })
-  })
-
-  describe('throws on inconsistent data', () => {
-    let k1, k2, k3
-    before((done) => {
-      parallel([
-        (cb) => crypto.generateKeyPair('RSA', 1024, cb),
-        (cb) => crypto.generateKeyPair('RSA', 1024, cb),
-        (cb) => crypto.generateKeyPair('RSA', 1024, cb)
-      ], (err, keys) => {
-        if (err) {
-          return done(err)
-        }
-
-        k1 = keys[0]
-        k2 = keys[1]
-        k3 = keys[2]
-        done()
-      })
-    })
-
-    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', (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', () => {
-      expect(
-        () => new PeerId('hello world')
-      ).to.throw(
-        /invalid id/
-      )
-    })
-  })
-})

test/peer-id.spec.js

@@ -0,0 +1,274 @@
+/* eslint max-nested-callbacks: ["error", 8] */
+/* eslint-env mocha */
+'use strict'
+
+const chai = require('chai')
+const dirtyChai = require('dirty-chai')
+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')
+
+const testId = require('./fixtures/sample-id')
+const testIdHex = testId.id
+const testIdBytes = mh.fromHexString(testId.id)
+const testIdB58String = mh.toB58String(testIdBytes)
+
+const goId = require('./fixtures/go-private-key')
+
+describe('PeerId', () => {
+  it('create an id without \'new\'', () => {
+    expect(PeerId).to.throw(Error)
+  })
+
+  it('create a new id', (done) => {
+    PeerId.create((err, id) => {
+      expect(err).to.not.exist()
+      expect(id.toB58String().length).to.equal(46)
+      done()
+    })
+  })
+
+  it('isPeerId', (done) => {
+    PeerId.create((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', (done) => {
+    PeerId.create((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', () => {
+    const id = PeerId.createFromHexString(testIdHex)
+    expect(testIdBytes).to.deep.equal(id.id)
+  })
+
+  it('Recreate an Id from a Buffer', () => {
+    const id = PeerId.createFromBytes(testIdBytes)
+    expect(testId.id).to.equal(id.toHexString())
+  })
+
+  it('Recreate a B58 String', () => {
+    const id = PeerId.createFromB58String(testIdB58String)
+    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', (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())
+        done()
+      })
+    })
+  })
+
+  it('Compare generated ID with one created from PubKey', (done) => {
+    PeerId.create((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('Non-default # of bits', function (done) {
+    // rsa is slow atm
+    this.timeout(20000)
+    PeerId.create({ bits: 1024 }, (err, shortId) => {
+      expect(err).to.not.exist()
+      PeerId.create({ bits: 4096 }, (err, longId) => {
+        expect(err).to.not.exist()
+        expect(shortId.privKey.bytes.length).is.below(longId.privKey.bytes.length)
+        done()
+      })
+    })
+  })
+
+  it('Pretty printing', (done) => {
+    PeerId.create((err, id1) => {
+      expect(err).to.not.exist()
+      PeerId.createFromPrivKey(id1.toPrint().privKey, (err, id2) => {
+        expect(err).to.not.exist()
+        expect(id1.toPrint()).to.be.eql(id2.toPrint())
+        done()
+      })
+    })
+  })
+
+  it('toBytes', () => {
+    const id = PeerId.createFromHexString(testIdHex)
+    expect(id.toBytes().toString('hex')).to.equal(testIdBytes.toString('hex'))
+  })
+
+  it('isEqual', (done) => {
+    parallel([
+      (cb) => PeerId.create(cb),
+      (cb) => PeerId.create(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', (done) => {
+      PeerId.create({ bits: 1024 }, (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', (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', (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)', (done) => {
+    PeerId.create((err, peerId) => {
+      expect(err).to.not.exist()
+      peerId.privKey = peerId._privKey
+      peerId.isValid(done)
+    })
+  })
+
+  it('set pubKey (valid)', (done) => {
+    PeerId.create((err, peerId) => {
+      expect(err).to.not.exist()
+      peerId.pubKey = peerId._pubKey
+      peerId.isValid(done)
+    })
+  })
+
+  it('set privKey (invalid)', (done) => {
+    PeerId.create((err, peerId) => {
+      expect(err).to.not.exist()
+      peerId.privKey = Buffer.from('bufff')
+      peerId.isValid((err) => {
+        expect(err).to.exist()
+        done()
+      })
+    })
+  })
+
+  it('set pubKey (invalid)', (done) => {
+    PeerId.create((err, peerId) => {
+      expect(err).to.not.exist()
+      peerId.pubKey = Buffer.from('buffff')
+      peerId.isValid((err) => {
+        expect(err).to.exist()
+        done()
+      })
+    })
+  })
+
+  describe('throws on inconsistent data', () => {
+    let k1
+    let k2
+    let k3
+
+    before((done) => {
+      parallel([
+        (cb) => crypto.keys.generateKeyPair('RSA', 1024, cb),
+        (cb) => crypto.keys.generateKeyPair('RSA', 1024, cb),
+        (cb) => crypto.keys.generateKeyPair('RSA', 1024, cb)
+      ], (err, keys) => {
+        expect(err).to.not.exist()
+
+        k1 = keys[0]
+        k2 = keys[1]
+        k3 = keys[2]
+        done()
+      })
+    })
+
+    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', (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', () => {
+      expect(() => new PeerId('hello world')).to.throw(/invalid id/)
+    })
+  })
+})