.aegir.js

@@ -1,13 +1,24 @@
 'use strict'
 
-const createServer = require('ipfsd-ctl').createServer
-
-const server = createServer()
+const { createServer } = require('ipfsd-ctl')
+let server
 
 module.exports = {
   hooks: {
     browser: {
-      pre: () => server.start(),
+      pre: async () => {
+        server = createServer({
+          host: '127.0.0.1',
+          port: 57483
+        }, {
+          type: 'go',
+          ipfsHttpModule: require('ipfs-http-client'),
+          ipfsBin: require('go-ipfs-dep').path(),
+          test: true
+        })
+
+        await server.start()
+      },
       post: () => server.stop()
     }
   }

CHANGELOG.md

@@ -1,3 +1,58 @@
+<a name="0.5.0"></a>
+# [0.5.0](https://github.com/libp2p/js-libp2p-delegated-peer-routing/compare/v0.4.3...v0.5.0) (2020-04-23)
+
+
+### Chores
+
+* make ipfs-http-client a peer dependency ([#32](https://github.com/libp2p/js-libp2p-delegated-peer-routing/issues/32)) ([a1b1b5e](https://github.com/libp2p/js-libp2p-delegated-peer-routing/commit/a1b1b5e))
+* remove-peer-info-from-api ([#25](https://github.com/libp2p/js-libp2p-delegated-peer-routing/issues/25)) ([f49ddc0](https://github.com/libp2p/js-libp2p-delegated-peer-routing/commit/f49ddc0))
+
+
+### BREAKING CHANGES
+
+* The ipfs-http-client must now be installed
+as a peer dependency. It is no longer included as a dependency
+of this module.
+
+The reason the http-client should be a peerDependency and
+not a dependency is that its API requires knowledge of the
+http-client (we pass in the api endpoint details).
+* findPeer returns id and addrs properties instead of peer-info instance
+
+* chore: address review
+
+
+
+<a name="0.4.3"></a>
+## [0.4.3](https://github.com/libp2p/js-libp2p-delegated-peer-routing/compare/v0.4.2...v0.4.3) (2020-04-16)
+
+
+
+<a name="0.4.2"></a>
+## [0.4.2](https://github.com/libp2p/js-libp2p-delegated-peer-routing/compare/v0.4.1...v0.4.2) (2020-04-09)
+
+
+
+<a name="0.4.1"></a>
+## [0.4.1](https://github.com/libp2p/js-libp2p-delegated-peer-routing/compare/v0.4.0...v0.4.1) (2020-02-04)
+
+
+
+<a name="0.4.0"></a>
+# [0.4.0](https://github.com/libp2p/js-libp2p-delegated-peer-routing/compare/v0.3.1...v0.4.0) (2019-11-29)
+
+
+### Chores
+
+* rename timeout option ([#14](https://github.com/libp2p/js-libp2p-delegated-peer-routing/issues/14)) ([36d852f](https://github.com/libp2p/js-libp2p-delegated-peer-routing/commit/36d852f))
+
+
+### BREAKING CHANGES
+
+* maxTimeout option renamed to timeout
+
+
+
 <a name="0.3.1"></a>
 ## [0.3.1](https://github.com/libp2p/js-libp2p-delegated-peer-routing/compare/v0.3.0...v0.3.1) (2019-07-24)
 

README.md

@@ -1,10 +1,21 @@
 # js-libp2p-delegated-peer-routing
+
 Leverage other peers in the network to perform Peer Routing calls.
 
+Requires access to `/api/v0/dht/findpeer` HTTP API endpoint of the delegate node.
+
 ## Lead Maintainer
 
 [Jacob Heun](https://github.com/jacobheun)
 
+## Requirements
+
+`libp2p-delegated-peer-routing` leverages the `ipfs-http-client` library and requires it as a peer dependency, as such, both must be installed in order for this module to work properly.
+
+```sh
+npm install ipfs-http-client libp2p-delegated-peer-routing
+```
+
 ## Example
 
 ```js
@@ -14,9 +25,9 @@ const DelegatedPeerRouting = require('libp2p-delegated-peer-routing')
 const routing = new DelegatedPeerRouing()
 
 try {
-  const peerInfo = await routing.findPeer('peerid')
+  const { id, multiaddrs } = await routing.findPeer('peerid')
 
-  console.log('found peer details', peerInfo)
+  console.log('found peer details', id, multiaddrs)
 } catch (err) {
   console.error(err)
 }

package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p-delegated-peer-routing",
-  "version": "0.3.1",
+  "version": "0.5.0",
   "description": "Leverage other peers in the libp2p network to perform Peer Routing calls.",
   "leadMaintainer": "Jacob Heun <jacobheun@gmail.com>",
   "main": "src/index.js",
@@ -18,26 +18,30 @@
     "coverage": "aegir coverage"
   },
   "devDependencies": {
-    "aegir": "^19.0.4",
+    "aegir": "^21.7.0",
     "chai": "^4.2.0",
     "dirty-chai": "^2.0.1",
-    "go-ipfs-dep": "~0.4.17",
-    "ipfsd-ctl": "^0.44.1"
+    "go-ipfs-dep": "0.4.23-3",
+    "ipfs-utils": "^2.2.0",
+    "ipfs-http-client": "^44.0.0",
+    "ipfsd-ctl": "^4.0.1"
+  },
+  "peerDependencies": {
+    "ipfs-http-client": "^44.0.0"
   },
   "dependencies": {
     "debug": "^4.1.1",
-    "ipfs-http-client": "^33.1.0",
-    "p-queue": "^6.1.0",
-    "peer-id": "~0.12.2"
+    "p-queue": "^6.3.0",
+    "peer-id": "^0.13.11"
   },
   "contributors": [
+    "Jacob Heun <jacobheun@gmail.com>",
     "Alan Shaw <alan.shaw@protocol.ai>",
+    "Vasco Santos <vasco.santos@moxy.studio>",
     "Alex Potsides <alex@achingbrain.net>",
-    "David Dias <daviddias.p@gmail.com>",
     "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
-    "Jacob Heun <jacobheun@gmail.com>",
     "Maciej Krüger <mkg20001@gmail.com>",
     "Marcin Rataj <lidel@lidel.org>",
-    "Vasco Santos <vasco.santos@moxy.studio>"
+    "David Dias <daviddias.p@gmail.com>"
   ]
 }

src/index.js

@@ -1,15 +1,14 @@
 'use strict'
 
 const PeerId = require('peer-id')
-const dht = require('ipfs-http-client/src/dht')
-const defaultConfig = require('ipfs-http-client/src/utils/default-config')
+const createFindPeer = require('ipfs-http-client/src/dht/find-peer')
 const { default: PQueue } = require('p-queue')
 const debug = require('debug')
 
 const log = debug('libp2p-delegated-peer-routing')
 log.error = debug('libp2p-delegated-peer-routing:error')
 
-const DEFAULT_MAX_TIMEOUT = 30e3 // 30 second default
+const DEFAULT_TIMEOUT = 30e3 // 30 second default
 const DEFAULT_IPFS_API = {
   protocol: 'https',
   port: 443,
@@ -19,8 +18,8 @@ const CONCURRENT_HTTP_REQUESTS = 4
 
 class DelegatedPeerRouting {
   constructor (api) {
-    this.api = Object.assign({}, defaultConfig(), DEFAULT_IPFS_API, api)
-    this.dht = dht(this.api)
+    this.api = Object.assign({}, DEFAULT_IPFS_API, api)
+    this.dht = { findPeer: createFindPeer(this.api) }
 
     // limit concurrency to avoid request flood in web browser
     // https://github.com/libp2p/js-libp2p-delegated-content-routing/issues/12
@@ -35,21 +34,30 @@ class DelegatedPeerRouting {
    *
    * @param {PeerID} id
    * @param {object} options
-   * @param {number} options.maxTimeout How long the query can take. Defaults to 30 seconds
-   * @returns {Promise<PeerInfo>}
+   * @param {number} options.timeout How long the query can take. Defaults to 30 seconds
+   * @returns {Promise<{ id: PeerId, multiaddrs: Multiaddr[] }>}
    */
   async findPeer (id, options = {}) {
-    if (PeerId.isPeerId(id)) {
-      id = id.toB58String()
+    let idStr = id
+    if (PeerId.isPeerId(idStr)) {
+      idStr = id.toB58String()
     }
+
     log('findPeer starts: ' + id)
 
-    options.maxTimeout = options.maxTimeout || DEFAULT_MAX_TIMEOUT
+    options.timeout = options.timeout || DEFAULT_TIMEOUT
 
     try {
-      return await this._httpQueue.add(() => this.dht.findPeer(id, {
-        timeout: `${options.maxTimeout}ms`// The api requires specification of the time unit (s/ms)
-      }))
+      return await this._httpQueue.add(async () => {
+        const { addrs } = await this.dht.findPeer(idStr, {
+          timeout: options.timeout
+        })
+
+        return {
+          id,
+          multiaddrs: addrs
+        }
+      })
     } catch (err) {
       if (err.message.includes('not found')) {
         return undefined

test/index.spec.js

@@ -4,20 +4,29 @@
 const chai = require('chai')
 const { expect } = chai
 chai.use(require('dirty-chai'))
-const IPFSFactory = require('ipfsd-ctl')
+const { createFactory } = require('ipfsd-ctl')
 const PeerID = require('peer-id')
+const { isNode } = require('ipfs-utils/src/env')
 
 const DelegatedPeerRouting = require('../src')
-const factory = IPFSFactory.create({ type: 'go' })
+const factory = createFactory({
+  type: 'go',
+  ipfsHttpModule: require('ipfs-http-client'),
+  ipfsBin: isNode ? require('go-ipfs-dep').path() : undefined,
+  test: true,
+  endpoint: 'http://localhost:57483'
+})
 
 async function spawnNode (boostrap = []) {
   const node = await factory.spawn({
     // Lock down the nodes so testing can be deterministic
-    config: {
-      Bootstrap: boostrap,
-      Discovery: {
-        MDNS: {
-          Enabled: false
+    ipfsOptions: {
+      config: {
+        Bootstrap: boostrap,
+        Discovery: {
+          MDNS: {
+            Enabled: false
+          }
         }
       }
     }
@@ -68,7 +77,6 @@ describe('DelegatedPeerRouting', function () {
       const router = new DelegatedPeerRouting()
 
       expect(router.api).to.include({
-        'api-path': '/api/v0/',
         protocol: 'https',
         port: 443,
         host: 'node0.delegate.ipfs.io'
@@ -81,7 +89,6 @@ describe('DelegatedPeerRouting', function () {
       })
 
       expect(router.api).to.include({
-        'api-path': '/api/v0/',
         protocol: 'https',
         port: 443,
         host: 'other.ipfs.io'
@@ -90,7 +97,7 @@ describe('DelegatedPeerRouting', function () {
 
     it('should allow for overriding the api', () => {
       const api = {
-        'api-path': '/api/v1/',
+        apiPath: '/api/v1',
         protocol: 'http',
         port: 8000,
         host: 'localhost'
@@ -104,15 +111,17 @@ describe('DelegatedPeerRouting', function () {
   describe('findPeers', () => {
     it('should be able to find peers via the delegate with a peer id string', async () => {
       const opts = delegatedNode.apiAddr.toOptions()
+
       const router = new DelegatedPeerRouting({
         protocol: 'http',
         port: opts.port,
         host: opts.host
       })
 
-      const peer = await router.findPeer(peerIdToFind.id)
-      expect(peer).to.exist()
-      expect(peer.id.toB58String()).to.eql(peerIdToFind.id)
+      const { id, multiaddrs } = await router.findPeer(peerIdToFind.id)
+      expect(id).to.exist()
+      expect(multiaddrs).to.exist()
+      expect(id).to.eql(peerIdToFind.id)
     })
 
     it('should be able to find peers via the delegate with a peerid', async () => {
@@ -123,22 +132,26 @@ describe('DelegatedPeerRouting', function () {
         host: opts.host
       })
 
-      const peer = await router.findPeer(PeerID.createFromB58String(peerIdToFind.id))
-      expect(peer).to.exist()
-      expect(peer.id.toB58String()).to.eql(peerIdToFind.id)
+      const { id, multiaddrs } = await router.findPeer(PeerID.createFromB58String(peerIdToFind.id))
+      expect(id).to.exist()
+      expect(multiaddrs).to.exist()
+
+      expect(id.toB58String()).to.eql(peerIdToFind.id)
     })
 
-    it('should be able to specify a maxTimeout', async () => {
+    it('should be able to specify a timeout', async () => {
       const opts = delegatedNode.apiAddr.toOptions()
       const router = new DelegatedPeerRouting({
         protocol: 'http',
         port: opts.port,
         host: opts.host
       })
 
-      const peer = await router.findPeer(PeerID.createFromB58String(peerIdToFind.id), { maxTimeout: 2000 })
-      expect(peer).to.exist()
-      expect(peer.id.toB58String()).to.eql(peerIdToFind.id)
+      const { id, multiaddrs } = await router.findPeer(PeerID.createFromB58String(peerIdToFind.id), { timeout: 2000 })
+      expect(id).to.exist()
+      expect(multiaddrs).to.exist()
+
+      expect(id.toB58String()).to.eql(peerIdToFind.id)
     })
 
     it('should not be able to find peers not on the network', async () => {