fix: remove peer routing search-for-self

The peer routing module starts a recurring process that searches for
peers close to our peer id.

This makes the DHT module query the network for peers.  Thing is the
DHT module is already doing this because periodically searching for
peers close to us is in the DHT spec so this ends up making redundant
queries.

This PR removes the recurring task configured by the peer routing module.

.aegir.js

@@ -7,7 +7,7 @@ const Peers = require('./test/fixtures/peers')
 const PeerId = require('peer-id')
 const WebSockets = require('libp2p-websockets')
 const Muxer = require('libp2p-mplex')
-const { NOISE: Crypto } = require('libp2p-noise')
+const { NOISE: Crypto } = require('@chainsafe/libp2p-noise')
 const pipe = require('it-pipe')
 let libp2p
 

.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,5 @@
+blank_issues_enabled: false
+contact_links:
+ - name: libp2p Official Forum
+   url: https://discuss.libp2p.io
+   about: For general questions, support requests and discussions

.github/ISSUE_TEMPLATE/open_an_issue.md

@@ -0,0 +1,55 @@
+---
+name: Open an issue
+about: For reporting bugs or errors in the JavaScript libp2p implementation
+title: ''
+labels: need/triage
+assignees: ''
+---
+
+<!--
+Thank you for reporting an issue.
+
+This issue tracker is for bugs found within the JavaScript implementation of libp2p.
+
+If you are asking a question about how to use libp2p, please ask on https://discuss.libp2p.io
+
+Otherwise please fill in as much of the template below as possible.
+-->
+
+- **Version**:
+<!--
+Check package.json version
+-->
+
+- **Platform**:
+<!--
+Output of `uname -a` (UNIX), or version and 32 or 64-bit (Windows). If using in a Browser, please share the browser version as well
+-->
+
+- **Subsystem**:
+<!--
+If known, please specify affected core module name (e.g Dialer, Pubsub, Relay etc)
+-->
+
+#### Severity:
+<!--
+One of following:
+  Critical - System crash, application panic.
+  High - The main functionality of the application does not work, API breakage, repo format breakage, etc.
+  Medium - A non-essential functionality does not work, performance issues, etc.
+  Low - An optional functionality does not work.
+  Very Low - Translation or documentation mistake. Something that won't give anyone a bad day.
+-->
+
+#### Description:
+<!--
+- What you did
+- What happened
+- What you expected to happen
+-->
+
+#### Steps to reproduce the error:
+<!--
+If possible, please provide code that demonstrates the problem, keeping it as simple and free of external dependencies as you are able
+-->
+

.github/ISSUE_TEMPLATE/release.md

@@ -25,7 +25,6 @@
     - [ ] [js-ipfs](https://github.com/ipfs/js-ipfs)
 - Documentation
   - [ ] Ensure that README.md is up to date
-  - [ ] Ensure [libp2p/js-libp2p-examples](https://github.com/libp2p/js-libp2p-examples) is updated
   - [ ] Ensure that [libp2p/docs](https://github.com/libp2p/docs) is updated
 - Communication
   - [ ] Create the release issue

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "11:00"
+  open-pull-requests-limit: 10

.github/workflows/examples.yml

@@ -12,6 +12,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
+    - uses: actions/setup-node@v2
+      with:
+        node-version: 16
     - run: npm install
     - run: npx aegir lint
     - run: npx aegir ts -p check
@@ -21,82 +24,118 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
       - run: npm install
-      - run: cd examples && yarn && npm run test -- auto-relay
+      - run: cd examples && npm i && npm run test -- auto-relay
   test-chat-example:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
       - run: npm install
-      - run: cd examples && yarn && npm run test -- chat
+      - run: cd examples && npm i && npm run test -- chat
   test-connection-encryption-example:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
       - run: npm install
-      - run: cd examples && yarn && npm run test -- connection-encryption
+      - run: cd examples && npm i && npm run test -- connection-encryption
   test-discovery-mechanisms-example:
     needs: check
     runs-on: macos-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
       - run: npm install
-      - run: cd examples && yarn && npm run test -- discovery-mechanisms
+      - run: cd examples && npm i && npm run test -- discovery-mechanisms
   test-echo-example:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
       - run: npm install
-      - run: cd examples && yarn && npm run test -- echo
+      - run: cd examples && npm i && npm run test -- echo
   test-libp2p-in-the-browser-example:
     needs: check
     runs-on: macos-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
       - run: npm install
-      - run: cd examples && yarn && npm run test -- libp2p-in-the-browser
+      - run: cd examples && npm i && npm run test -- libp2p-in-the-browser
   test-peer-and-content-routing-example:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+            node-version: 16
       - run: npm install
-      - run: cd examples && yarn && npm run test -- peer-and-content-routing
+      - run: cd examples && npm i && npm run test -- peer-and-content-routing
   test-pnet-example:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+            node-version: 16
       - run: npm install
-      - run: cd examples && yarn && npm run test -- pnet
+      - run: cd examples && npm i && npm run test -- pnet
   test-protocol-and-stream-muxing-example:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+            node-version: 16
       - run: npm install
-      - run: cd examples && yarn && npm run test -- protocol-and-stream-muxing
+      - run: cd examples && npm i && npm run test -- protocol-and-stream-muxing
   test-pubsub-example:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+            node-version: 16
       - run: npm install
-      - run: cd examples && yarn && npm run test -- pubsub
+      - run: cd examples && npm i && npm run test -- pubsub
   test-transports-example:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+            node-version: 16
       - run: npm install
-      - run: cd examples && yarn && npm run test -- transports
+      - run: cd examples && npm i && npm run test -- transports
   test-webrtc-direct-example:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && yarn && npm run test -- webrtc-direct
+      - uses: actions/setup-node@v2
+        with:
+            node-version: 16
+      - run: npm install -g @mapbox/node-pre-gyp && npm install
+      - run: cd examples && npm i && npm run test -- webrtc-direct

.github/workflows/main.yml

@@ -12,12 +12,14 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
+    - uses: actions/setup-node@v2
+      with:
+        node-version: 16
     - run: npm install
     - run: npx aegir lint
-    - uses: gozala/typescript-error-reporter-action@v1.0.8
     - run: npx aegir build
     - run: npx aegir dep-check
-    - uses: ipfs/aegir/actions/bundle-size@master
+    - uses: ipfs/aegir/actions/bundle-size@v32.1.0
       name: size
       with:
         github_token: ${{ secrets.GITHUB_TOKEN }}
@@ -27,11 +29,11 @@ jobs:
     strategy:
       matrix:
         os: [windows-latest, ubuntu-latest, macos-latest]
-        node: [14]
+        node: [16]
       fail-fast: true
     steps:
       - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
+      - uses: actions/setup-node@v2
         with:
           node-version: ${{ matrix.node }}
       - run: npm install
@@ -42,6 +44,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
       - run: npm install
       - run: npx aegir test -t browser -t webworker --bail
   test-firefox:
@@ -49,6 +54,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
       - run: npm install
       - run: npx aegir test -t browser -t webworker --bail -- --browser firefox
   test-ts:
@@ -56,6 +64,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
       - run: npm install
       - run: npm run test:ts
   test-interop:
@@ -63,5 +74,8 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
       - run: npm install
-      - run: cd node_modules/interop-libp2p && yarn && LIBP2P_JS=${GITHUB_WORKSPACE}/src/index.js npx aegir test -t node --bail
+      - run: npm run test:interop -- --bail -- --exit

CHANGELOG.md

@@ -1,3 +1,175 @@
+## [0.35.1](https://github.com/libp2p/js-libp2p/compare/v0.35.0...v0.35.1) (2021-12-03)
+
+
+### Bug Fixes
+
+* do not let closest peers run forever ([#1047](https://github.com/libp2p/js-libp2p/issues/1047)) ([91c2ec9](https://github.com/libp2p/js-libp2p/commit/91c2ec9856a3e972b7b2c9c4d9a4eda1d431c7ef))
+
+
+
+# [0.35.0](https://github.com/libp2p/js-libp2p/compare/v0.34.0...v0.35.0) (2021-12-02)
+
+
+### Bug Fixes
+
+* stop dht before connection manager ([#1041](https://github.com/libp2p/js-libp2p/issues/1041)) ([3a9d5f6](https://github.com/libp2p/js-libp2p/commit/3a9d5f64d96719ebb4d3b083c4f5832db4fa0816)), closes [#1039](https://github.com/libp2p/js-libp2p/issues/1039)
+
+
+### chore
+
+* update peer id and libp2p crypto ([#1042](https://github.com/libp2p/js-libp2p/issues/1042)) ([9cbf36f](https://github.com/libp2p/js-libp2p/commit/9cbf36fcb54099e6fed35ceccc4a2376f0926c1f))
+
+
+### BREAKING CHANGES
+
+* requires node 15+
+
+
+
+# [0.34.0](https://github.com/libp2p/js-libp2p/compare/v0.33.0...v0.34.0) (2021-11-25)
+
+
+### Bug Fixes
+
+* private ip ts compile has no call signatures ([#1020](https://github.com/libp2p/js-libp2p/issues/1020)) ([77d7cb8](https://github.com/libp2p/js-libp2p/commit/77d7cb8f0815f2cdd3bfdfa8b641a7a186fe9520))
+
+
+### Features
+
+* update dht ([#1009](https://github.com/libp2p/js-libp2p/issues/1009)) ([2f598eb](https://github.com/libp2p/js-libp2p/commit/2f598eba09cff4301474af08196158065e3602d8))
+
+
+### BREAKING CHANGES
+
+* libp2p-kad-dht has a new event-based API which is exposed as `_dht`
+
+
+
+# [0.33.0](https://github.com/libp2p/js-libp2p/compare/v0.32.5...v0.33.0) (2021-09-24)
+
+
+### chore
+
+* update datastore ([#990](https://github.com/libp2p/js-libp2p/issues/990)) ([83734ef](https://github.com/libp2p/js-libp2p/commit/83734ef52061ad61ddb5ca49aae27e3a8b937058))
+
+
+### BREAKING CHANGES
+
+* datastore implementations provided to libp2p must be compliant with interface-datastore@6.0.0
+
+
+
+## [0.32.5](https://github.com/libp2p/js-libp2p/compare/v0.32.4...v0.32.5) (2021-09-21)
+
+
+### Bug Fixes
+
+* move abortable-iterator to dependencies ([#992](https://github.com/libp2p/js-libp2p/issues/992)) ([122c89d](https://github.com/libp2p/js-libp2p/commit/122c89dd0df55a59edaae078e3dc7c31b5603715)), closes [#986](https://github.com/libp2p/js-libp2p/issues/986)
+
+
+
+## [0.32.4](https://github.com/libp2p/js-libp2p/compare/v0.32.3...v0.32.4) (2021-08-20)
+
+
+
+## [0.32.3](https://github.com/libp2p/js-libp2p/compare/v0.32.2...v0.32.3) (2021-08-16)
+
+
+### Bug Fixes
+
+* uint8arrays is a dep ([#964](https://github.com/libp2p/js-libp2p/issues/964)) ([ba2b4d4](https://github.com/libp2p/js-libp2p/commit/ba2b4d4b28f1d9940b457de344aed44537f9eabd))
+
+
+
+## [0.32.2](https://github.com/libp2p/js-libp2p/compare/v0.32.1...v0.32.2) (2021-08-13)
+
+
+### Bug Fixes
+
+* browser example ci ([3b33fb4](https://github.com/libp2p/js-libp2p/commit/3b33fb4b73ba8065e432fb59f758fe138fd23d9e))
+
+
+### Features
+
+* custom protocol name ([#962](https://github.com/libp2p/js-libp2p/issues/962)) ([ef24fab](https://github.com/libp2p/js-libp2p/commit/ef24fabf0269fd079888e92eedb458e23ef1c733))
+
+
+
+## [0.32.1](https://github.com/libp2p/js-libp2p/compare/v0.32.0...v0.32.1) (2021-07-22)
+
+
+### Bug Fixes
+
+* turn compliance tests into devDependency ([#960](https://github.com/libp2p/js-libp2p/issues/960)) ([0701de4](https://github.com/libp2p/js-libp2p/commit/0701de40b1ebdf319959846d8c4fdd30b3cf34a4))
+
+
+
+# [0.32.0](https://github.com/libp2p/js-libp2p/compare/v0.32.0-rc.0...v0.32.0) (2021-07-15)
+
+
+
+# [0.32.0-rc.0](https://github.com/libp2p/js-libp2p/compare/v0.31.7...v0.32.0-rc.0) (2021-07-09)
+
+
+### Bug Fixes
+
+* do not allow dial to large number of multiaddrs ([#954](https://github.com/libp2p/js-libp2p/issues/954)) ([af723b3](https://github.com/libp2p/js-libp2p/commit/af723b355e1ddf4aecf439f81c3aa67613d45fa4))
+
+
+### chore
+
+* update to new multiformats ([#948](https://github.com/libp2p/js-libp2p/issues/948)) ([13cf476](https://github.com/libp2p/js-libp2p/commit/13cf4761489d59b22924bb8ec2ec6dbe207b280c))
+
+
+### BREAKING CHANGES
+
+* uses the CID class from the new multiformats module
+
+Co-authored-by: Vasco Santos <vasco.santos@moxy.studio>
+
+
+
+## [0.31.7](https://github.com/libp2p/js-libp2p/compare/v0.31.6...v0.31.7) (2021-06-14)
+
+
+### Bug Fixes
+
+* chat example with new multiaddr ([#946](https://github.com/libp2p/js-libp2p/issues/946)) ([d8ba284](https://github.com/libp2p/js-libp2p/commit/d8ba2848833d9fb8a963d1b7c8d27062c6f829da))
+* dialer leaking resources after stopping ([#947](https://github.com/libp2p/js-libp2p/issues/947)) ([b291bc0](https://github.com/libp2p/js-libp2p/commit/b291bc06ec13feeb6e010730edfad754a3b2dc1b))
+
+
+
+## [0.31.6](https://github.com/libp2p/js-libp2p/compare/v0.31.5...v0.31.6) (2021-05-27)
+
+
+### Features
+
+* keychain rotate passphrase ([#944](https://github.com/libp2p/js-libp2p/issues/944)) ([478963a](https://github.com/libp2p/js-libp2p/commit/478963ad2d195444494c0acc54cb3847a29e117c))
+
+
+
+## [0.31.5](https://github.com/libp2p/js-libp2p/compare/v0.31.4...v0.31.5) (2021-05-12)
+
+
+### Bug Fixes
+
+* store remote agent and protocol version during identify ([#943](https://github.com/libp2p/js-libp2p/issues/943)) ([818d2b2](https://github.com/libp2p/js-libp2p/commit/818d2b2a98736f4242694479089396f6070cdad5))
+
+
+
+## [0.31.4](https://github.com/libp2p/js-libp2p/compare/v0.31.3...v0.31.4) (2021-05-12)
+
+
+### Bug Fixes
+
+* peerRouting.findPeer() trying to find self ([#941](https://github.com/libp2p/js-libp2p/issues/941)) ([a79c6b5](https://github.com/libp2p/js-libp2p/commit/a79c6b50d7fddbcdb1af53efae922cecad4c9a83))
+
+
+
+## [0.31.3](https://github.com/libp2p/js-libp2p/compare/v0.31.2...v0.31.3) (2021-05-04)
+
+
+
 ## [0.31.2](https://github.com/libp2p/js-libp2p/compare/v0.31.1...v0.31.2) (2021-04-30)
 
 

README.md

@@ -163,9 +163,9 @@ List of packages currently in existence for libp2p
 | [`libp2p-kad-dht`](//github.com/libp2p/js-libp2p-kad-dht) | [![npm](https://img.shields.io/npm/v/libp2p-kad-dht.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-kad-dht/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-kad-dht.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-dht) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-kad-dht/master)](https://travis-ci.com/libp2p/js-libp2p-kad-dht) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-kad-dht/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-kad-dht) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
 | **utilities** |
 | [`libp2p-crypto`](//github.com/libp2p/js-libp2p-crypto) | [![npm](https://img.shields.io/npm/v/libp2p-crypto.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-crypto/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-crypto.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-crypto) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-crypto/master)](https://travis-ci.com/libp2p/js-libp2p-crypto) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-crypto/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-crypto) | [Jacob Heun](mailto:jacobheun@gmail.com) |
-| [`libp2p-crypto-secp256k1`](//github.com/libp2p/js-libp2p-crypto-secp256k1) | [![npm](https://img.shields.io/npm/v/libp2p-crypto-secp256k1.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-crypto-secp256k1/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-crypto-secp256k1.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-crypto-secp256k1) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-crypto-secp256k1/master)](https://travis-ci.com/libp2p/js-libp2p-crypto-secp256k1) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-crypto-secp256k1/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-crypto-secp256k1) | [Friedel Ziegelmayer](mailto:dignifiedquire@gmail.com) |
 | **data types** |
 | [`peer-id`](//github.com/libp2p/js-peer-id) | [![npm](https://img.shields.io/npm/v/peer-id.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-peer-id/releases) | [![Deps](https://david-dm.org/libp2p/js-peer-id.svg?style=flat-square)](https://david-dm.org/libp2p/js-peer-id) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-peer-id/master)](https://travis-ci.com/libp2p/js-peer-id) | [![codecov](https://codecov.io/gh/libp2p/js-peer-id/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-peer-id) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
+| [`libp2p-record`](//github.com/libp2p/js-libp2p-record) | [![npm](https://img.shields.io/npm/v/libp2p-record.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-record/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-record.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-record) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-record/master)](https://travis-ci.com/libp2p/js-libp2p-record) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-record/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-record) | [Jacob Heun](mailto:santos.vasco10@gmail.com) |
 | **pubsub** |
 | [`libp2p-floodsub`](//github.com/libp2p/js-libp2p-floodsub) | [![npm](https://img.shields.io/npm/v/libp2p-floodsub.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-floodsub/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-floodsub.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-floodsub) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-floodsub/master)](https://travis-ci.com/libp2p/js-libp2p-floodsub) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-floodsub/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-floodsub) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
 | [`libp2p-gossipsub`](//github.com/ChainSafe/js-libp2p-gossipsub) | [![npm](https://img.shields.io/npm/v/libp2p-gossipsub.svg?maxAge=86400&style=flat-square)](//github.com/ChainSafe/js-libp2p-gossipsub/releases) | [![Deps](https://david-dm.org/ChainSafe/js-libp2p-gossipsub.svg?style=flat-square)](https://david-dm.org/ChainSafe/js-libp2p-gossipsub) | [![Travis CI](https://flat.badgen.net/travis/ChainSafe/js-libp2p-gossipsub/master)](https://travis-ci.com/ChainSafe/js-libp2p-gossipsub) | [![codecov](https://codecov.io/gh/ChainSafe/js-libp2p-gossipsub/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/ChainSafe/js-libp2p-gossipsub) | [Cayman Nava](mailto:caymannava@gmail.com) |

doc/API.md

@@ -2086,7 +2086,7 @@ the NatManager performing NAT hole punching.
 
 [address]: https://github.com/libp2p/js-libp2p/tree/master/src/peer-store/address-book.js
 [cid]: https://github.com/multiformats/js-cid
-[connection]: https://github.com/libp2p/js-interfaces/tree/master/src/connection
+[connection]: https://github.com/libp2p/js-libp2p-interfaces/tree/master/packages/interfaces/src/connection
 [multiaddr]: https://github.com/multiformats/js-multiaddr
 [peer-id]: https://github.com/libp2p/js-peer-id
 [keys]: https://github.com/libp2p/js-libp2p-crypto/tree/master/src/keys

doc/CONFIGURATION.md

@@ -1,37 +1,37 @@
-# Configuration
+#
 
-- [Configuration](#configuration)
-  - [Overview](#overview)
-  - [Modules](#modules)
-    - [Transport](#transport)
-    - [Stream Multiplexing](#stream-multiplexing)
-    - [Connection Encryption](#connection-encryption)
-    - [Peer Discovery](#peer-discovery)
-    - [Content Routing](#content-routing)
-    - [Peer Routing](#peer-routing)
-    - [DHT](#dht)
-    - [Pubsub](#pubsub)
-  - [Customizing libp2p](#customizing-libp2p)
-    - [Examples](#examples)
-      - [Basic setup](#basic-setup)
-      - [Customizing Peer Discovery](#customizing-peer-discovery)
-      - [Setup webrtc transport and discovery](#setup-webrtc-transport-and-discovery)
-      - [Customizing Pubsub](#customizing-pubsub)
-      - [Customizing DHT](#customizing-dht)
-      - [Setup with Content and Peer Routing](#setup-with-content-and-peer-routing)
-      - [Setup with Relay](#setup-with-relay)
-      - [Setup with Auto Relay](#setup-with-auto-relay)
-      - [Setup with Keychain](#setup-with-keychain)
-      - [Configuring Dialing](#configuring-dialing)
-      - [Configuring Connection Manager](#configuring-connection-manager)
-      - [Configuring Transport Manager](#configuring-transport-manager)
-      - [Configuring Metrics](#configuring-metrics)
-      - [Configuring PeerStore](#configuring-peerstore)
-      - [Customizing Transports](#customizing-transports)
-      - [Configuring the NAT Manager](#configuring-the-nat-manager)
-        - [Browser support](#browser-support)
-        - [UPnP and NAT-PMP](#upnp-and-nat-pmp)
-  - [Configuration examples](#configuration-examples)
+- [Overview](#overview)
+- [Modules](#modules)
+  - [Transport](#transport)
+  - [Stream Multiplexing](#stream-multiplexing)
+  - [Connection Encryption](#connection-encryption)
+  - [Peer Discovery](#peer-discovery)
+  - [Content Routing](#content-routing)
+  - [Peer Routing](#peer-routing)
+  - [DHT](#dht)
+  - [Pubsub](#pubsub)
+- [Customizing libp2p](#customizing-libp2p)
+  - [Examples](#examples)
+    - [Basic setup](#basic-setup)
+    - [Customizing Peer Discovery](#customizing-peer-discovery)
+    - [Setup webrtc transport and discovery](#setup-webrtc-transport-and-discovery)
+    - [Customizing Pubsub](#customizing-pubsub)
+    - [Customizing DHT](#customizing-dht)
+    - [Setup with Content and Peer Routing](#setup-with-content-and-peer-routing)
+    - [Setup with Relay](#setup-with-relay)
+    - [Setup with Auto Relay](#setup-with-auto-relay)
+    - [Setup with Keychain](#setup-with-keychain)
+    - [Configuring Dialing](#configuring-dialing)
+    - [Configuring Connection Manager](#configuring-connection-manager)
+    - [Configuring Transport Manager](#configuring-transport-manager)
+    - [Configuring Metrics](#configuring-metrics)
+    - [Configuring PeerStore](#configuring-peerstore)
+    - [Customizing Transports](#customizing-transports)
+    - [Configuring the NAT Manager](#configuring-the-nat-manager)
+      - [Browser support](#browser-support)
+      - [UPnP and NAT-PMP](#upnp-and-nat-pmp)
+    - [Configuring protocol name](#configuring-protocol-name)
+- [Configuration examples](#configuration-examples)
 
 ## Overview
 
@@ -210,7 +210,7 @@ const modules = {
 Moreover, the majority of the modules can be customized via option parameters. This way, it is also possible to provide this options through a `config` object. This config object should have the property name of each building block to configure, the same way as the modules specification.
 
 Besides the `modules` and `config`, libp2p allows other internal options and configurations:
-- `datastore`: an instance of [ipfs/interface-datastore](https://github.com/ipfs/interface-datastore/) modules.
+- `datastore`: an instance of [ipfs/interface-datastore](https://github.com/ipfs/js-ipfs-interfaces/tree/master/packages/interface-datastore) modules.
   - This is used in modules such as the DHT. If it is not provided, `js-libp2p` will use an in memory datastore.
 - `peerId`: the identity of the node, an instance of [libp2p/js-peer-id](https://github.com/libp2p/js-peer-id).
   - This is particularly useful if you want to reuse the same `peer-id`, as well as for modules like `libp2p-delegated-content-routing`, which need a `peer-id` in their instantiation.
@@ -282,7 +282,7 @@ const node = await Libp2p.create({
         interval: 1000,
         enabled: true
       },
-      [Bootstrap.tag:] {
+      [Bootstrap.tag]: {
         list: [ // A list of bootstrap peers to connect to starting up the node
           "/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
           "/dnsaddr/bootstrap.libp2p.io/ipfs/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN",
@@ -373,12 +373,8 @@ const node = await Libp2p.create({
   config: {
     dht: {                        // The DHT options (and defaults) can be found in its documentation
       kBucketSize: 20,
-      enabled: true,
-      randomWalk: {
-        enabled: true,            // Allows to disable discovery (enabled by default)
-        interval: 300e3,
-        timeout: 10e3
-      }
+      enabled: true,              // This flag is required for DHT to run (disabled by default)
+      clientMode: false           // Whether to run the WAN DHT in client or server mode (default: client mode)
     }
   }
 })
@@ -399,13 +395,13 @@ const PeerId = require('peer-id')
 // create a peerId
 const peerId = await PeerId.create()
 
-const delegatedPeerRouting = new DelegatedPeerRouter(ipfsHttpClient({
+const delegatedPeerRouting = new DelegatedPeerRouter(ipfsHttpClient.create({
   host: 'node0.delegate.ipfs.io', // In production you should setup your own delegates
   protocol: 'https',
   port: 443
 }))
 
-const delegatedContentRouting = new DelegatedContentRouter(peerId, ipfsHttpClient({
+const delegatedContentRouting = new DelegatedContentRouter(peerId, ipfsHttpClient.create({
   host: 'node0.delegate.ipfs.io', // In production you should setup your own delegates
   protocol: 'https',
   port: 443
@@ -419,14 +415,7 @@ const node = await Libp2p.create({
     contentRouting: [delegatedContentRouting],
     peerRouting: [delegatedPeerRouting],
   },
-  peerId,
-  peerRouting: { // Peer routing configuration
-    refreshManager: { // Refresh known and connected closest peers
-      enabled: true, // Should find the closest peers.
-      interval: 6e5, // Interval for getting the new for closest peers of 10min
-      bootDelay: 10e3 // Delay for the initial query for closest peers
-    }
-  }
+  peerId
 })
 ```
 
@@ -503,6 +492,9 @@ const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
 const LevelStore = require('datastore-level')
 
+const datastore = new LevelStore('path/to/store')
+await datastore.open()
+
 const node = await Libp2p.create({
   modules: {
     transport: [TCP],
@@ -511,11 +503,11 @@ const node = await Libp2p.create({
   },
   keychain: {
     pass: 'notsafepassword123456789',
-    datastore: new LevelStore('path/to/store')
+    datastore: dsInstant,
   }
 })
 
-await libp2p.loadKeychain()
+await node.loadKeychain()
 ```
 
 #### Configuring Dialing
@@ -525,6 +517,7 @@ Dialing in libp2p can be configured to limit the rate of dialing, and how long d
 | Name | Type | Description |
 |------|------|-------------|
 | maxParallelDials | `number` | How many multiaddrs we can dial in parallel. |
+| maxAddrsToDial | `number` | How many multiaddrs is the dial allowed to dial for a single peer. |
 | maxDialsPerPeer | `number` | How many multiaddrs we can dial per peer, in parallel. |
 | dialTimeout | `number` | Second dial timeout per peer in ms. |
 | resolvers | `object` | Dial [Resolvers](https://github.com/multiformats/js-multiaddr/blob/master/src/resolvers/index.js) for resolving multiaddrs |
@@ -549,6 +542,7 @@ const node = await Libp2p.create({
   },
   dialer: {
     maxParallelDials: 100,
+    maxAddrsToDial: 25,
     maxDialsPerPeer: 4,
     dialTimeout: 30e3,
     resolvers: {
@@ -671,16 +665,18 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
-
 const LevelStore = require('datastore-level')
 
+const datastore = new LevelStore('path/to/store')
+const dsInstant = await datastore.open()
+
 const node = await Libp2p.create({
   modules: {
     transport: [TCP],
     streamMuxer: [MPLEX],
     connEncryption: [NOISE]
   },
-  datastore: new LevelStore('path/to/store'),
+  datastore: dsInstant,
   peerStore: {
     persistence: true,
     threshold: 5
@@ -779,6 +775,26 @@ By default under nodejs libp2p will attempt to use [UPnP](https://en.wikipedia.o
 
 [NAT-PMP](http://miniupnp.free.fr/nat-pmp.html) is a feature of some modern routers which performs a similar job to UPnP. NAT-PMP is disabled by default, if enabled libp2p will try to use NAT-PMP and will fall back to UPnP if it fails.
 
+#### Configuring protocol name
+
+Changing the protocol name prefix can isolate default public network (IPFS) for custom purposes.
+
+```js
+const node = await Libp2p.create({
+  config: {
+    protocolPrefix: 'ipfs' // default
+  }
+})
+/*
+protocols: [
+  "/ipfs/id/1.0.0", // identify service protocol (if we have multiplexers)
+  "/ipfs/id/push/1.0.0", // identify service push protocol (if we have multiplexers)
+  "/ipfs/ping/1.0.0", // built-in ping protocol
+]
+*/
+```
+
+
 ## Configuration examples
 
 As libp2p is designed to be a modular networking library, its usage will vary based on individual project needs. We've included links to some existing project configurations for your reference, in case you wish to replicate their configuration:

doc/migrations/v0.31-v0.32.md

@@ -0,0 +1,36 @@
+<!--Specify versions for migration below-->
+# Migrating to libp2p@32
+
+A migration guide for refactoring your application code from libp2p v0.31.x to v0.32.0.
+
+## Table of Contents
+
+- [Module Updates](#module-updates)
+
+## Module Updates
+
+With this release you should update the following libp2p modules if you are relying on them:
+
+<!--Specify module versions in JSON for migration below.
+It's recommended to check package.json changes for this: 
+`git diff <release> <prev> -- package.json`
+-->
+
+```json
+"libp2p-bootstrap": "^0.13.0",
+"libp2p-crypto": "^0.19.4",
+"libp2p-interfaces": "^1.0.0",
+"libp2p-delegated-content-routing": "^0.11.0",
+"libp2p-delegated-peer-routing": "^0.10.0",
+"libp2p-floodsub": "^0.27.0",
+"libp2p-gossipsub": "^0.11.0",
+"libp2p-kad-dht": "^0.23.0",
+"libp2p-mdns": "^0.17.0",
+"libp2p-noise": "^4.0.0",
+"libp2p-tcp": "^0.17.0",
+"libp2p-webrtc-direct": "^0.7.0",
+"libp2p-webrtc-star": "^0.23.0",
+"libp2p-websockets": "^0.16.0"
+```
+
+One of the main changes in this new release is the update to `multiaddr@10.0.0`. This should also be updated in upstream projects to avoid several multiaddr versions in the bundle and to avoid potential problems when libp2p interacts with provided outdated multiaddr instances.

doc/migrations/v0.32-v0.33.md

@@ -0,0 +1,14 @@
+<!--Specify versions for migration below-->
+# Migrating to libp2p@33
+
+A migration guide for refactoring your application code from libp2p v0.32.x to v0.33.0.
+
+## Table of Contents
+
+- [Module Updates](#module-updates)
+
+## Module Updates
+
+Libp2p uses a datastore implementation for Peerstore persistence and for the DHT state. While libp2p defaults to a datastore implementation, it can receive any implementation of a datastore compliant with the [interface-datastore](https://github.com/ipfs/js-ipfs-interfaces/tree/master/packages/interface-datastore) via its configuration.
+
+In this release, we updated to `interface-datastore@6.0.0`. As a result, libp2p users relying on a configured datastore should update it to a compliant implementation for updating libp2p.

examples/auto-relay/README.md

@@ -18,7 +18,7 @@ The relay node will need to have its relay subsystem enabled, as well as its HOP
 ```js
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 const node = await Libp2p.create({
@@ -76,7 +76,7 @@ One of the typical use cases for Auto Relay is nodes behind a NAT or browser nod
 ```js
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 const relayAddr = process.argv[2]
@@ -125,7 +125,7 @@ As you can see in the code, we need to provide the relay address, `relayAddr`, a
 You should now run the following to start the node running Auto Relay:
 
 ```sh
-node listener.js /ip4/192.168.1.120/tcp/58941/ws/p2p/QmQKCBm87HQMbFqy14oqC85pMmnRrj6iD46ggM6reqNpsd
+node listener.js /ip4/192.168.1.120/tcp/61592/ws/p2p/QmWDn2LY8nannvSWJzruUYoLZ4vV83vfCBwd8DipvdgQc3
 ```
 
 This should print out something similar to the following:
@@ -147,7 +147,7 @@ Now that you have a relay node and a node bound to that relay, you can test conn
 ```js
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 const autoRelayNodeAddr = process.argv[2]
@@ -173,7 +173,7 @@ console.log(`Connected to the auto relay node via ${conn.remoteAddr.toString()}`
 You should now run the following to start the relay node using the listen address from step 2:
 
 ```sh
-node dialer.js /ip4/192.168.1.120/tcp/58941/ws/p2p/QmQKCBm87HQMbFqy14oqC85pMmnRrj6iD46ggM6reqNpsd
+node dialer.js /ip4/192.168.1.120/tcp/61592/ws/p2p/QmWDn2LY8nannvSWJzruUYoLZ4vV83vfCBwd8DipvdgQc3
 ```
 
 Once you start your test node, it should print out something similar to the following:

examples/auto-relay/dialer.js

@@ -2,7 +2,7 @@
 
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 async function main () {

examples/auto-relay/listener.js

@@ -2,7 +2,7 @@
 
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 async function main () {

examples/auto-relay/relay.js

@@ -2,7 +2,7 @@
 
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 async function main () {

examples/auto-relay/test.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 function startProcess (name, args = []) {
   return execa('node', [path.join(__dirname, name), ...args], {

examples/chat/src/dialer.js

@@ -2,11 +2,11 @@
 /* eslint-disable no-console */
 
 const PeerId = require('peer-id')
-const multiaddr = require('multiaddr')
+const { Multiaddr } = require('multiaddr')
 const createLibp2p = require('./libp2p')
 const { stdinToStream, streamToConsole } = require('./stream')
 
-async function run() {
+async function run () {
   const [idDialer, idListener] = await Promise.all([
     PeerId.createFromJSON(require('./peer-id-dialer')),
     PeerId.createFromJSON(require('./peer-id-listener'))
@@ -30,7 +30,7 @@ async function run() {
   })
 
   // Dial to the remote peer (the "listener")
-  const listenerMa = multiaddr(`/ip4/127.0.0.1/tcp/10333/p2p/${idListener.toB58String()}`)
+  const listenerMa = new Multiaddr(`/ip4/127.0.0.1/tcp/10333/p2p/${idListener.toB58String()}`)
   const { stream } = await nodeDialer.dialProtocol(listenerMa, '/chat/1.0.0')
 
   console.log('Dialer dialed to listener on protocol: /chat/1.0.0')

examples/chat/src/libp2p.js

@@ -3,7 +3,7 @@
 const TCP = require('libp2p-tcp')
 const WS = require('libp2p-websockets')
 const mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const defaultsDeep = require('@nodeutils/defaults-deep')
 const libp2p = require('../../..')
 

examples/chat/src/listener.js

@@ -5,7 +5,7 @@ const PeerId = require('peer-id')
 const createLibp2p = require('./libp2p.js')
 const { stdinToStream, streamToConsole } = require('./stream')
 
-async function run() {
+async function run () {
   // Create a new libp2p node with the given multi-address
   const idListener = await PeerId.createFromJSON(require('./peer-id-listener'))
   const nodeListener = await createLibp2p({

examples/chat/test.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 function startProcess(name) {
   return execa('node', [path.join(__dirname, name)], {

examples/connection-encryption/1.js

@@ -3,7 +3,7 @@
 const Libp2p = require('../..')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const pipe = require('it-pipe')
 

examples/connection-encryption/README.md

@@ -8,13 +8,13 @@ A byproduct of having these encrypted communications modules is that we can auth
 
 # 1. Set up encrypted communications
 
-We will build this example on top of example for [Protocol and Stream Multiplexing](../protocol-and-stream-multiplexing). You will need the `libp2p-noise` module to complete it, go ahead and `npm install libp2p-noise`.
+We will build this example on top of example for [Protocol and Stream Multiplexing](../protocol-and-stream-multiplexing). You will need the `@chainsafe/libp2p-noise` module to complete it, go ahead and `npm install @chainsafe/libp2p-noise`.
 
 To add them to your libp2p configuration, all you have to do is:
 
 ```JavaScript
 const Libp2p = require('libp2p')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const createNode = () => {
   return Libp2p.create({

examples/connection-encryption/test.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test () {
   const messageReceived = pDefer()

examples/delegated-routing/package.json

@@ -7,7 +7,7 @@
     "libp2p": "github:libp2p/js-libp2p#master",
     "libp2p-delegated-content-routing": "~0.2.2",
     "libp2p-delegated-peer-routing": "~0.2.2",
-    "libp2p-kad-dht": "~0.14.12",
+    "libp2p-kad-dht": "^0.26.5",
     "libp2p-mplex": "~0.8.5",
     "libp2p-secio": "~0.11.1",
     "libp2p-webrtc-star": "~0.15.8",

examples/discovery-mechanisms/1.js

@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const Bootstrap = require('libp2p-bootstrap')
 
 const bootstrapers = require('./bootstrapers')

examples/discovery-mechanisms/2.js

@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MulticastDNS = require('libp2p-mdns')
 
 const createNode = async () => {

examples/discovery-mechanisms/3.js

@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const Gossipsub = require('libp2p-gossipsub')
 const Bootstrap = require('libp2p-bootstrap')
 const PubsubPeerDiscovery = require('libp2p-pubsub-peer-discovery')

examples/discovery-mechanisms/README.md

@@ -55,7 +55,7 @@ const node = await Libp2p.create({
   peerId,
   addresses: {
     listen: ['/ip4/0.0.0.0/tcp/0']
-  }
+  },
   modules: {
     transport: [ TCP ],
     streamMuxer: [ Mplex ],
@@ -117,7 +117,7 @@ const createNode = () => {
   return Libp2p.create({
     addresses: {
       listen: ['/ip4/0.0.0.0/tcp/0']
-    }
+    },
     modules: {
       transport: [ TCP ],
       streamMuxer: [ Mplex ],
@@ -144,8 +144,13 @@ const [node1, node2] = await Promise.all([
   createNode()
 ])
 
-node1.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String()))
-node2.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String()))
+node1.on('peer:discovery', (peer) => console.log('Discovered:', peerId.toB58String()))
+node2.on('peer:discovery', (peer) => console.log('Discovered:', peerId.toB58String()))
+
+await Promise.all([
+  node1.start(),
+  node2.start()
+])
 ```
 
 If you run this example, you will see the other peers being discovered.
@@ -168,7 +173,7 @@ You can create your libp2p nodes as follows:
 const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const Gossipsub = require('libp2p-gossipsub')
 const Bootstrap = require('libp2p-bootstrap')
 const PubsubPeerDiscovery = require('libp2p-pubsub-peer-discovery')

examples/discovery-mechanisms/test-1.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pWaitFor = require('p-wait-for')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 const bootstrapers = require('./bootstrapers')
 
 const discoveredCopy = 'Discovered:'

examples/discovery-mechanisms/test-2.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pWaitFor = require('p-wait-for')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 const discoveredCopy = 'Discovered:'
 

examples/discovery-mechanisms/test-3.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pWaitFor = require('p-wait-for')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 const discoveredCopy = 'discovered:'
 

examples/echo/src/libp2p.js

@@ -3,7 +3,7 @@
 const TCP = require('libp2p-tcp')
 const WS = require('libp2p-websockets')
 const mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const defaultsDeep = require('@nodeutils/defaults-deep')
 const libp2p = require('../../..')

examples/echo/test.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 function startProcess(name) {
   return execa('node', [path.join(__dirname, name)], {

examples/libp2p-in-the-browser/index.html

@@ -16,7 +16,7 @@
       <pre id="output"></pre>
     </main>
 
-    <script src="./index.js"></script>
+    <script type="module" src="./index.js"></script>
 
   </body>
 

examples/libp2p-in-the-browser/index.js

@@ -2,7 +2,7 @@ import 'babel-polyfill'
 import Libp2p from 'libp2p'
 import Websockets from 'libp2p-websockets'
 import WebRTCStar from 'libp2p-webrtc-star'
-import { NOISE } from 'libp2p-noise'
+import { NOISE } from '@chainsafe/libp2p-noise'
 import Mplex from 'libp2p-mplex'
 import Bootstrap from 'libp2p-bootstrap'
 

examples/libp2p-in-the-browser/package.json

@@ -2,7 +2,6 @@
   "name": "libp2p-in-browser",
   "version": "1.0.0",
   "description": "A libp2p node running in the browser",
-  "main": "dist/index.html",
   "browserslist": [
     "last 2 Chrome versions"
   ],
@@ -17,11 +16,11 @@
   "dependencies": {
     "@babel/preset-env": "^7.13.0",
     "libp2p": "../../",
-    "libp2p-bootstrap": "^0.12.1",
-    "libp2p-mplex": "^0.10.0",
-    "libp2p-noise": "^2.0.0",
-    "libp2p-webrtc-star": "^0.22.0",
-    "libp2p-websockets": "^0.15.0"
+    "libp2p-bootstrap": "^0.13.0",
+    "libp2p-mplex": "^0.10.4",
+    "@chainsafe/libp2p-noise": "^4.1.0",
+    "libp2p-webrtc-star": "^0.23.0",
+    "libp2p-websockets": "^0.16.1"
   },
   "devDependencies": {
     "@babel/cli": "^7.13.10",
@@ -29,6 +28,6 @@
     "babel-plugin-syntax-async-functions": "^6.13.0",
     "babel-plugin-transform-regenerator": "^6.26.0",
     "babel-polyfill": "^6.26.0",
-    "parcel": "next"
+    "parcel": "^2.0.1"
   }
 }

examples/libp2p-in-the-browser/test.js

@@ -38,7 +38,7 @@ async function run() {
         )
         await browser.close();
 
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
         console.error(err)
         process.exit(1)
       } finally {

examples/package.json

@@ -10,12 +10,16 @@
   "dependencies": {
     "execa": "^2.1.0",
     "fs-extra": "^8.1.0",
-    "libp2p-pubsub-peer-discovery": "^3.0.0",
-    "libp2p-relay-server": "^0.1.2",
+    "libp2p": "../src",
+    "libp2p-pubsub-peer-discovery": "^4.0.0",
+    "libp2p-relay-server": "^0.3.0",
+    "libp2p-gossipsub": "^0.11.0",
     "p-defer": "^3.0.0",
+    "uint8arrays": "^3.0.0",
     "which": "^2.0.1"
   },
   "devDependencies": {
+    "https": "^1.0.0",
     "playwright": "^1.7.1"
   }
 }

examples/peer-and-content-routing/1.js

@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const KadDHT = require('libp2p-kad-dht')
 
 const delay = require('delay')

examples/peer-and-content-routing/2.js

@@ -4,8 +4,8 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
-const CID = require('cids')
+const { NOISE } = require('@chainsafe/libp2p-noise')
+const { CID } = require('multiformats/cid')
 const KadDHT = require('libp2p-kad-dht')
 
 const all = require('it-all')
@@ -51,10 +51,10 @@ const createNode = async () => {
   // Wait for onConnect handlers in the DHT
   await delay(100)
 
-  const cid = new CID('QmTp9VkYvnHyrqKQuFPiuZkiX9gPcqj6x5LJ1rmWuSySnL')
+  const cid = CID.parse('QmTp9VkYvnHyrqKQuFPiuZkiX9gPcqj6x5LJ1rmWuSySnL')
   await node1.contentRouting.provide(cid)
 
-  console.log('Node %s is providing %s', node1.peerId.toB58String(), cid.toBaseEncodedString())
+  console.log('Node %s is providing %s', node1.peerId.toB58String(), cid.toString())
 
   // wait for propagation
   await delay(300)

examples/peer-and-content-routing/README.md

@@ -81,7 +81,7 @@ Instead of calling `peerRouting.findPeer`, we will use `contentRouting.provide`
 
 ```JavaScript
 await node1.contentRouting.provide(cid)
-console.log('Node %s is providing %s', node1.peerId.toB58String(), cid.toBaseEncodedString())
+console.log('Node %s is providing %s', node1.peerId.toB58String(), cid.toString())
 
 const provs = await all(node3.contentRouting.findProviders(cid, { timeout: 5000 }))
 

examples/peer-and-content-routing/test-1.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pWaitFor = require('p-wait-for')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test() {
   process.stdout.write('1.js\n')

examples/peer-and-content-routing/test-2.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 const providedCopy = 'is providing'
 const foundCopy = 'Found provider:'

examples/pnet/libp2p-node.js

@@ -3,7 +3,7 @@
 const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const Protector = require('libp2p/src/pnet')
 
 /**

examples/pnet/test.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test () {
   const messageReceived = pDefer()

examples/protocol-and-stream-muxing/1.js

@@ -3,7 +3,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const pipe = require('it-pipe')
 

examples/protocol-and-stream-muxing/2.js

@@ -3,7 +3,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const pipe = require('it-pipe')
 

examples/protocol-and-stream-muxing/3.js

@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const pipe = require('it-pipe')
 

examples/protocol-and-stream-muxing/test-1.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test() {
   const messageDefer = pDefer()

examples/protocol-and-stream-muxing/test-2.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pWaitFor = require('p-wait-for')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 const messages = [
   'protocol (a)',

examples/protocol-and-stream-muxing/test-3.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pWaitFor = require('p-wait-for')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 const messages = [
   'from 1 to 2',

examples/pubsub/1.js

@@ -4,10 +4,10 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const Gossipsub = require('libp2p-gossipsub')
-const uint8ArrayFromString = require('uint8arrays/from-string')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 const createNode = async () => {
   const node = await Libp2p.create({

examples/pubsub/README.md

@@ -8,6 +8,10 @@ We've seen many interesting use cases appear with this, here are some highlights
 - [IPFS PubSub (using libp2p-floodsub) for IoT](https://www.youtube.com/watch?v=qLpM5pBDGiE).
 - [Real Time distributed Applications](https://www.youtube.com/watch?v=vQrbxyDPSXg)
 
+## 0. Set up the example
+
+Before moving into the examples, you should run `npm install` on the top level `js-libp2p` folder, in order to install all the dependencies needed for this example. In addition, you will need to install the example related dependencies by doing `cd examples && npm install`. Once the install finishes, you should move into the example folder with `cd pubsub`.
+
 ## 1. Setting up a simple PubSub network on top of libp2p
 
 For this example, we will use MulticastDNS for automatic Peer Discovery. This example is based the previous examples found in [Discovery Mechanisms](../discovery-mechanisms). You can find the complete version at [1.js](./1.js).

examples/pubsub/message-filtering/1.js

@@ -4,10 +4,10 @@
 const Libp2p = require('../../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const Gossipsub = require('libp2p-gossipsub')
-const uint8ArrayFromString = require('uint8arrays/from-string')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 const createNode = async () => {
   const node = await Libp2p.create({

examples/pubsub/message-filtering/test.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 const stdout = [
   {

examples/pubsub/test-1.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test () {
   const defer = pDefer()

examples/transports/1.js

@@ -3,7 +3,7 @@
 
 const Libp2p = require('../..')
 const TCP = require('libp2p-tcp')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const createNode = async () => {
   const node = await Libp2p.create({

examples/transports/2.js

@@ -3,7 +3,7 @@
 
 const Libp2p = require('../..')
 const TCP = require('libp2p-tcp')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 const pipe = require('it-pipe')

examples/transports/3.js

@@ -4,7 +4,7 @@
 const Libp2p = require('../..')
 const TCP = require('libp2p-tcp')
 const WebSockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 const pipe = require('it-pipe')
@@ -81,7 +81,7 @@ function print ({ stream }) {
   // node 3 (listening WebSockets) can dial node 1 (TCP)
   try {
     await node3.dialProtocol(node1.peerId, '/print')
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     console.log('node 3 failed to dial to node 1 with:', err.message)
   }
 })();

examples/transports/4.js

@@ -0,0 +1,89 @@
+/* eslint-disable no-console */
+'use strict'
+
+const Libp2p = require('../..')
+const TCP = require('libp2p-tcp')
+const WebSockets = require('libp2p-websockets')
+const { NOISE } = require('@chainsafe/libp2p-noise')
+const MPLEX = require('libp2p-mplex')
+
+const fs = require('fs');
+const https = require('https');
+const pipe = require('it-pipe')
+
+const transportKey = WebSockets.prototype[Symbol.toStringTag];
+
+const httpServer = https.createServer({
+  cert: fs.readFileSync('./test_certs/cert.pem'),
+  key: fs.readFileSync('./test_certs/key.pem'),
+});
+
+const createNode = async (addresses = []) => {
+  if (!Array.isArray(addresses)) {
+    addresses = [addresses]
+  }
+
+  const node = await Libp2p.create({
+    addresses: {
+      listen: addresses
+    },
+    modules: {
+      transport: [WebSockets],
+      connEncryption: [NOISE],
+      streamMuxer: [MPLEX]
+    },
+    config: {
+      peerDiscovery: {
+        // Disable autoDial as it would fail because we are using a self-signed cert.
+        // `dialProtocol` does not fail because we pass `rejectUnauthorized: false`.
+        autoDial: false
+      },
+      transport: {
+        [transportKey]: {
+          listenerOptions: { server: httpServer },
+        },
+      },
+    }
+  })
+
+  await node.start()
+  return node
+}
+
+function printAddrs(node, number) {
+  console.log('node %s is listening on:', number)
+  node.multiaddrs.forEach((ma) => console.log(`${ma.toString()}/p2p/${node.peerId.toB58String()}`))
+}
+
+function print ({ stream }) {
+  pipe(
+    stream,
+    async function (source) {
+      for await (const msg of source) {
+        console.log(msg.toString())
+      }
+    }
+  )
+}
+
+;(async () => {
+  const [node1, node2] = await Promise.all([
+    createNode('/ip4/127.0.0.1/tcp/10000/wss'),
+    createNode([])
+  ])
+
+  printAddrs(node1, '1')
+  printAddrs(node2, '2')
+
+  node1.handle('/print', print)
+  node2.handle('/print', print)
+
+  const targetAddr = `${node1.multiaddrs[0]}/p2p/${node1.peerId.toB58String()}`;
+
+  // node 2 (Secure WebSockets) dials to node 1 (Secure Websockets)
+  const { stream } = await node2.dialProtocol(targetAddr, '/print',  { websocket: { rejectUnauthorized: false } })
+  await pipe(
+    ['node 2 dialed to node 1 successfully'],
+    stream
+  )
+})();

examples/transports/README.md

@@ -13,7 +13,7 @@ When using libp2p, you need properly configure it, that is, pick your set of mod
 You will need 4 dependencies total, so go ahead and install all of them with:
 
 ```bash
-> npm install libp2p libp2p-tcp libp2p-noise
+> npm install libp2p libp2p-tcp @chainsafe/libp2p-noise
 ```
 
 Then, in your favorite text editor create a file with the `.js` extension. I've called mine `1.js`.
@@ -25,7 +25,7 @@ First thing is to create our own libp2p node! Insert:
 
 const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const createNode = async () => {
   const node = await Libp2p.create({
@@ -91,7 +91,7 @@ const concat = require('it-concat')
 const MPLEX = require('libp2p-mplex')
 ```
 
-We are going to reuse the `createNode` function from step 1, but this time add a stream multiplexer from `libp2p-mplex`. 
+We are going to reuse the `createNode` function from step 1, but this time add a stream multiplexer from `libp2p-mplex`.
 ```js
 const createNode = async () => {
   const node = await Libp2p.create({

examples/transports/test-1.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test () {
   const deferStarted = pDefer()

examples/transports/test-2.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test () {
   const defer = pDefer()

examples/transports/test-3.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test () {
   const deferNode1 = pDefer()

examples/transports/test-4.js

@@ -0,0 +1,33 @@
+'use strict'
+
+const path = require('path')
+const execa = require('execa')
+const pDefer = require('p-defer')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
+
+async function test () {
+  const deferNode1 = pDefer()
+
+  process.stdout.write('4.js\n')
+
+  const proc = execa('node', [path.join(__dirname, '4.js')], {
+    cwd: path.resolve(__dirname),
+    all: true
+  })
+
+  proc.all.on('data', async (data) => {
+    process.stdout.write(data)
+    const line = uint8ArrayToString(data)
+
+    if (line.includes('node 2 dialed to node 1 successfully')) {
+      deferNode1.resolve()
+    }
+  })
+
+  await Promise.all([
+    deferNode1.promise,
+  ])
+  proc.kill()
+}
+
+module.exports = test

examples/transports/test.js

@@ -3,11 +3,13 @@
 const test1 = require('./test-1')
 const test2 = require('./test-2')
 const test3 = require('./test-3')
+const test4 = require('./test-4')
 
 async function test() {
   await test1()
   await test2()
   await test3()
+  await test4()
 }
 
 module.exports = test

examples/transports/test_certs/cert.pem

@@ -0,0 +1,32 @@
+-----BEGIN CERTIFICATE-----
+MIIFlzCCA3+gAwIBAgIUMYedwb9L/BtvZ7Lhu71iSKrXsa4wDQYJKoZIhvcNAQEL
+BQAwajELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlZBMREwDwYDVQQHDAhTb21lQ2l0
+eTESMBAGA1UECgwJTXlDb21wYW55MRMwEQYDVQQLDApNeURpdmlzaW9uMRIwEAYD
+VQQDDAkxMjcuMC4wLjEwHhcNMjEwNDI4MDIzMjA5WhcNMjIwNDI4MDIzMjA5WjBq
+MQswCQYDVQQGEwJVUzELMAkGA1UECAwCVkExETAPBgNVBAcMCFNvbWVDaXR5MRIw
+EAYDVQQKDAlNeUNvbXBhbnkxEzARBgNVBAsMCk15RGl2aXNpb24xEjAQBgNVBAMM
+CTEyNy4wLjAuMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANNhXBu0
+GH1Kzl9iaQxCxEnyyAShS5FYScdKxqpYsgJT4poLWLQBZQEFLEqbdillIlTZqMss
+jWqkFL2xmjqdcnOKFEZUarntVE2hxFYYQex2Fi8MYwFj+Pvt74d02xPyfzFNFgyX
+a1EakoGBwClaf3I7jW7raPudjcf4HnwQ7r/NwiO8FqHFZgLcTnwI8bk+cxDoDAqu
+mhqMB5nnerqvKEyR9Fb2PoL+8PwOPJOOKTDVwLMeMJu2WLR8AU2FzOj5SVI2qsu9
+Ps5azysD8KQAMcw4y9s6do36SaMQS85fbvXBV7XBqMD34HPBUbFiCoFoaCzK9Zfb
+pCXyVJMUNmw5hyq9nbjUt4Kvr/58bU2gjUKSdPf6KhBxFnDZwl+2qqPdVIb/qtwz
+HExtJWq3upklXNOg3HoR6vcr1O9ReJHrzLRMEb51WP1aN/qJ2/lRskcZ4A806qwr
+W67BvnOg6s3ZtxHN9v3bsyfsvC66w8PEfCnCVxugC7cUW0gtW54AU75T3ukg7X+m
+vECr/+qIzNEBIxxCPgefCG/JAdJhQ5SCvoARAVPStUIWDmigDeOt7go5nKbdVIJ4
+7bbBFUhHT2mTHu30fHhRqSDcHzwE7Zz6YJIJmKq29UmzUazFnKlLU67MjLJwiDPm
+fC3GyOdAWkkZE5hjtkiy+3yWoEHhaJYRI1u3AgMBAAGjNTAzMAsGA1UdDwQEAwIE
+MDATBgNVHSUEDDAKBggrBgEFBQcDATAPBgNVHREECDAGhwR/AAABMA0GCSqGSIb3
+DQEBCwUAA4ICAQCx/ynu4iCQAK8VId/QQe7GqgOpFgx+6Mce9GQC6ZVEjAPgapsS
+Pl+l6+11cFjHKv0+Z/iN2JgkFmNXfwJcfYI0tHbMK+0U9hgKb1eFgiIwCqb4cPOz
+wMwusZ95BjIbtcEbL/+pMUpNhmjPz1fOILJZtDVq++lqJCv7t8+SoAmMVYtlcLNg
+muuV/UYR3uqvnAJmjgJVWs4otDGrxCYJE48M+9L2Gm05Htpi9WL1bZaQ+fJ85m85
+daedLc6R1/ZRTIH6i73sD4rYs0bx1fCJvkbcgXtKMHEkiHuG/MzR7Pa4cJAVKCx9
+lRTgrO7Gkllt2+jp4qg0YhdNq89e0DNA5cyB9H4udRgHQOcrlVRiX9OD/Kz+F5m/
+fQwMdbnqdg3ar5DSa8Q5g3bdLbNSCcI9sjCLTkNxUC/XTWGdG03RCVIt1qvBvZHk
+JaG6xGpbRZ5CN0T9eindd38JBrkPAPfgl6qhwvcqh6uVFYua+7KmF9K+mKarlmMw
+6RWaw2j4sMgUyRIS6fR9vDc20SrtoNvKQM1U6+0VYs1nizfkmsqqqRODmERKbKwc
+ahKJFubXfr8gz+PipAKFZbxr2EPAyoiNkx+0eM6Eedo55oP2BoGHEfXEoAonyMFM
+F/xTbpFtdRYE2hwsZCk86fpbcPTmdCY8txeZ7+4Bme2d9XXsTAxF64usqQ==
+-----END CERTIFICATE-----

examples/transports/test_certs/key.pem

@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----

examples/utils.js

@@ -9,7 +9,7 @@ async function isExecutable (command) {
     await fs.access(command, fs.constants.X_OK)
 
     return true
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     if (err.code === 'ENOENT') {
       return isExecutable(await which(command))
     }
@@ -49,7 +49,7 @@ async function waitForOutput (expectedOutput, command, args = [], opts = {}) {
 
   try {
     await proc
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     if (!err.killed) {
       throw err
     }

examples/webrtc-direct/dialer.js

@@ -2,7 +2,7 @@ import 'babel-polyfill'
 const Libp2p = require('libp2p')
 const WebRTCDirect = require('libp2p-webrtc-direct')
 const Mplex = require('libp2p-mplex')
-const {NOISE} = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const Bootstrap = require('libp2p-bootstrap')
 
 document.addEventListener('DOMContentLoaded', async () => {

examples/webrtc-direct/index.html

@@ -12,6 +12,6 @@
   <main>
     <pre id="output"></pre>
   </main>
-  <script src="./dialer.js"></script>
+  <script src="./dialer.js" type="module"></script>
 </body>
 </html>

examples/webrtc-direct/listener.js

@@ -2,7 +2,7 @@ const Libp2p = require('libp2p')
 const Bootstrap = require('libp2p-bootstrap')
 const WebRTCDirect = require('libp2p-webrtc-direct')
 const Mplex = require('libp2p-mplex')
-const {NOISE} = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const PeerId = require('peer-id')
 
 ;(async () => {

examples/webrtc-direct/package.json

@@ -3,7 +3,6 @@
   "version": "0.0.1",
   "private": true,
   "description": "",
-  "main": "dist/index.html",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
     "build": "parcel build index.html",
@@ -16,16 +15,16 @@
     "babel-plugin-syntax-async-functions": "^6.13.0",
     "babel-plugin-transform-regenerator": "^6.26.0",
     "babel-polyfill": "^6.26.0",
-    "parcel-bundler": "1.12.3",
+    "parcel": "^2.0.1",
     "util": "^0.12.3"
   },
   "dependencies": {
     "libp2p": "../../",
-    "libp2p-bootstrap": "^0.12.1",
-    "libp2p-mplex": "^0.10.1",
-    "libp2p-noise": "^2.0.1",
-    "libp2p-webrtc-direct": "^0.6.0",
-    "peer-id": "^0.14.3"
+    "libp2p-bootstrap": "^0.13.0",
+    "libp2p-mplex": "^0.10.4",
+    "@chainsafe/libp2p-noise": "^4.1.0",
+    "libp2p-webrtc-direct": "^0.7.0",
+    "peer-id": "^0.16.0"
   },
   "browser": {
     "ipfs": "ipfs/dist/index.min.js"

examples/webrtc-direct/test.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 const { chromium } = require('playwright');
 
 function startNode (name, args = []) {
@@ -72,7 +72,7 @@ async function test () {
                   { timeout: 10000 }
                 )
                 await browser.close();
-            } catch (err) {
+            } catch (/** @type {any} */ err) {
                 console.error(err)
                 process.exit(1)
             } finally {

package-list.json

@@ -44,10 +44,10 @@
 
     "utilities",
     ["libp2p/js-libp2p-crypto", "libp2p-crypto"],
-    ["libp2p/js-libp2p-crypto-secp256k1", "libp2p-crypto-secp256k1"],
 
     "data types",
     ["libp2p/js-peer-id", "peer-id"],
+    ["libp2p/js-libp2p-record", "libp2p-record"],
 
     "pubsub",
     ["libp2p/js-libp2p-floodsub", "libp2p-floodsub"],

package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "0.31.2",
+  "version": "0.35.1",
   "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
   "leadMaintainer": "Jacob Heun <jacobheun@gmail.com>",
   "main": "src/index.js",
@@ -41,6 +41,7 @@
     "test:node": "aegir test -t node -f \"./test/**/*.{node,spec}.js\"",
     "test:browser": "aegir test -t browser",
     "test:examples": "cd examples && npm run test:all",
+    "test:interop": "LIBP2P_JS=$PWD npx aegir test -t node -f ./node_modules/libp2p-interop/test/*",
     "prepare": "aegir build --no-bundle",
     "release": "aegir release -t node -t browser",
     "release-minor": "aegir release --type minor -t node -t browser",
@@ -65,7 +66,7 @@
   "homepage": "https://libp2p.io",
   "license": "MIT",
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=15.0.0"
   },
   "browser": {
     "@motrix/nat-api": false
@@ -74,24 +75,24 @@
     "extends": "ipfs",
     "ignorePatterns": [
       "!.aegir.js",
-      "test/ts-use"
+      "test/ts-use",
+      "*.d.ts"
     ]
   },
   "dependencies": {
     "@motrix/nat-api": "^0.3.1",
-    "abort-controller": "^3.0.0",
+    "@vascosantos/moving-average": "^1.1.0",
+    "abortable-iterator": "^3.0.0",
     "aggregate-error": "^3.1.0",
     "any-signal": "^2.1.1",
     "bignumber.js": "^9.0.1",
-    "cids": "^1.1.5",
     "class-is": "^1.1.0",
     "debug": "^4.3.1",
     "err-code": "^3.0.0",
-    "es6-promisify": "^6.1.1",
+    "es6-promisify": "^7.0.0",
     "events": "^3.3.0",
     "hashlru": "^2.3.0",
-    "interface-datastore": "^4.0.0",
-    "ipfs-utils": "^6.0.0",
+    "interface-datastore": "^6.0.2",
     "it-all": "^1.0.4",
     "it-buffer": "^0.1.2",
     "it-drain": "^1.0.3",
@@ -100,18 +101,16 @@
     "it-handshake": "^2.0.0",
     "it-length-prefixed": "^5.0.2",
     "it-map": "^1.0.4",
-    "it-merge": "1.0.0",
+    "it-merge": "^1.0.0",
     "it-pipe": "^1.1.0",
-    "it-take": "1.0.0",
-    "libp2p-crypto": "^0.19.4",
-    "libp2p-interfaces": "^0.10.4",
-    "libp2p-utils": "^0.3.1",
-    "mafmt": "^9.0.0",
+    "it-take": "^1.0.0",
+    "libp2p-crypto": "^0.21.0",
+    "libp2p-interfaces": "^2.0.1",
+    "libp2p-utils": "^0.4.0",
+    "mafmt": "^10.0.0",
     "merge-options": "^3.0.4",
-    "@vascosantos/moving-average": "^1.1.0",
-    "multiaddr": "^9.0.1",
-    "multicodec": "^3.0.1",
-    "multihashing-async": "^2.1.2",
+    "multiaddr": "^10.0.0",
+    "multiformats": "^9.0.0",
     "multistream-select": "^2.0.0",
     "mutable-proxy": "^1.0.0",
     "node-forge": "^0.10.0",
@@ -119,58 +118,59 @@
     "p-fifo": "^1.0.0",
     "p-retry": "^4.4.0",
     "p-settle": "^4.1.1",
-    "peer-id": "^0.14.2",
+    "peer-id": "^0.16.0",
     "private-ip": "^2.1.0",
     "protobufjs": "^6.10.2",
     "retimer": "^3.0.0",
     "sanitize-filename": "^1.6.3",
     "set-delayed-interval": "^1.0.0",
-    "streaming-iterables": "^5.0.2",
-    "timeout-abort-controller": "^1.1.1",
+    "streaming-iterables": "^6.0.0",
+    "timeout-abort-controller": "^2.0.0",
+    "uint8arrays": "^3.0.0",
     "varint": "^6.0.0",
+    "wherearewe": "^1.0.0",
     "xsalsa20": "^1.1.0"
   },
   "devDependencies": {
+    "@chainsafe/libp2p-noise": "^4.0.0",
     "@nodeutils/defaults-deep": "^1.1.0",
     "@types/es6-promisify": "^6.0.0",
-    "@types/node-forge": "^0.9.7",
+    "@types/node-forge": "^0.10.1",
     "@types/varint": "^6.0.0",
-    "abortable-iterator": "^3.0.0",
-    "aegir": "^33.1.1",
+    "aegir": "^36.0.0",
     "buffer": "^6.0.3",
+    "datastore-core": "^6.0.7",
     "delay": "^5.0.0",
-    "interop-libp2p": "^0.3.0",
     "into-stream": "^6.0.0",
-    "ipfs-http-client": "^49.0.4",
-    "it-concat": "^1.0.0",
+    "ipfs-http-client": "^54.0.2",
+    "it-concat": "^2.0.0",
     "it-pair": "^1.0.0",
     "it-pushable": "^1.4.0",
     "libp2p": ".",
-    "libp2p-bootstrap": "^0.12.3",
-    "libp2p-delegated-content-routing": "^0.10.0",
-    "libp2p-delegated-peer-routing": "^0.9.0",
-    "libp2p-floodsub": "^0.25.0",
-    "libp2p-gossipsub": "^0.9.0",
-    "libp2p-kad-dht": "^0.22.0",
-    "libp2p-mdns": "^0.16.0",
+    "libp2p-bootstrap": "^0.14.0",
+    "libp2p-delegated-content-routing": "^0.11.0",
+    "libp2p-delegated-peer-routing": "^0.11.0",
+    "libp2p-floodsub": "^0.27.0",
+    "libp2p-gossipsub": "^0.11.0",
+    "libp2p-interfaces-compliance-tests": "^2.0.1",
+    "libp2p-interop": "^0.5.0",
+    "libp2p-kad-dht": "^0.27.1",
+    "libp2p-mdns": "^0.18.0",
     "libp2p-mplex": "^0.10.1",
-    "libp2p-noise": "^3.0.0",
-    "libp2p-tcp": "^0.15.4",
-    "libp2p-webrtc-star": "^0.22.2",
-    "libp2p-websockets": "^0.15.6",
-    "multihashes": "^4.0.2",
+    "libp2p-tcp": "^0.17.0",
+    "libp2p-webrtc-star": "^0.25.0",
+    "libp2p-websockets": "^0.16.0",
     "nock": "^13.0.3",
     "p-defer": "^3.0.0",
     "p-times": "^3.0.0",
     "p-wait-for": "^3.2.0",
     "rimraf": "^3.0.2",
-    "sinon": "^10.0.0",
-    "uint8arrays": "^2.1.3",
+    "sinon": "^12.0.1",
     "util": "^0.12.3"
   },
   "contributors": [
-    "David Dias <daviddias.p@gmail.com>",
     "Vasco Santos <vasco.santos@moxy.studio>",
+    "David Dias <daviddias.p@gmail.com>",
     "Jacob Heun <jacobheun@gmail.com>",
     "Alex Potsides <alex@achingbrain.net>",
     "Alan Shaw <alan@tableflip.io>",
@@ -180,30 +180,43 @@
     "Maciej Krüger <mkg20001@gmail.com>",
     "Hugo Dias <mail@hugodias.me>",
     "dirkmc <dirkmdev@gmail.com>",
+    "Chris Dostert <chrisdostert@users.noreply.github.com>",
     "Volker Mische <volker.mische@gmail.com>",
+    "zeim839 <50573884+zeim839@users.noreply.github.com>",
     "Richard Littauer <richard.littauer@gmail.com>",
     "a1300 <matthias-knopp@gmx.net>",
-    "Elven <mon.samuel@qq.com>",
-    "Giovanni T. Parra <fiatjaf@gmail.com>",
-    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
-    "Thomas Eizinger <thomas@eizinger.io>",
-    "Samlior <samlior@foxmail.com>",
     "Ryan Bell <ryan@piing.net>",
+    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
+    "Giovanni T. Parra <fiatjaf@gmail.com>",
+    "acolytec3 <17355484+acolytec3@users.noreply.github.com>",
+    "Franck Royer <franck@royer.one>",
+    "Elven <mon.samuel@qq.com>",
+    "Robert Kiel <robert.kiel@hoprnet.org>",
     "Andrew Nesbitt <andrewnez@gmail.com>",
+    "Samlior <samlior@foxmail.com>",
+    "Thomas Eizinger <thomas@eizinger.io>",
     "Didrik Nordström <didrik.nordstrom@gmail.com>",
-    "Nuno Nogueira <nunofmn@gmail.com>",
-    "Philipp Muens <raute1337@gmx.de>",
     "Smite Chow <xiaopengyou@live.com>",
     "Soeren <nikorpoulsen@gmail.com>",
     "Sönke Hahn <soenkehahn@gmail.com>",
     "TJKoury <TJKoury@gmail.com>",
+    "TheStarBoys <41286328+TheStarBoys@users.noreply.github.com>",
     "Tiago Alves <alvesjtiago@gmail.com>",
+    "XiaoZhang <zxinmyth@gmail.com>",
     "Yusef Napora <yusef@napora.org>",
     "Zane Starr <zcstarr@gmail.com>",
     "ebinks <elizabethjbinks@gmail.com>",
+    "Aditya Bose <13054902+adbose@users.noreply.github.com>",
     "isan_rivkin <isanrivkin@gmail.com>",
+    "mayerwin <mayerwin@users.noreply.github.com>",
+    "mcclure <andi.m.mcclure@gmail.com>",
+    "patrickwoodhead <91056047+patrickwoodhead@users.noreply.github.com>",
+    "phillmac <phillmac@users.noreply.github.com>",
     "robertkiel <robert.kiel@validitylabs.org>",
-    "RasmusErik Voel Jensen <github@solsort.com>",
+    "shresthagrawal <34920931+shresthagrawal@users.noreply.github.com>",
+    "swedneck <40505480+swedneck@users.noreply.github.com>",
+    "greenSnot <greenSnot@users.noreply.github.com>",
+    "Alan Smithee <ggnore.alan.smithee@gmail.com>",
     "Aleksei <vozhdb@gmail.com>",
     "Bernd Strehl <bernd.strehl@gmail.com>",
     "Chris Bratlien <chrisbratlien@gmail.com>",
@@ -216,13 +229,22 @@
     "Felipe Martins <felipebrasil93@gmail.com>",
     "Florian-Merle <florian.david.merle@gmail.com>",
     "Francis Gulotta <wizard@roborooter.com>",
-    "Franck Royer <franck@royer.one>",
+    "Guy Sviry <32539816+guysv@users.noreply.github.com>",
     "Henrique Dias <hacdias@gmail.com>",
     "Irakli Gozalishvili <rfobic@gmail.com>",
     "Joel Gustafson <joelg@mit.edu>",
+    "John Rees <johnrees@users.noreply.github.com>",
+    "João Santos <joaosantos15@users.noreply.github.com>",
     "Julien Bouquillon <contact@revolunet.com>",
     "Kevin Kwok <antimatter15@gmail.com>",
     "Kevin Lacker <lacker@gmail.com>",
-    "Miguel Mota <miguelmota2@gmail.com>"
+    "Lars Gierth <lgierth@users.noreply.github.com>",
+    "Leask Wong <i@leaskh.com>",
+    "Marcin Tojek <mtojek@users.noreply.github.com>",
+    "Michael Burns <5170+mburns@users.noreply.github.com>",
+    "Miguel Mota <miguelmota2@gmail.com>",
+    "Nuno Nogueira <nunofmn@gmail.com>",
+    "Philipp Muens <raute1337@gmx.de>",
+    "RasmusErik Voel Jensen <github@solsort.com>"
   ]
 }

src/circuit/auto-relay.js

@@ -5,8 +5,8 @@ const log = Object.assign(debug('libp2p:auto-relay'), {
   error: debug('libp2p:auto-relay:err')
 })
 
-const uint8ArrayFromString = require('uint8arrays/from-string')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 const { Multiaddr } = require('multiaddr')
 const PeerId = require('peer-id')
 
@@ -116,7 +116,7 @@ class AutoRelay {
         this._peerStore.metadataBook.set(peerId, HOP_METADATA_KEY, uint8ArrayFromString(HOP_METADATA_VALUE))
         await this._addListenRelay(connection, id)
       }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._onError(err)
     }
   }
@@ -169,7 +169,7 @@ class AutoRelay {
     try {
       await this._transportManager.listen([new Multiaddr(listenAddr)])
       // Announce multiaddrs will update on listen success by TransportManager event being triggered
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._onError(err)
       this._listenRelays.delete(id)
     }
@@ -222,7 +222,7 @@ class AutoRelay {
         continue
       }
 
-      const peerId = PeerId.createFromCID(id)
+      const peerId = PeerId.createFromB58String(id)
       const connection = this._connectionManager.get(peerId)
 
       // If not connected, store for possible later use.
@@ -267,7 +267,7 @@ class AutoRelay {
           return
         }
       }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._onError(err)
     }
   }
@@ -279,7 +279,7 @@ class AutoRelay {
     try {
       const connection = await this._libp2p.dial(peerId)
       await this._addListenRelay(connection, peerId.toB58String())
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._onError(err, `could not connect and listen on known hop relay ${peerId.toB58String()}`)
     }
   }

src/circuit/circuit/hop.js

@@ -54,7 +54,7 @@ async function handleHop ({
   // Validate the HOP request has the required input
   try {
     validateAddrs(request, streamHandler)
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     return log.error('invalid hop request via peer %s', connection.remotePeer.toB58String(), err)
   }
 
@@ -93,7 +93,7 @@ async function handleHop ({
       connection: destinationConnection,
       request: stopRequest
     })
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     return log.error(err)
   }
 

src/circuit/circuit/stop.js

@@ -34,7 +34,7 @@ module.exports.handleStop = function handleStop ({
   // Validate the STOP request has the required input
   try {
     validateAddrs(request, streamHandler)
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     return log.error('invalid stop request via peer %s', connection.remotePeer.toB58String(), err)
   }
 

src/circuit/circuit/utils.js

@@ -34,7 +34,7 @@ function validateAddrs (msg, streamHandler) {
         return new Multiaddr(addr)
       })
     }
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
       ? CircuitRelay.Status.HOP_DST_MULTIADDR_INVALID
       : CircuitRelay.Status.STOP_DST_MULTIADDR_INVALID)
@@ -47,7 +47,7 @@ function validateAddrs (msg, streamHandler) {
         return new Multiaddr(addr)
       })
     }
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
       ? CircuitRelay.Status.HOP_SRC_MULTIADDR_INVALID
       : CircuitRelay.Status.STOP_SRC_MULTIADDR_INVALID)

src/circuit/index.js

@@ -87,7 +87,7 @@ class Relay {
     try {
       const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
       await this._libp2p.contentRouting.provide(cid)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       if (err.code === 'NO_ROUTERS_AVAILABLE') {
         log.error('a content router, such as a DHT, must be provided in order to advertise the relay service', err)
         // Stop the advertise

src/circuit/transport.js

@@ -136,8 +136,8 @@ class Circuit {
       throw errCode(new Error(errMsg), codes.ERR_RELAYED_DIAL)
     }
 
-    const relayPeer = PeerId.createFromCID(relayId)
-    const destinationPeer = PeerId.createFromCID(destinationId)
+    const relayPeer = PeerId.createFromB58String(relayId)
+    const destinationPeer = PeerId.createFromB58String(destinationId)
 
     let disconnectOnFailure = false
     let relayConnection = this._connectionManager.get(relayPeer)
@@ -171,7 +171,7 @@ class Circuit {
       log('new outbound connection %s', maConn.remoteAddr)
 
       return this._upgrader.upgradeOutbound(maConn)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       log.error('Circuit relay dial failed', err)
       disconnectOnFailure && await relayConnection.close()
       throw err

src/circuit/utils.js

@@ -1,9 +1,7 @@
 'use strict'
 
-const CID = require('cids')
-const multihashing = require('multihashing-async')
-
-const TextEncoder = require('ipfs-utils/src/text-encoder')
+const { CID } = require('multiformats/cid')
+const { sha256 } = require('multiformats/hashes/sha2')
 
 /**
  * Convert a namespace string into a cid.
@@ -13,7 +11,7 @@ const TextEncoder = require('ipfs-utils/src/text-encoder')
  */
 module.exports.namespaceToCid = async (namespace) => {
   const bytes = new TextEncoder().encode(namespace)
-  const hash = await multihashing(bytes, 'sha2-256')
+  const hash = await sha256.digest(bytes)
 
-  return new CID(hash)
+  return CID.createV0(hash)
 }

src/config.js

@@ -49,23 +49,11 @@ const DefaultConfig = {
     persistence: false,
     threshold: 5
   },
-  peerRouting: {
-    refreshManager: {
-      enabled: true,
-      interval: 6e5,
-      bootDelay: 10e3
-    }
-  },
   config: {
+    protocolPrefix: 'ipfs',
     dht: {
       enabled: false,
-      kBucketSize: 20,
-      randomWalk: {
-        enabled: false, // disabled waiting for https://github.com/libp2p/js-libp2p-kad-dht/issues/86
-        queriesPerPeriod: 1,
-        interval: 300e3,
-        timeout: 10e3
-      }
+      kBucketSize: 20
     },
     nat: {
       enabled: true,

src/connection-manager/auto-dialler.js

@@ -0,0 +1,118 @@
+'use strict'
+
+const debug = require('debug')
+const mergeOptions = require('merge-options')
+// @ts-ignore retimer does not have types
+const retimer = require('retimer')
+
+const log = Object.assign(debug('libp2p:connection-manager:auto-dialler'), {
+  error: debug('libp2p:connection-manager:auto-dialler:err')
+})
+
+const defaultOptions = {
+  enabled: true,
+  minConnections: 0,
+  autoDialInterval: 10000
+}
+
+/**
+ * @typedef {import('../index')} Libp2p
+ * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
+ */
+
+/**
+ * @typedef {Object} AutoDiallerOptions
+ * @property {boolean} [enabled = true] - Should preemptively guarantee connections are above the low watermark
+ * @property {number} [minConnections = 0] - The minimum number of connections to avoid pruning
+ * @property {number} [autoDialInterval = 10000] - How often, in milliseconds, it should preemptively guarantee connections are above the low watermark
+ */
+
+class AutoDialler {
+  /**
+   * Proactively tries to connect to known peers stored in the PeerStore.
+   * It will keep the number of connections below the upper limit and sort
+   * the peers to connect based on wether we know their keys and protocols.
+   *
+   * @class
+   * @param {Libp2p} libp2p
+   * @param {AutoDiallerOptions} options
+   */
+  constructor (libp2p, options = {}) {
+    this._options = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, options)
+    this._libp2p = libp2p
+    this._running = false
+    this._autoDialTimeout = null
+    this._autoDial = this._autoDial.bind(this)
+
+    log('options: %j', this._options)
+  }
+
+  /**
+   * Starts the auto dialer
+   */
+  start () {
+    if (!this._options.enabled) {
+      log('not enabled')
+      return
+    }
+
+    this._running = true
+    this._autoDial()
+    log('started')
+  }
+
+  /**
+   * Stops the auto dialler
+   */
+  async stop () {
+    if (!this._options.enabled) {
+      log('not enabled')
+      return
+    }
+
+    this._running = false
+    this._autoDialTimeout && this._autoDialTimeout.clear()
+    log('stopped')
+  }
+
+  async _autoDial () {
+    const minConnections = this._options.minConnections
+
+    // Already has enough connections
+    if (this._libp2p.connections.size >= minConnections) {
+      this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
+      return
+    }
+
+    // Sort peers on wether we know protocols of public keys for them
+    const peers = Array.from(this._libp2p.peerStore.peers.values())
+      .sort((a, b) => {
+        if (b.protocols && b.protocols.length && (!a.protocols || !a.protocols.length)) {
+          return 1
+        } else if (b.id.pubKey && !a.id.pubKey) {
+          return 1
+        }
+        return -1
+      })
+
+    for (let i = 0; this._running && i < peers.length && this._libp2p.connections.size < minConnections; i++) {
+      if (!this._libp2p.connectionManager.get(peers[i].id)) {
+        log('connecting to a peerStore stored peer %s', peers[i].id.toB58String())
+        try {
+          await this._libp2p.dialer.connectToPeer(peers[i].id)
+        } catch (/** @type {any} */ err) {
+          log.error('could not connect to peerStore stored peer', err)
+        }
+      }
+    }
+
+    // Connection Manager was stopped
+    if (!this._running) {
+      return
+    }
+
+    this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
+  }
+}
+
+module.exports = AutoDialler

src/connection-manager/index.js

@@ -94,9 +94,12 @@ class ConnectionManager extends EventEmitter {
 
     this._started = false
     this._timer = null
-    this._autoDialTimeout = null
     this._checkMetrics = this._checkMetrics.bind(this)
-    this._autoDial = this._autoDial.bind(this)
+
+    this._latencyMonitor = new LatencyMonitor({
+      latencyCheckIntervalMs: this._options.pollInterval,
+      dataEmitIntervalMs: this._options.pollInterval
+    })
   }
 
   /**
@@ -117,17 +120,12 @@ class ConnectionManager extends EventEmitter {
     }
 
     // latency monitor
-    this._latencyMonitor = new LatencyMonitor({
-      latencyCheckIntervalMs: this._options.pollInterval,
-      dataEmitIntervalMs: this._options.pollInterval
-    })
+    this._latencyMonitor.start()
     this._onLatencyMeasure = this._onLatencyMeasure.bind(this)
     this._latencyMonitor.on('data', this._onLatencyMeasure)
 
     this._started = true
     log('started')
-
-    this._options.autoDial && this._autoDial()
   }
 
   /**
@@ -136,9 +134,10 @@ class ConnectionManager extends EventEmitter {
    * @async
    */
   async stop () {
-    this._autoDialTimeout && this._autoDialTimeout.clear()
     this._timer && this._timer.clear()
-    this._latencyMonitor && this._latencyMonitor.removeListener('data', this._onLatencyMeasure)
+
+    this._latencyMonitor.removeListener('data', this._onLatencyMeasure)
+    this._latencyMonitor.stop()
 
     this._started = false
     await this._close()
@@ -308,53 +307,6 @@ class ConnectionManager extends EventEmitter {
     }
   }
 
-  /**
-   * Proactively tries to connect to known peers stored in the PeerStore.
-   * It will keep the number of connections below the upper limit and sort
-   * the peers to connect based on wether we know their keys and protocols.
-   *
-   * @async
-   * @private
-   */
-  async _autoDial () {
-    const minConnections = this._options.minConnections
-
-    // Already has enough connections
-    if (this.size >= minConnections) {
-      this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
-      return
-    }
-
-    // Sort peers on wether we know protocols of public keys for them
-    const peers = Array.from(this._libp2p.peerStore.peers.values())
-      .sort((a, b) => {
-        if (b.protocols && b.protocols.length && (!a.protocols || !a.protocols.length)) {
-          return 1
-        } else if (b.id.pubKey && !a.id.pubKey) {
-          return 1
-        }
-        return -1
-      })
-
-    for (let i = 0; i < peers.length && this.size < minConnections; i++) {
-      if (!this.get(peers[i].id)) {
-        log('connecting to a peerStore stored peer %s', peers[i].id.toB58String())
-        try {
-          await this._libp2p.dialer.connectToPeer(peers[i].id)
-
-          // Connection Manager was stopped
-          if (!this._started) {
-            return
-          }
-        } catch (err) {
-          log.error('could not connect to peerStore stored peer', err)
-        }
-      }
-    }
-
-    this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
-  }
-
   /**
    * If we have more connections than our maximum, close a connection
    * to the lowest valued peer.

src/connection-manager/latency-monitor.js

@@ -69,49 +69,55 @@ class LatencyMonitor extends EventEmitter {
     }
 
     that.asyncTestFn = asyncTestFn // If there is no asyncFn, we measure latency
+  }
 
+  start () {
     // If process: use high resolution timer
     if (globalThis.process && globalThis.process.hrtime) { // eslint-disable-line no-undef
       debug('Using process.hrtime for timing')
-      that.now = globalThis.process.hrtime // eslint-disable-line no-undef
-      that.getDeltaMS = (startTime) => {
-        const hrtime = that.now(startTime)
+      this.now = globalThis.process.hrtime // eslint-disable-line no-undef
+      this.getDeltaMS = (startTime) => {
+        const hrtime = this.now(startTime)
         return (hrtime[0] * 1000) + (hrtime[1] / 1000000)
       }
       // Let's try for a timer that only monotonically increases
     } else if (typeof window !== 'undefined' && window.performance && window.performance.now) {
       debug('Using performance.now for timing')
-      that.now = window.performance.now.bind(window.performance)
-      that.getDeltaMS = (startTime) => Math.round(that.now() - startTime)
+      this.now = window.performance.now.bind(window.performance)
+      this.getDeltaMS = (startTime) => Math.round(this.now() - startTime)
     } else {
       debug('Using Date.now for timing')
-      that.now = Date.now
-      that.getDeltaMS = (startTime) => that.now() - startTime
+      this.now = Date.now
+      this.getDeltaMS = (startTime) => this.now() - startTime
     }
 
-    that._latencyData = that._initLatencyData()
+    this._latencyData = this._initLatencyData()
 
     // We check for isBrowser because of browsers set max rates of timeouts when a page is hidden,
     // so we fall back to another library
     // See: http://stackoverflow.com/questions/6032429/chrome-timeouts-interval-suspended-in-background-tabs
     if (isBrowser()) {
-      that._visibilityChangeEmitter = new VisibilityChangeEmitter()
+      this._visibilityChangeEmitter = new VisibilityChangeEmitter()
 
-      that._visibilityChangeEmitter.on('visibilityChange', (pageInFocus) => {
+      this._visibilityChangeEmitter.on('visibilityChange', (pageInFocus) => {
         if (pageInFocus) {
-          that._startTimers()
+          this._startTimers()
         } else {
-          that._emitSummary()
-          that._stopTimers()
+          this._emitSummary()
+          this._stopTimers()
         }
       })
     }
 
-    if (!that._visibilityChangeEmitter || that._visibilityChangeEmitter.isVisible()) {
-      that._startTimers()
+    if (!this._visibilityChangeEmitter || this._visibilityChangeEmitter.isVisible()) {
+      this._startTimers()
     }
   }
 
+  stop () {
+    this._stopTimers()
+  }
+
   /**
    * Start internal timers
    *

src/constants.js

@@ -4,6 +4,7 @@ module.exports = {
   DIAL_TIMEOUT: 30e3, // How long in ms a dial attempt is allowed to take
   MAX_PARALLEL_DIALS: 100, // Maximum allowed concurrent dials
   MAX_PER_PEER_DIALS: 4, // Allowed parallel dials per DialRequest
+  MAX_ADDRS_TO_DIAL: 25, // Maximum number of allowed addresses to attempt to dial
   METRICS: {
     computeThrottleMaxQueueSize: 1000,
     computeThrottleTimeout: 2000,

src/content-routing/index.js

@@ -8,14 +8,15 @@ const {
   requirePeers,
   maybeLimitSource
 } = require('./utils')
-
+const drain = require('it-drain')
 const merge = require('it-merge')
 const { pipe } = require('it-pipe')
+const { DHTContentRouting } = require('../dht/dht-content-routing')
 
 /**
  * @typedef {import('peer-id')} PeerId
  * @typedef {import('multiaddr').Multiaddr} Multiaddr
- * @typedef {import('cids')} CID
+ * @typedef {import('multiformats/cid').CID} CID
  * @typedef {import('libp2p-interfaces/src/content-routing/types').ContentRouting} ContentRoutingModule
  */
 
@@ -38,7 +39,7 @@ class ContentRouting {
 
     // If we have the dht, add it to the available content routers
     if (this.dht && libp2p._config.dht.enabled) {
-      this.routers.push(this.dht)
+      this.routers.push(new DHTContentRouting(this.dht))
     }
   }
 
@@ -91,12 +92,12 @@ class ContentRouting {
    * @param {number} [options.minPeers] - minimum number of peers required to successfully put
    * @returns {Promise<void>}
    */
-  put (key, value, options) {
+  async put (key, value, options) {
     if (!this.libp2p.isStarted() || !this.dht.isStarted) {
       throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
     }
 
-    return this.dht.put(key, value, options)
+    await drain(this.dht.put(key, value, options))
   }
 
   /**
@@ -108,12 +109,18 @@ class ContentRouting {
    * @param {number} [options.timeout] - optional timeout (default: 60000)
    * @returns {Promise<GetData>}
    */
-  get (key, options) {
+  async get (key, options) {
     if (!this.libp2p.isStarted() || !this.dht.isStarted) {
       throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
     }
 
-    return this.dht.get(key, options)
+    for await (const event of this.dht.get(key, options)) {
+      if (event.name === 'VALUE') {
+        return { from: event.peerId, val: event.value }
+      }
+    }
+
+    throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
   }
 
   /**
@@ -123,14 +130,33 @@ class ContentRouting {
    * @param {number} nVals
    * @param {Object} [options] - get options
    * @param {number} [options.timeout] - optional timeout (default: 60000)
-   * @returns {Promise<GetData[]>}
    */
-  async getMany (key, nVals, options) { // eslint-disable-line require-await
+  async * getMany (key, nVals, options) { // eslint-disable-line require-await
     if (!this.libp2p.isStarted() || !this.dht.isStarted) {
       throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
     }
 
-    return this.dht.getMany(key, nVals, options)
+    if (!nVals) {
+      return
+    }
+
+    let gotValues = 0
+
+    for await (const event of this.dht.get(key, options)) {
+      if (event.name === 'VALUE') {
+        yield { from: event.peerId, val: event.value }
+
+        gotValues++
+
+        if (gotValues === nVals) {
+          break
+        }
+      }
+    }
+
+    if (gotValues === 0) {
+      throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
+    }
   }
 }
 

src/dht/dht-content-routing.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const drain = require('it-drain')
+
+/**
+ * @typedef {import('peer-id')} PeerId
+ * @typedef {import('libp2p-interfaces/src/content-routing/types').ContentRouting} ContentRoutingModule
+ * @typedef {import('multiformats/cid').CID} CID
+ */
+
+/**
+ * Wrapper class to convert events into returned values
+ *
+ * @implements {ContentRoutingModule}
+ */
+class DHTContentRouting {
+  /**
+   * @param {import('libp2p-kad-dht').DHT} dht
+   */
+  constructor (dht) {
+    this._dht = dht
+  }
+
+  /**
+   * @param {CID} cid
+   */
+  async provide (cid) {
+    await drain(this._dht.provide(cid))
+  }
+
+  /**
+   * @param {CID} cid
+   * @param {*} options
+   */
+  async * findProviders (cid, options) {
+    for await (const event of this._dht.findProviders(cid, options)) {
+      if (event.name === 'PROVIDER') {
+        yield * event.providers
+      }
+    }
+  }
+}
+
+module.exports = { DHTContentRouting }

src/dht/dht-peer-routing.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const errCode = require('err-code')
+const { messages, codes } = require('../errors')
+
+/**
+ * @typedef {import('peer-id')} PeerId
+ * @typedef {import('libp2p-interfaces/src/peer-routing/types').PeerRouting} PeerRoutingModule
+ */
+
+/**
+ * Wrapper class to convert events into returned values
+ *
+ * @implements {PeerRoutingModule}
+ */
+class DHTPeerRouting {
+  /**
+   * @param {import('libp2p-kad-dht').DHT} dht
+   */
+  constructor (dht) {
+    this._dht = dht
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {any} options
+   */
+  async findPeer (peerId, options = {}) {
+    for await (const event of this._dht.findPeer(peerId, options)) {
+      if (event.name === 'FINAL_PEER') {
+        return event.peer
+      }
+    }
+
+    throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
+  }
+
+  /**
+   * @param {Uint8Array} key
+   * @param {any} options
+   */
+  async * getClosestPeers (key, options = {}) {
+    for await (const event of this._dht.getClosestPeers(key, options)) {
+      if (event.name === 'PEER_RESPONSE') {
+        yield * event.closer
+      }
+    }
+  }
+}
+
+module.exports = { DHTPeerRouting }

src/dialer/dial-request.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const errCode = require('err-code')
-const AbortController = require('abort-controller').default
 const { anySignal } = require('any-signal')
 // @ts-ignore p-fifo does not export types
 const FIFO = require('p-fifo')

src/dialer/index.js

@@ -6,8 +6,8 @@ const log = Object.assign(debug('libp2p:dialer'), {
 })
 const errCode = require('err-code')
 const { Multiaddr } = require('multiaddr')
-// @ts-ignore timeout-abourt-controles does not export types
-const TimeoutController = require('timeout-abort-controller')
+const { TimeoutController } = require('timeout-abort-controller')
+const { AbortError } = require('abortable-iterator')
 const { anySignal } = require('any-signal')
 
 const DialRequest = require('./dial-request')
@@ -18,7 +18,8 @@ const { codes } = require('../errors')
 const {
   DIAL_TIMEOUT,
   MAX_PARALLEL_DIALS,
-  MAX_PER_PEER_DIALS
+  MAX_PER_PEER_DIALS,
+  MAX_ADDRS_TO_DIAL
 } = require('../constants')
 
 /**
@@ -39,6 +40,7 @@ const {
  * @typedef {Object} DialerOptions
  * @property {(addresses: Address[]) => Address[]} [options.addressSorter = publicAddressesFirst] - Sort the known addresses of a peer before trying to dial.
  * @property {number} [maxParallelDials = MAX_PARALLEL_DIALS] - Number of max concurrent dials.
+ * @property {number} [maxAddrsToDial = MAX_ADDRS_TO_DIAL] - Number of max addresses to dial for a given peer.
  * @property {number} [maxDialsPerPeer = MAX_PER_PEER_DIALS] - Number of max concurrent dials per peer.
  * @property {number} [dialTimeout = DIAL_TIMEOUT] - How long a dial attempt is allowed to take.
  * @property {Record<string, Resolver>} [resolvers = {}] - multiaddr resolvers to use when dialing
@@ -64,6 +66,7 @@ class Dialer {
     peerStore,
     addressSorter = publicAddressesFirst,
     maxParallelDials = MAX_PARALLEL_DIALS,
+    maxAddrsToDial = MAX_ADDRS_TO_DIAL,
     dialTimeout = DIAL_TIMEOUT,
     maxDialsPerPeer = MAX_PER_PEER_DIALS,
     resolvers = {}
@@ -72,10 +75,12 @@ class Dialer {
     this.peerStore = peerStore
     this.addressSorter = addressSorter
     this.maxParallelDials = maxParallelDials
+    this.maxAddrsToDial = maxAddrsToDial
     this.timeout = dialTimeout
     this.maxDialsPerPeer = maxDialsPerPeer
     this.tokens = [...new Array(maxParallelDials)].map((_, index) => index)
     this._pendingDials = new Map()
+    this._pendingDialTargets = new Map()
 
     for (const [key, value] of Object.entries(resolvers)) {
       Multiaddr.resolvers.set(key, value)
@@ -89,11 +94,16 @@ class Dialer {
     for (const dial of this._pendingDials.values()) {
       try {
         dial.controller.abort()
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
         log.error(err)
       }
     }
     this._pendingDials.clear()
+
+    for (const pendingTarget of this._pendingDialTargets.values()) {
+      pendingTarget.reject(new AbortError('Dialer was destroyed'))
+    }
+    this._pendingDialTargets.clear()
   }
 
   /**
@@ -107,7 +117,7 @@ class Dialer {
    * @returns {Promise<Connection>}
    */
   async connectToPeer (peer, options = {}) {
-    const dialTarget = await this._createDialTarget(peer)
+    const dialTarget = await this._createCancellableDialTarget(peer)
 
     if (!dialTarget.addrs.length) {
       throw errCode(new Error('The dial request has no valid addresses'), codes.ERR_NO_VALID_ADDRESSES)
@@ -118,7 +128,7 @@ class Dialer {
       const connection = await pendingDial.promise
       log('dial succeeded to %s', dialTarget.id)
       return connection
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       // Error is a timeout
       if (pendingDial.controller.signal.aborted) {
         err.code = codes.ERR_TIMEOUT
@@ -130,6 +140,31 @@ class Dialer {
     }
   }
 
+  /**
+   * Connects to a given `peer` by dialing all of its known addresses.
+   * The dial to the first address that is successfully able to upgrade a connection
+   * will be used.
+   *
+   * @param {PeerId|Multiaddr|string} peer - The peer to dial
+   * @returns {Promise<DialTarget>}
+   */
+  async _createCancellableDialTarget (peer) {
+    // Make dial target promise cancellable
+    const id = `${(parseInt(String(Math.random() * 1e9), 10)).toString() + Date.now()}`
+    const cancellablePromise = new Promise((resolve, reject) => {
+      this._pendingDialTargets.set(id, { resolve, reject })
+    })
+
+    const dialTarget = await Promise.race([
+      this._createDialTarget(peer),
+      cancellablePromise
+    ])
+
+    this._pendingDialTargets.delete(id)
+
+    return dialTarget
+  }
+
   /**
    * Creates a DialTarget. The DialTarget is used to create and track
    * the DialRequest to a given peer.
@@ -166,6 +201,11 @@ class Dialer {
     // Multiaddrs not supported by the available transports will be filtered out.
     const supportedAddrs = addrs.filter(a => this.transportManager.transportForMultiaddr(a))
 
+    if (supportedAddrs.length > this.maxAddrsToDial) {
+      this.peerStore.delete(id)
+      throw errCode(new Error('dial with more addresses than allowed'), codes.ERR_TOO_MANY_ADDRESSES)
+    }
+
     return {
       id: id.toB58String(),
       addrs: supportedAddrs

src/errors.js

@@ -3,7 +3,8 @@
 exports.messages = {
   NOT_STARTED_YET: 'The libp2p node is not started yet',
   DHT_DISABLED: 'DHT is not available',
-  CONN_ENCRYPTION_REQUIRED: 'At least one connection encryption module is required'
+  CONN_ENCRYPTION_REQUIRED: 'At least one connection encryption module is required',
+  NOT_FOUND: 'Not found'
 }
 
 exports.codes = {
@@ -16,6 +17,7 @@ exports.codes = {
   ERR_CONNECTION_FAILED: 'ERR_CONNECTION_FAILED',
   ERR_NODE_NOT_STARTED: 'ERR_NODE_NOT_STARTED',
   ERR_ALREADY_ABORTED: 'ERR_ALREADY_ABORTED',
+  ERR_TOO_MANY_ADDRESSES: 'ERR_TOO_MANY_ADDRESSES',
   ERR_NO_VALID_ADDRESSES: 'ERR_NO_VALID_ADDRESSES',
   ERR_RELAYED_DIAL: 'ERR_RELAYED_DIAL',
   ERR_DIALED_SELF: 'ERR_DIALED_SELF',
@@ -28,6 +30,7 @@ exports.codes = {
   ERR_INVALID_PARAMETERS: 'ERR_INVALID_PARAMETERS',
   ERR_INVALID_PEER: 'ERR_INVALID_PEER',
   ERR_MUXER_UNAVAILABLE: 'ERR_MUXER_UNAVAILABLE',
+  ERR_NOT_FOUND: 'ERR_NOT_FOUND',
   ERR_TIMEOUT: 'ERR_TIMEOUT',
   ERR_TRANSPORT_UNAVAILABLE: 'ERR_TRANSPORT_UNAVAILABLE',
   ERR_TRANSPORT_DIAL_FAILED: 'ERR_TRANSPORT_DIAL_FAILED',

src/get-peer.js

@@ -32,7 +32,7 @@ function getPeer (peer) {
 
     try {
       peer = PeerId.createFromB58String(idStr)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       throw errCode(
         new Error(`${peer} is not a valid peer type`),
         codes.ERR_INVALID_MULTIADDR

src/identify/consts.js

@@ -3,7 +3,13 @@
 // @ts-ignore file not listed within the file list of projects
 const libp2pVersion = require('../../package.json').version
 
-module.exports.PROTOCOL_VERSION = 'ipfs/0.1.0'
+module.exports.PROTOCOL_VERSION = 'ipfs/0.1.0' // deprecated
 module.exports.AGENT_VERSION = `js-libp2p/${libp2pVersion}`
-module.exports.MULTICODEC_IDENTIFY = '/ipfs/id/1.0.0'
-module.exports.MULTICODEC_IDENTIFY_PUSH = '/ipfs/id/push/1.0.0'
+module.exports.MULTICODEC_IDENTIFY = '/ipfs/id/1.0.0' // deprecated
+module.exports.MULTICODEC_IDENTIFY_PUSH = '/ipfs/id/push/1.0.0' // deprecated
+
+module.exports.IDENTIFY_PROTOCOL_VERSION = '0.1.0'
+module.exports.MULTICODEC_IDENTIFY_PROTOCOL_NAME = 'id'
+module.exports.MULTICODEC_IDENTIFY_PUSH_PROTOCOL_NAME = 'id/push'
+module.exports.MULTICODEC_IDENTIFY_PROTOCOL_VERSION = '1.0.0'
+module.exports.MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION = '1.0.0'

src/identify/index.js

@@ -8,7 +8,7 @@ const errCode = require('err-code')
 const lp = require('it-length-prefixed')
 const { pipe } = require('it-pipe')
 const { collect, take, consume } = require('streaming-iterables')
-const uint8ArrayFromString = require('uint8arrays/from-string')
+const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
 
 const PeerId = require('peer-id')
 const { Multiaddr } = require('multiaddr')
@@ -23,7 +23,11 @@ const PeerRecord = require('../record/peer-record')
 const {
   MULTICODEC_IDENTIFY,
   MULTICODEC_IDENTIFY_PUSH,
-  PROTOCOL_VERSION
+  IDENTIFY_PROTOCOL_VERSION,
+  MULTICODEC_IDENTIFY_PROTOCOL_NAME,
+  MULTICODEC_IDENTIFY_PUSH_PROTOCOL_NAME,
+  MULTICODEC_IDENTIFY_PROTOCOL_VERSION,
+  MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION
 } = require('./consts')
 
 const { codes } = require('../errors')
@@ -39,6 +43,16 @@ const { codes } = require('../errors')
  */
 
 class IdentifyService {
+  /**
+   * @param {import('../')} libp2p
+   */
+  static getProtocolStr (libp2p) {
+    return {
+      identifyProtocolStr: `/${libp2p._config.protocolPrefix}/${MULTICODEC_IDENTIFY_PROTOCOL_NAME}/${MULTICODEC_IDENTIFY_PROTOCOL_VERSION}`,
+      identifyPushProtocolStr: `/${libp2p._config.protocolPrefix}/${MULTICODEC_IDENTIFY_PUSH_PROTOCOL_NAME}/${MULTICODEC_IDENTIFY_PUSH_PROTOCOL_VERSION}`
+    }
+  }
+
   /**
    * @class
    * @param {Object} options
@@ -53,9 +67,13 @@ class IdentifyService {
 
     this.handleMessage = this.handleMessage.bind(this)
 
+    const protocolStr = IdentifyService.getProtocolStr(libp2p)
+    this.identifyProtocolStr = protocolStr.identifyProtocolStr
+    this.identifyPushProtocolStr = protocolStr.identifyPushProtocolStr
+
     // Store self host metadata
     this._host = {
-      protocolVersion: PROTOCOL_VERSION,
+      protocolVersion: `${libp2p._config.protocolPrefix}/${IDENTIFY_PROTOCOL_VERSION}`,
       ...libp2p._options.host
     }
 
@@ -94,7 +112,7 @@ class IdentifyService {
 
     const pushes = connections.map(async connection => {
       try {
-        const { stream } = await connection.newStream(MULTICODEC_IDENTIFY_PUSH)
+        const { stream } = await connection.newStream(this.identifyPushProtocolStr)
 
         await pipe(
           [Message.Identify.encode({
@@ -106,7 +124,7 @@ class IdentifyService {
           stream,
           consume
         )
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
         // Just log errors
         log.error('could not push identify update to peer', err)
       }
@@ -129,7 +147,7 @@ class IdentifyService {
     const connections = []
     let connection
     for (const peer of this.peerStore.peers.values()) {
-      if (peer.protocols.includes(MULTICODEC_IDENTIFY_PUSH) && (connection = this.connectionManager.get(peer.id))) {
+      if (peer.protocols.includes(this.identifyPushProtocolStr) && (connection = this.connectionManager.get(peer.id))) {
         connections.push(connection)
       }
     }
@@ -147,7 +165,7 @@ class IdentifyService {
    * @returns {Promise<void>}
    */
   async identify (connection) {
-    const { stream } = await connection.newStream(MULTICODEC_IDENTIFY)
+    const { stream } = await connection.newStream(this.identifyProtocolStr)
     const [data] = await pipe(
       [],
       stream,
@@ -164,7 +182,7 @@ class IdentifyService {
     let message
     try {
       message = Message.Identify.decode(data)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       throw errCode(err, codes.ERR_INVALID_MESSAGE)
     }
 
@@ -189,21 +207,24 @@ class IdentifyService {
       const envelope = await Envelope.openAndCertify(signedPeerRecord, PeerRecord.DOMAIN)
       if (this.peerStore.addressBook.consumePeerRecord(envelope)) {
         this.peerStore.protoBook.set(id, protocols)
+        this.peerStore.metadataBook.set(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
+        this.peerStore.metadataBook.set(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
         return
       }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       log('received invalid envelope, discard it and fallback to listenAddrs is available', err)
     }
 
     // LEGACY: Update peers data in PeerStore
     try {
       this.peerStore.addressBook.set(id, listenAddrs.map((addr) => new Multiaddr(addr)))
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       log.error('received invalid addrs', err)
     }
 
     this.peerStore.protoBook.set(id, protocols)
     this.peerStore.metadataBook.set(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
+    this.peerStore.metadataBook.set(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
 
     // TODO: Add and score our observed addr
     log('received observed address of %s', cleanObservedAddr)
@@ -221,9 +242,9 @@ class IdentifyService {
    */
   handleMessage ({ connection, stream, protocol }) {
     switch (protocol) {
-      case MULTICODEC_IDENTIFY:
+      case this.identifyProtocolStr:
         return this._handleIdentify({ connection, stream })
-      case MULTICODEC_IDENTIFY_PUSH:
+      case this.identifyPushProtocolStr:
         return this._handlePush({ connection, stream })
       default:
         log.error('cannot handle unknown protocol %s', protocol)
@@ -266,7 +287,7 @@ class IdentifyService {
         stream,
         consume
       )
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       log.error('could not respond to identify request', err)
     }
   }
@@ -292,7 +313,7 @@ class IdentifyService {
         collect
       )
       message = Message.Identify.decode(data)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       return log.error('received invalid message', err)
     }
 
@@ -304,7 +325,7 @@ class IdentifyService {
         this.peerStore.protoBook.set(id, message.protocols)
         return
       }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       log('received invalid envelope, discard it and fallback to listenAddrs is available', err)
     }
 
@@ -312,7 +333,7 @@ class IdentifyService {
     try {
       this.peerStore.addressBook.set(id,
         message.listenAddrs.map((addr) => new Multiaddr(addr)))
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       log.error('received invalid addrs', err)
     }
 

src/index.js

@@ -18,6 +18,7 @@ const { codes, messages } = require('./errors')
 
 const AddressManager = require('./address-manager')
 const ConnectionManager = require('./connection-manager')
+const AutoDialler = require('./connection-manager/auto-dialler')
 const Circuit = require('./circuit/transport')
 const Relay = require('./circuit')
 const Dialer = require('./dialer')
@@ -31,7 +32,6 @@ const PersistentPeerStore = require('./peer-store/persistent')
 const Registrar = require('./registrar')
 const ping = require('./ping')
 const IdentifyService = require('./identify')
-const IDENTIFY_PROTOCOLS = IdentifyService.multicodecs
 const NatManager = require('./nat-manager')
 const { updateSelfPeerRecord } = require('./record/utils')
 
@@ -194,9 +194,13 @@ class Libp2p extends EventEmitter {
 
     // Create the Connection Manager
     this.connectionManager = new ConnectionManager(this, {
-      autoDial: this._config.peerDiscovery.autoDial,
       ...this._options.connectionManager
     })
+    this._autodialler = new AutoDialler(this, {
+      enabled: this._config.peerDiscovery.autoDial,
+      minConnections: this._options.connectionManager.minConnections,
+      autoDialInterval: this._options.connectionManager.autoDialInterval
+    })
 
     // Create Metrics
     if (this._options.metrics.enabled) {
@@ -289,7 +293,7 @@ class Libp2p extends EventEmitter {
 
       // Add the identify service since we can multiplex
       this.identifyService = new IdentifyService({ libp2p: this })
-      this.handle(Object.values(IDENTIFY_PROTOCOLS), this.identifyService.handleMessage)
+      this.handle(Object.values(IdentifyService.getProtocolStr(this)), this.identifyService.handleMessage)
     }
 
     // Attach private network protector
@@ -302,14 +306,9 @@ class Libp2p extends EventEmitter {
     // dht provided components (peerRouting, contentRouting, dht)
     if (this._modules.dht) {
       const DHT = this._modules.dht
-      // @ts-ignore Object is not constructable
-      this._dht = new DHT({
+      // @ts-ignore TODO: types need fixing - DHT is an `object` which has no `create` method
+      this._dht = DHT.create({
         libp2p: this,
-        dialer: this.dialer,
-        peerId: this.peerId,
-        peerStore: this.peerStore,
-        registrar: this.registrar,
-        datastore: this.datastore,
         ...this._config.dht
       })
     }
@@ -364,7 +363,7 @@ class Libp2p extends EventEmitter {
       await this._onStarting()
       await this._onDidStart()
       log('libp2p has started')
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this.emit('error', err)
       log.error('An error occurred starting libp2p', err)
       await this.stop()
@@ -385,7 +384,8 @@ class Libp2p extends EventEmitter {
       this._isStarted = false
 
       this.relay && this.relay.stop()
-      this.peerRouting.stop()
+      this._autodialler.stop()
+      await (this._dht && this._dht.stop())
 
       for (const service of this._discovery.values()) {
         service.removeListener('peer', this._onDiscoveryPeer)
@@ -400,7 +400,6 @@ class Libp2p extends EventEmitter {
 
       await Promise.all([
         this.pubsub && this.pubsub.stop(),
-        this._dht && this._dht.stop(),
         this.metrics && this.metrics.stop()
       ])
 
@@ -409,7 +408,7 @@ class Libp2p extends EventEmitter {
 
       ping.unmount(this)
       this.dialer.destroy()
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       if (err) {
         log.error(err)
         this.emit('error', err)
@@ -432,7 +431,7 @@ class Libp2p extends EventEmitter {
 
     try {
       await this.keychain.findKeyByName('self')
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       await this.keychain.importPeer('self', this.peerId)
     }
   }
@@ -625,7 +624,7 @@ class Libp2p extends EventEmitter {
 
     // DHT subsystem
     if (this._config.dht.enabled) {
-      this._dht && this._dht.start()
+      this._dht && await this._dht.start()
 
       // TODO: this should be modified once random-walk is used as
       // the other discovery modules
@@ -656,14 +655,13 @@ class Libp2p extends EventEmitter {
     }
 
     this.connectionManager.start()
+    this._autodialler.start()
 
     // Peer discovery
     await this._setupPeerDiscovery()
 
     // Relay
     this.relay && this.relay.start()
-
-    this.peerRouting.start()
   }
 
   /**
@@ -699,7 +697,7 @@ class Libp2p extends EventEmitter {
         log('connecting to discovered peer %s', peerId.toB58String())
         try {
           await this.dialer.connectToPeer(peerId)
-        } catch (err) {
+        } catch (/** @type {any} */ err) {
           log.error(`could not connect to discovered peer ${peerId.toB58String()} with ${err}`)
         }
       }