chore: release version v0.8.6

feat: isEqual

README.md

@@ -58,7 +58,7 @@ var PeerId = require('peer-id')
 var bs58 = require('bs58')
 
 PeerId.create({ bits: 1024 }, (err, id) => {
-  console.log(JSON.stringify(id.toJSON(), null, 2)
+  console.log(JSON.stringify(id.toJSON(), null, 2))
 })
 ```
 
@@ -203,6 +203,9 @@ Returns an `obj` of the form
 
 Alias for `.toJSON()`.
 
+### `isEqual(id)`
+
+- `id` can be a PeerId or a Buffer containing the id
 
 # License
 

package.json

@@ -1,6 +1,6 @@
 {
   "name": "peer-id",
-  "version": "0.8.0",
+  "version": "0.8.6",
   "description": "IPFS Peer Id implementation in Node.js",
   "main": "src/index.js",
   "bin": "src/bin.js",
@@ -26,21 +26,24 @@
     "test"
   ],
   "engines": {
-    "node": ">=4.0.0"
+    "node": ">=4.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": "^11.0.1",
     "chai": "^3.5.0",
-    "pre-commit": "^1.1.3"
+    "dirty-chai": "^1.2.2",
+    "pre-commit": "^1.2.2"
   },
   "dependencies": {
-    "async": "^2.0.1",
-    "libp2p-crypto": "^0.7.0",
-    "multihashes": "^0.3.0"
+    "async": "^2.2.0",
+    "libp2p-crypto": "~0.8.7",
+    "lodash": "^4.17.4",
+    "multihashes": "~0.4.5"
   },
   "repository": {
     "type": "git",
@@ -50,6 +53,7 @@
     "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>",

src/index.js

@@ -17,11 +17,20 @@ 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
   }
@@ -61,7 +70,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 +86,21 @@ 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')
+    }
   }
 }
 
 exports = module.exports = PeerId
-exports.Buffer = Buffer
 
 // generation
 exports.create = function (opts, callback) {
@@ -210,6 +228,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

@@ -2,7 +2,10 @@
 /* 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')
@@ -23,12 +26,33 @@ 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(new Buffer('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 = new Buffer('hello')
+      }).to.throw(/immutable/)
+      done()
+    })
+  })
+
   it('recreate an Id from Hex string', () => {
     const id = PeerId.createFromHexString(testIdHex)
     expect(testIdBytes).to.deep.equal(id.id)
@@ -46,7 +70,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()
     })
@@ -54,12 +78,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')
       PeerId.createFromPrivKey(encoded, (err, id2) => {
-        expect(err).to.not.exist
+        expect(err).to.not.exist()
         expect(testIdB58String).to.equal(id2.toB58String())
         done()
       })
@@ -68,10 +92,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()
       })
@@ -80,9 +104,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()
       })
@@ -91,9 +115,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()
       })
@@ -105,28 +129,30 @@ 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()
         })
       })
@@ -134,16 +160,16 @@ describe('PeerId', () => {
 
     it('only id', (done) => {
       crypto.generateKeyPair('RSA', 1024, (err, key) => {
-        expect(err).to.not.exist
+        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(err).to.not.exist()
             expect(
               id.toB58String()
             ).to.equal(
@@ -157,9 +183,9 @@ 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(err).to.not.exist()
           expect(
             mh.toB58String(digest)
           ).to.be.eql(
@@ -192,7 +218,7 @@ describe('PeerId', () => {
 
     it('missmatch private - public key', (done) => {
       k1.public.hash((err, digest) => {
-        expect(err).to.not.exist
+        expect(err).to.not.exist()
         expect(
           () => new PeerId(digest, k1, k2.public)
         ).to.throw(
@@ -204,7 +230,7 @@ describe('PeerId', () => {
 
     it('missmatch id - private - public key', (done) => {
       k1.public.hash((err, digest) => {
-        expect(err).to.not.exist
+        expect(err).to.not.exist()
         expect(
           () => new PeerId(digest, k1, k3.public)
         ).to.throw(