chore: release version v0.8.7

feat: set privKey pubKey

README.md

@@ -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.4",
+  "version": "0.8.7",
   "description": "IPFS Peer Id implementation in Node.js",
   "main": "src/index.js",
   "bin": "src/bin.js",
@@ -34,15 +34,16 @@
   },
   "homepage": "https://github.com/libp2p/js-peer-id",
   "devDependencies": {
-    "aegir": "^11.0.0",
+    "aegir": "^11.0.1",
     "chai": "^3.5.0",
     "dirty-chai": "^1.2.2",
     "pre-commit": "^1.2.2"
   },
   "dependencies": {
-    "libp2p-crypto": "~0.8.6",
+    "async": "^2.3.0",
-    "multihashes": "~0.4.4",
+    "libp2p-crypto": "~0.8.7",
-    "async": "^2.1.5"
+    "lodash": "^4.17.4",
+    "multihashes": "~0.4.5"
   },
   "repository": {
     "type": "git",

src/index.js

@@ -35,26 +35,32 @@ class PeerId {
     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 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)
@@ -88,10 +94,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) {
@@ -130,16 +161,17 @@ exports.createFromB58String = function (str) {
 
 // Public Key input will be a buffer
 exports.createFromPubKey = function (key, callback) {
+  if (typeof callback !== 'function') {
+    throw new Error('callback is required')
+  }
+
   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)
+
   pubKey.hash((err, digest) => {
     if (err) {
       return callback(err)
@@ -219,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/peer-id.spec.js

@@ -32,6 +32,16 @@ describe('PeerId', () => {
     })
   })
 
+  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()
@@ -119,6 +129,20 @@ 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) => {
@@ -173,17 +197,56 @@ describe('PeerId', () => {
     })
   })
 
+  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 = new Buffer('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 = new Buffer('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)
       ], (err, keys) => {
-        if (err) {
+        expect(err).to.not.exist()
-          return done(err)
-        }
 
         k1 = keys[0]
         k2 = keys[1]
@@ -195,11 +258,8 @@ describe('PeerId', () => {
     it('missmatch private - public key', (done) => {
       k1.public.hash((err, digest) => {
         expect(err).to.not.exist()
-        expect(
+        expect(() => new PeerId(digest, k1, k2.public))
-          () => new PeerId(digest, k1, k2.public)
+          .to.throw(/inconsistent arguments/)
-        ).to.throw(
-            /inconsistent arguments/
-        )
         done()
       })
     })
@@ -207,11 +267,8 @@ describe('PeerId', () => {
     it('missmatch id - private - public key', (done) => {
       k1.public.hash((err, digest) => {
         expect(err).to.not.exist()
-        expect(
+        expect(() => new PeerId(digest, k1, k3.public))
-          () => new PeerId(digest, k1, k3.public)
+          .to.throw(/inconsistent arguments/)
-        ).to.throw(
-            /inconsistent arguments/
-        )
         done()
       })
     })