chore: peer-discovery not using peer-info

package.json

@@ -41,8 +41,9 @@
   "devDependencies": {
     "aegir": "^21.4.5",
     "chai": "^4.2.0",
+    "chai-bytes": "^0.1.2",
     "dirty-chai": "^2.0.1",
-    "libp2p-interfaces": "^0.2.7",
+    "libp2p-interfaces": "libp2p/js-interfaces#v0.3.x",
     "p-defer": "^3.0.0",
     "p-wait-for": "^3.1.0",
     "sinon": "^9.0.1"
@@ -52,7 +53,6 @@
     "emittery": "^0.6.0",
     "multiaddr": "^7.4.3",
     "peer-id": "^0.13.11",
-    "peer-info": "^0.17.5",
     "protons": "^1.0.2"
   },
   "contributors": [

src/index.js

@@ -4,7 +4,6 @@ const Emittery = require('emittery')
 const debug = require('debug')
 
 const PeerId = require('peer-id')
-const PeerInfo = require('peer-info')
 const multiaddr = require('multiaddr')
 
 const PB = require('./peer.proto')
@@ -31,17 +30,20 @@ class PubsubPeerDiscovery extends Emittery {
    * @constructor
    * @param {Libp2p} param0.libp2p Our libp2p node
    * @param {number} [param0.interval = 10000] How often (ms) we should broadcast our infos
+   * @param {Array<Multiaddr>} param0.multiaddrs Multiaddrs used by the node to listen.
    * @param {Array<string>} [param0.topics = PubsubPeerDiscovery.TOPIC] What topics to subscribe to. If set, the default will NOT be used.
    * @param {boolean} [param0.listenOnly = false] If true, we will not broadcast our peer data
    */
   constructor ({
     libp2p,
     interval = 10000,
     topics,
+    multiaddrs = [],
     listenOnly = false
   }) {
     super()
     this.libp2p = libp2p
+    this.multiaddrs = multiaddrs
     this.interval = interval
     this._intervalId = null
     this._listenOnly = listenOnly
@@ -54,6 +56,7 @@ class PubsubPeerDiscovery extends Emittery {
     }
 
     this.removeListener = this.off.bind(this)
+    this.removeAllListeners = this.clearListeners.bind(this)
   }
 
   /**
@@ -97,8 +100,8 @@ class PubsubPeerDiscovery extends Emittery {
    */
   _broadcast () {
     const peer = {
-      publicKey: this.libp2p.peerInfo.id.pubKey.bytes,
-      addrs: this.libp2p.peerInfo.multiaddrs.toArray().map(ma => ma.buffer)
+      publicKey: this.libp2p.peerId.pubKey.bytes,
+      addrs: this.multiaddrs.map(ma => ma.buffer)
     }
 
     const encodedPeer = PB.Peer.encode(peer)
@@ -120,16 +123,23 @@ class PubsubPeerDiscovery extends Emittery {
       const peerId = await PeerId.createFromPubKey(peer.publicKey)
 
       // Ignore if we received our own response
-      if (peerId.equals(this.libp2p.peerInfo.id)) return
+      if (peerId.equals(this.libp2p.peerId)) return
 
-      const peerInfo = new PeerInfo(peerId)
-      peer.addrs.forEach(buffer => peerInfo.multiaddrs.add(multiaddr(buffer)))
       log('discovered peer %j on %j', peerId, message.topicIDs)
-      this.emit('peer', peerInfo)
+      this._onNewPeer(peerId, peer.addrs)
     } catch (err) {
       log.error(err)
     }
   }
+
+  _onNewPeer (peerId, addrs) {
+    if (!this._intervalId) return
+
+    this.emit('peer', {
+      id: peerId,
+      multiaddrs: addrs.map(b => multiaddr(b))
+    })
+  }
 }
 
 PubsubPeerDiscovery.TOPIC = TOPIC

test/compliance.spec.js

@@ -5,27 +5,34 @@ const tests = require('libp2p-interfaces/src/peer-discovery/tests')
 const PubsubPeerDiscovery = require('../src')
 
 const PeerID = require('peer-id')
-const PeerInfo = require('peer-info')
 
 describe('compliance tests', () => {
+  let intervalId
   tests({
     async setup () {
       const peerId = await PeerID.create({ bits: 512 })
-      const peerInfo = new PeerInfo(peerId)
       await new Promise(resolve => setTimeout(resolve, 10))
-      return new PubsubPeerDiscovery({
+
+      const pubsubDiscovery = new PubsubPeerDiscovery({
         libp2p: {
-          peerInfo,
+          peerId,
           pubsub: {
             subscribe: () => {},
             unsubscribe: () => {},
             publish: () => {}
           }
         }
       })
+
+      intervalId = setInterval(() => {
+        pubsubDiscovery._onNewPeer(peerId, ['/ip4/166.10.1.2/tcp/80'])
+      }, 1000)
+
+      return pubsubDiscovery
     },
     async teardown () {
       await new Promise(resolve => setTimeout(resolve, 10))
+      clearInterval(intervalId)
     }
   })
 })

test/index.spec.js

@@ -3,27 +3,29 @@
 
 const chai = require('chai')
 chai.use(require('dirty-chai'))
+chai.use(require('chai-bytes'))
 const { expect } = chai
 const sinon = require('sinon')
 const defer = require('p-defer')
 const pWaitFor = require('p-wait-for')
 
+const multiaddr = require('multiaddr')
 const PeerID = require('peer-id')
-const PeerInfo = require('peer-info')
 
 const PubsubPeerDiscovery = require('../src')
 const PB = require('../src/peer.proto')
 
+const listeningMultiaddrs = multiaddr('/ip4/127.0.0.1/tcp/9000/ws')
+
 describe('Pubsub Peer Discovery', () => {
   let mockLibp2p
   let discovery
 
   before(async () => {
-    const peerInfo = await PeerInfo.create()
-    peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/9000/ws')
+    const peerId = await PeerID.create()
 
     mockLibp2p = {
-      peerInfo,
+      peerId,
       pubsub: {
         subscribe: () => {},
         publish: () => {},
@@ -38,18 +40,18 @@ describe('Pubsub Peer Discovery', () => {
   })
 
   it('should not discover self', async () => {
-    discovery = new PubsubPeerDiscovery({ libp2p: mockLibp2p })
+    discovery = new PubsubPeerDiscovery({ libp2p: mockLibp2p, multiaddrs: [listeningMultiaddrs] })
     sinon.spy(mockLibp2p.pubsub, 'publish')
     discovery._broadcast()
     expect(mockLibp2p.pubsub.publish.callCount).to.equal(1)
 
     const [topic, encodedPeer] = mockLibp2p.pubsub.publish.getCall(0).args
     const peer = PB.Peer.decode(encodedPeer)
     const peerId = await PeerID.createFromPubKey(peer.publicKey)
-    expect(peerId.equals(mockLibp2p.peerInfo.id)).to.equal(true)
+    expect(peerId.equals(mockLibp2p.peerId)).to.equal(true)
     expect(peer.addrs).to.have.length(1)
     peer.addrs.forEach((addr) => {
-      expect(mockLibp2p.peerInfo.multiaddrs.has(addr)).to.equal(true)
+      expect(addr).to.equalBytes(listeningMultiaddrs.buffer)
     })
     expect(topic).to.equal(PubsubPeerDiscovery.TOPIC)
 
@@ -60,14 +62,20 @@ describe('Pubsub Peer Discovery', () => {
   })
 
   it('should be able to encode/decode a message', async () => {
-    discovery = new PubsubPeerDiscovery({ libp2p: mockLibp2p })
+    discovery = new PubsubPeerDiscovery({ libp2p: mockLibp2p, multiaddrs: [listeningMultiaddrs] })
+    discovery.start()
+
     const peerId = await PeerID.create({ bits: 512 })
-    const expectedPeerInfo = new PeerInfo(peerId)
-    expectedPeerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/8080/ws')
-    expectedPeerInfo.multiaddrs.add('/ip4/0.0.0.0/tcp/8081/ws')
+    const expectedPeerData = {
+      id: peerId,
+      multiaddrs: [
+        '/ip4/0.0.0.0/tcp/8080/ws',
+        '/ip4/0.0.0.0/tcp/8081/ws'
+      ]
+    }
     const peer = {
       publicKey: peerId.pubKey.bytes,
-      addrs: expectedPeerInfo.multiaddrs.toArray().map(ma => ma.buffer)
+      addrs: expectedPeerData.multiaddrs.map(ma => multiaddr(ma).buffer)
     }
 
     const deferred = defer()
@@ -80,9 +88,10 @@ describe('Pubsub Peer Discovery', () => {
     await discovery._onMessage({ data: encodedPeer, topicIDs: [PubsubPeerDiscovery.TOPIC] })
 
     const discoveredPeer = await deferred.promise
-    expect(discoveredPeer.id.equals(expectedPeerInfo.id)).to.equal(true)
-    expectedPeerInfo.multiaddrs.forEach(addr => {
-      expect(discoveredPeer.multiaddrs.has(addr)).to.equal(true)
+    expect(discoveredPeer.id.equals(expectedPeerData.id)).to.equal(true)
+
+    discoveredPeer.multiaddrs.forEach(addr => {
+      expect(expectedPeerData.multiaddrs.includes(addr.toString())).to.equal(true)
     })
   })