chore: release version v0.9.0

* feat: use next libp2p-crypto

* chore: update deps

.travis.yml

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

README.md

@@ -9,8 +9,6 @@
 ![](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)
 
-[![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.
 
 - [Description](#description)
@@ -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
-public key.*
+A Peer ID is the SHA-256 [multihash](https://github.com/multiformats/multihash) of a public key.
 
-*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.*
+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.
 
 # Example
 
-```js
-var PeerId = require('peer-id')
-var bs58 = require('bs58')
+```JavaScript
+const PeerId = require('peer-id')
 
 PeerId.create({ bits: 1024 }, (err, id) => {
+  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 -
-    - sudo sh -c 'echo "deb [arch=amd64] http://dl.google.com/linux/chrome/deb/ stable main" >> /etc/apt/sources.list.d/google.list'
+    - 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 --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,6 +1,6 @@
 {
   "name": "peer-id",
-  "version": "0.8.2",
+  "version": "0.9.0",
   "description": "IPFS Peer Id implementation in Node.js",
   "main": "src/index.js",
   "bin": "src/bin.js",
@@ -34,14 +34,16 @@
   },
   "homepage": "https://github.com/libp2p/js-peer-id",
   "devDependencies": {
-    "aegir": "^10.0.0",
-    "chai": "^3.5.0",
+    "aegir": "^11.0.2",
+    "chai": "^4.1.0",
+    "dirty-chai": "^2.0.1",
     "pre-commit": "^1.2.2"
   },
   "dependencies": {
-    "libp2p-crypto": "~0.8.0",
-    "multihashes": "~0.3.3",
-    "async": "^2.1.4"
+    "async": "^2.5.0",
+    "libp2p-crypto": "~0.9.4",
+    "lodash": "^4.17.4",
+    "multihashes": "~0.4.5"
   },
   "repository": {
     "type": "git",
@@ -51,10 +53,10 @@
     "David Dias <daviddias.p@gmail.com>",
     "David Dias <mail@daviddias.me>",
     "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
-    "Greenkeeper <support@greenkeeper.io>",
     "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

@@ -8,6 +8,7 @@ const mh = require('multihashes')
 const crypto = require('libp2p-crypto')
 const assert = require('assert')
 const waterfall = require('async/waterfall')
+const Buffer = require('safe-buffer').Buffer
 
 class PeerId {
   constructor (id, privKey, pubKey) {
@@ -35,29 +36,35 @@ class PeerId {
     return this._privKey
   }
 
+  set privKey (privKey) {
+    this._privKey = privKey
+  }
+
   get pubKey () {
     if (this._pubKey) {
       return this._pubKey
     }
 
-    if (this.privKey) {
-      return this.privKey.public
+    if (this._privKey) {
+      return this._privKey.public
     }
   }
 
-  // Return the protobuf version of the public key,
-  // matching go ipfs formatting
+  set pubKey (pubKey) {
+    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,
-  // matching go ipfs formatting
+  // Return the protobuf version of the private key, matching go ipfs formatting
   marshalPrivKey () {
     if (this.privKey) {
-      return crypto.marshalPrivateKey(this.privKey)
+      return crypto.keys.marshalPrivateKey(this.privKey)
     }
   }
 
@@ -88,10 +95,35 @@ class PeerId {
   toB58String () {
     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) {
@@ -103,7 +135,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)
     })
@@ -130,16 +162,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)
@@ -153,7 +186,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') {
@@ -161,7 +194,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)
     })
@@ -180,13 +213,13 @@ exports.createFromJSON = function (obj, callback) {
   }
 
   const id = mh.fromB58String(obj.id)
-  const rawPrivKey = obj.privKey && new Buffer(obj.privKey, 'base64')
-  const rawPubKey = obj.pubKey && new Buffer(obj.pubKey, 'base64')
-  const pub = rawPubKey && crypto.unmarshalPublicKey(rawPubKey)
+  const rawPrivKey = obj.privKey && Buffer.from(obj.privKey, 'base64')
+  const rawPubKey = obj.pubKey && Buffer.from(obj.pubKey, 'base64')
+  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)
       }),
@@ -219,6 +252,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/peer-id.spec.js

@@ -2,10 +2,14 @@
 /* eslint-env mocha */
 'use strict'
 
-const expect = require('chai').expect
+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 Buffer = require('safe-buffer').Buffer
 
 const PeerId = require('../src')
 
@@ -23,18 +27,28 @@ describe('PeerId', () => {
 
   it('create a new id', (done) => {
     PeerId.create((err, id) => {
-      expect(err).to.not.exist
+      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(err).to.not.exist()
       expect(id.toB58String().length).to.equal(46)
       expect(() => {
-        id.id = new Buffer('hello')
+        id.id = Buffer.from('hello')
       }).to.throw(/immutable/)
       done()
     })
@@ -57,7 +71,7 @@ describe('PeerId', () => {
 
   it('Recreate from a Public Key', (done) => {
     PeerId.createFromPubKey(testId.pubKey, (err, id) => {
-      expect(err).to.not.exist
+      expect(err).to.not.exist()
       expect(testIdB58String).to.equal(id.toB58String())
       done()
     })
@@ -65,12 +79,12 @@ describe('PeerId', () => {
 
   it('Recreate from a Private Key', (done) => {
     PeerId.createFromPrivKey(testId.privKey, (err, id) => {
-      expect(err).to.not.exist
+      expect(err).to.not.exist()
       expect(testIdB58String).to.equal(id.toB58String())
 
-      const encoded = new Buffer(testId.privKey, 'base64')
+      const encoded = Buffer.from(testId.privKey, 'base64')
       PeerId.createFromPrivKey(encoded, (err, id2) => {
-        expect(err).to.not.exist
+        expect(err).to.not.exist()
         expect(testIdB58String).to.equal(id2.toB58String())
         done()
       })
@@ -79,10 +93,10 @@ describe('PeerId', () => {
 
   it('Compare generated ID with one created from PubKey', (done) => {
     PeerId.create((err, id1) => {
-      expect(err).to.not.exist
+      expect(err).to.not.exist()
 
       PeerId.createFromPubKey(id1.marshalPubKey(), (err, id2) => {
-        expect(err).to.not.exist
+        expect(err).to.not.exist()
         expect(id1.id).to.be.eql(id2.id)
         done()
       })
@@ -91,9 +105,9 @@ describe('PeerId', () => {
 
   it('Non-default # of bits', (done) => {
     PeerId.create({ bits: 1024 }, (err, shortId) => {
-      expect(err).to.not.exist
+      expect(err).to.not.exist()
       PeerId.create({ bits: 4096 }, (err, longId) => {
-        expect(err).to.not.exist
+        expect(err).to.not.exist()
         expect(shortId.privKey.bytes.length).is.below(longId.privKey.bytes.length)
         done()
       })
@@ -102,9 +116,9 @@ describe('PeerId', () => {
 
   it('Pretty printing', (done) => {
     PeerId.create((err, id1) => {
-      expect(err).to.not.exist
+      expect(err).to.not.exist()
       PeerId.createFromPrivKey(id1.toPrint().privKey, (err, id2) => {
-        expect(err).to.not.exist
+        expect(err).to.not.exist()
         expect(id1.toPrint()).to.be.eql(id2.toPrint())
         done()
       })
@@ -116,50 +130,48 @@ describe('PeerId', () => {
     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.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
-          )
+          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.generateKeyPair('RSA', 1024, (err, key) => {
-        expect(err).to.not.exist
+      crypto.keys.generateKeyPair('RSA', 1024, (err, key) => {
+        expect(err).to.not.exist()
         key.public.hash((err, digest) => {
-          expect(err).to.not.exist
+          expect(err).to.not.exist()
 
           const id = PeerId.createFromBytes(digest)
-          expect(id.privKey).to.not.exist
-          expect(id.pubKey).to.not.exist
+          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()
-            )
+            expect(err).to.not.exist()
+            expect(id.toB58String()).to.equal(other.toB58String())
             done()
           })
         })
@@ -168,31 +180,66 @@ describe('PeerId', () => {
 
     it('go interop', (done) => {
       PeerId.createFromJSON(goId, (err, id) => {
-        expect(err).to.not.exist
+        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
-          )
+          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, k2, k3
+    let k1
+    let k2
+    let k3
+
     before((done) => {
       parallel([
-        (cb) => crypto.generateKeyPair('RSA', 1024, cb),
-        (cb) => crypto.generateKeyPair('RSA', 1024, cb),
-        (cb) => crypto.generateKeyPair('RSA', 1024, cb)
+        (cb) => crypto.keys.generateKeyPair('RSA', 1024, cb),
+        (cb) => crypto.keys.generateKeyPair('RSA', 1024, cb),
+        (cb) => crypto.keys.generateKeyPair('RSA', 1024, cb)
       ], (err, keys) => {
-        if (err) {
-          return done(err)
-        }
+        expect(err).to.not.exist()
 
         k1 = keys[0]
         k2 = keys[1]
@@ -203,34 +250,24 @@ describe('PeerId', () => {
 
     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/
-        )
+        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/
-        )
+        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/
-      )
+      expect(() => new PeerId('hello world')).to.throw(/invalid id/)
     })
   })
 })