chore: release version v0.35.7

chore: update contributors
fix: type definitions for big dialrequest and persistent peerstore (#1078 )
2025-07-16 09:01:58 +00:00 · 2021-12-24 14:51:51 +00:00 · 2021-12-24 14:51:51 +00:00 · 2021-12-24 15:46:00 +01:00 · 2021-12-24 11:18:09 +01:00 · 2021-12-22 17:03:03 +01:00
165 changed files with 2171 additions and 1252 deletions
--- a/.aegir.js
+++ b/.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

--- a/.github/dependabot.yml
+++ b/.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
--- a/.github/workflows/examples.yml
+++ b/.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
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -12,9 +12,11 @@ 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
@@ -27,35 +29,44 @@ 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
-      - run: npx aegir test -t node --cov --bail
+      - run: npm run test:node -- --cov --bail
      - uses: codecov/codecov-action@v1
  test-chrome:
    needs: check
    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
+      - run: npm run test:browser -- -t browser -t webworker --bail
  test-firefox:
    needs: check
    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
+      - run: npm run test:browser -- -t browser -t webworker --bail -- --browser firefox
  test-ts:
    needs: check
    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
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,225 @@
+## [0.35.7](https://github.com/libp2p/js-libp2p/compare/v0.35.2...v0.35.7) (2021-12-24)
+
+
+### Bug Fixes
+
+* add tracked map ([#1069](https://github.com/libp2p/js-libp2p/issues/1069)) ([b425fa1](https://github.com/libp2p/js-libp2p/commit/b425fa12304def2a007d43a0aa445c28b766ed02))
+* clean up pending dial targets ([#1059](https://github.com/libp2p/js-libp2p/issues/1059)) ([bdc9f16](https://github.com/libp2p/js-libp2p/commit/bdc9f16d0cbe56ccf26822f11068e7795bcef046))
+* fix uncaught promise rejection when finding peers ([#1044](https://github.com/libp2p/js-libp2p/issues/1044)) ([3b683e7](https://github.com/libp2p/js-libp2p/commit/3b683e715686163e229b7b5c3a892327dfd4fc63))
+* increase the maxlisteners for timeout controllers ([#1065](https://github.com/libp2p/js-libp2p/issues/1065)) ([09a0f94](https://github.com/libp2p/js-libp2p/commit/09a0f940df7fdb4ece34604e85693709df5c213e))
+* main ci ([#1079](https://github.com/libp2p/js-libp2p/issues/1079)) ([d1c48dc](https://github.com/libp2p/js-libp2p/commit/d1c48dcbeded828f2dd3044cc9aed3f17f02846d))
+* make error codes consistent ([#1054](https://github.com/libp2p/js-libp2p/issues/1054)) ([b25e0fe](https://github.com/libp2p/js-libp2p/commit/b25e0fe5312db58a06c39500ae84c50fed3a93bd))
+* type definitions for big dialrequest and persistent peerstore ([#1078](https://github.com/libp2p/js-libp2p/issues/1078)) ([cb0d7d6](https://github.com/libp2p/js-libp2p/commit/cb0d7d6c99d179498f04e76df76e70e4f7d41c4c))
+
+
+### Features
+
+* allow per-component metrics to be collected ([#1061](https://github.com/libp2p/js-libp2p/issues/1061)) ([2f0b311](https://github.com/libp2p/js-libp2p/commit/2f0b311df7127aa44512c2008142d4ca30268986)), closes [#1060](https://github.com/libp2p/js-libp2p/issues/1060)
+
+
+
+## [0.35.6](https://github.com/libp2p/js-libp2p/compare/v0.35.5...v0.35.6) (2021-12-18)
+
+
+### Bug Fixes
+
+* increase the maxlisteners for timeout controllers ([#1065](https://github.com/libp2p/js-libp2p/issues/1065)) ([09a0f94](https://github.com/libp2p/js-libp2p/commit/09a0f940df7fdb4ece34604e85693709df5c213e))
+
+
+
+## [0.35.5](https://github.com/libp2p/js-libp2p/compare/v0.35.4...v0.35.5) (2021-12-15)
+
+
+
+## [0.35.4](https://github.com/libp2p/js-libp2p/compare/v0.35.3...v0.35.4) (2021-12-15)
+
+
+### Features
+
+* allow per-component metrics to be collected ([#1061](https://github.com/libp2p/js-libp2p/issues/1061)) ([2f0b311](https://github.com/libp2p/js-libp2p/commit/2f0b311df7127aa44512c2008142d4ca30268986)), closes [#1060](https://github.com/libp2p/js-libp2p/issues/1060)
+
+
+
+## [0.35.3](https://github.com/libp2p/js-libp2p/compare/v0.35.2...v0.35.3) (2021-12-13)
+
+
+### Bug Fixes
+
+* clean up pending dial targets ([#1059](https://github.com/libp2p/js-libp2p/issues/1059)) ([bdc9f16](https://github.com/libp2p/js-libp2p/commit/bdc9f16d0cbe56ccf26822f11068e7795bcef046))
+* fix uncaught promise rejection when finding peers ([#1044](https://github.com/libp2p/js-libp2p/issues/1044)) ([3b683e7](https://github.com/libp2p/js-libp2p/commit/3b683e715686163e229b7b5c3a892327dfd4fc63))
+* make error codes consistent ([#1054](https://github.com/libp2p/js-libp2p/issues/1054)) ([b25e0fe](https://github.com/libp2p/js-libp2p/commit/b25e0fe5312db58a06c39500ae84c50fed3a93bd))
+
+
+
+## [0.35.2](https://github.com/libp2p/js-libp2p/compare/v0.33.0...v0.35.2) (2021-12-06)
+
+
+### 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))
+* increase maxlisteners on event target ([#1050](https://github.com/libp2p/js-libp2p/issues/1050)) ([b70fb43](https://github.com/libp2p/js-libp2p/commit/b70fb43427b47df079b55929ec8956f69cbda966)), closes [#900](https://github.com/libp2p/js-libp2p/issues/900)
+* 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))
+* 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))
+
+
+### Features
+
+* update dht ([#1009](https://github.com/libp2p/js-libp2p/issues/1009)) ([2f598eb](https://github.com/libp2p/js-libp2p/commit/2f598eba09cff4301474af08196158065e3602d8))
+
+
+### BREAKING CHANGES
+
+* requires node 15+
+* libp2p-kad-dht has a new event-based API which is exposed as `_dht`
+
+
+
+## [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)


--- a/README.md
+++ b/README.md
@@ -23,8 +23,8 @@
  <a href="https://david-dm.org/libp2p/js-libp2p"><img src="https://david-dm.org/libp2p/js-libp2p.svg?style=flat-square" /></a>
  <a href="https://github.com/feross/standard"><img src="https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square"></a>
  <a href="https://github.com/RichardLitt/standard-readme"><img src="https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square" /></a>
-  <a href=""><img src="https://img.shields.io/badge/npm-%3E%3D6.0.0-orange.svg?style=flat-square" /></a>
-  <a href=""><img src="https://img.shields.io/badge/Node.js-%3E%3D12.0.0-orange.svg?style=flat-square" /></a>
+  <a href=""><img src="https://img.shields.io/badge/npm-%3E%3D7.0.0-orange.svg?style=flat-square" /></a>
+  <a href=""><img src="https://img.shields.io/badge/Node.js-%3E%3D15.0.0-orange.svg?style=flat-square" /></a>
  <br>
 </p>

@@ -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) |
--- a/doc/API.md
+++ b/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
--- a/doc/CONFIGURATION.md
+++ b/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
@@ -501,7 +497,10 @@ 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 LevelDatastore = require('datastore-level')
+
+const datastore = new LevelDatastore('path/to/store')
+await datastore.open()

 const node = await Libp2p.create({
  modules: {
@@ -511,7 +510,7 @@ const node = await Libp2p.create({
  },
  keychain: {
    pass: 'notsafepassword123456789',
-    datastore: new LevelStore('path/to/store')
+    datastore: dsInstant,
  }
 })

@@ -525,6 +524,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 +549,7 @@ const node = await Libp2p.create({
  },
  dialer: {
    maxParallelDials: 100,
+    maxAddrsToDial: 25,
    maxDialsPerPeer: 4,
    dialTimeout: 30e3,
    resolvers: {
@@ -671,16 +672,18 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
+const LevelDatastore = require('datastore-level')

-const LevelStore = require('datastore-level')
+const datastore = new LevelDatastore('path/to/store')
+await datastore.open() // level database must be ready before node boot

 const node = await Libp2p.create({
+  datastore, // pass the opened datastore
  modules: {
    transport: [TCP],
    streamMuxer: [MPLEX],
    connEncryption: [NOISE]
  },
-  datastore: new LevelStore('path/to/store'),
  peerStore: {
    persistence: true,
    threshold: 5
@@ -779,12 +782,32 @@ 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:

- [libp2p-ipfs-nodejs](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs/src/core/runtime/libp2p-nodejs.js) - libp2p configuration used by js-ipfs when running in Node.js
- [libp2p-ipfs-browser](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs/src/core/runtime/libp2p-browser.js) - libp2p configuration used by js-ipfs when running in a Browser (that supports WebRTC)
+- [libp2p-ipfs-nodejs](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs-core-config/src/libp2p.js) - libp2p configuration used by js-ipfs when running in Node.js
+- [libp2p-ipfs-browser](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs-core-config/src/libp2p.browser.js) - libp2p configuration used by js-ipfs when running in a Browser (that supports WebRTC)

 If you have developed a project using `js-libp2p`, please consider submitting your configuration to this list so that it can be found easily by other users.

--- a/doc/migrations/v0.31-v0.32.md
+++ b/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.
--- a/doc/migrations/v0.32-v0.33.md
+++ b/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.
--- a/examples/auto-relay/README.md
+++ b/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:
--- a/examples/auto-relay/dialer.js
+++ b/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 () {
--- a/examples/auto-relay/listener.js
+++ b/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 () {
--- a/examples/auto-relay/relay.js
+++ b/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 () {
--- a/examples/auto-relay/test.js
+++ b/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], {
--- a/examples/chat/src/dialer.js
+++ b/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')
--- a/examples/chat/src/libp2p.js
+++ b/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('../../..')

--- a/examples/chat/src/listener.js
+++ b/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({
--- a/examples/chat/test.js
+++ b/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)], {
--- a/examples/connection-encryption/1.js
+++ b/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')

--- a/examples/connection-encryption/README.md
+++ b/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({
--- a/examples/connection-encryption/test.js
+++ b/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()
--- a/examples/delegated-routing/package.json
+++ b/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",
--- a/examples/discovery-mechanisms/1.js
+++ b/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')
--- a/examples/discovery-mechanisms/2.js
+++ b/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 () => {
--- a/examples/discovery-mechanisms/3.js
+++ b/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')
--- a/examples/discovery-mechanisms/README.md
+++ b/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')
--- a/examples/discovery-mechanisms/test-1.js
+++ b/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:'
--- a/examples/discovery-mechanisms/test-2.js
+++ b/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:'

--- a/examples/discovery-mechanisms/test-3.js
+++ b/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:'

--- a/examples/echo/src/libp2p.js
+++ b/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('../../..')
--- a/examples/echo/test.js
+++ b/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)], {
--- a/examples/libp2p-in-the-browser/index.html
+++ b/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>

--- a/examples/libp2p-in-the-browser/index.js
+++ b/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'

--- a/examples/libp2p-in-the-browser/package.json
+++ b/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"
  }
 }
--- a/examples/libp2p-in-the-browser/test.js
+++ b/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 {
--- a/examples/package.json
+++ b/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"
  }
 }
--- a/examples/peer-and-content-routing/1.js
+++ b/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')
--- a/examples/peer-and-content-routing/2.js
+++ b/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)
--- a/examples/peer-and-content-routing/README.md
+++ b/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 }))

--- a/examples/peer-and-content-routing/test-1.js
+++ b/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')
--- a/examples/peer-and-content-routing/test-2.js
+++ b/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:'
--- a/examples/pnet/libp2p-node.js
+++ b/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')

 /**
--- a/examples/pnet/test.js
+++ b/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()
--- a/examples/protocol-and-stream-muxing/1.js
+++ b/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')

--- a/examples/protocol-and-stream-muxing/2.js
+++ b/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')

--- a/examples/protocol-and-stream-muxing/3.js
+++ b/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')

--- a/examples/protocol-and-stream-muxing/test-1.js
+++ b/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()
--- a/examples/protocol-and-stream-muxing/test-2.js
+++ b/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)',
--- a/examples/protocol-and-stream-muxing/test-3.js
+++ b/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',
--- a/examples/pubsub/1.js
+++ b/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({
@@ -41,13 +41,13 @@ const createNode = async () => {
  node1.pubsub.on(topic, (msg) => {
    console.log(`node1 received: ${uint8ArrayToString(msg.data)}`)
  })
-  await node1.pubsub.subscribe(topic)
+  node1.pubsub.subscribe(topic)

  // Will not receive own published messages by default
  node2.pubsub.on(topic, (msg) => {
    console.log(`node2 received: ${uint8ArrayToString(msg.data)}`)
  })
-  await node2.pubsub.subscribe(topic)
+  node2.pubsub.subscribe(topic)

  // node2 publishes "news" every second
  setInterval(() => {
--- a/examples/pubsub/README.md
+++ b/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).
--- a/examples/pubsub/message-filtering/1.js
+++ b/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({
--- a/examples/pubsub/message-filtering/test.js
+++ b/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 = [
  {
--- a/examples/pubsub/test-1.js
+++ b/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()
--- a/examples/transports/1.js
+++ b/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({
--- a/examples/transports/2.js
+++ b/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')
--- a/examples/transports/3.js
+++ b/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)
  }
 })();
--- a/examples/transports/4.js
+++ b/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
+  )
+})();
--- a/examples/transports/README.md
+++ b/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({
--- a/examples/transports/test-1.js
+++ b/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()
--- a/examples/transports/test-2.js
+++ b/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()
--- a/examples/transports/test-3.js
+++ b/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()
--- a/examples/transports/test-4.js
+++ b/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
--- a/examples/transports/test.js
+++ b/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
--- a/examples/transports/test_certs/cert.pem
+++ b/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-----
--- a/examples/transports/test_certs/key.pem
+++ b/examples/transports/test_certs/key.pem
@@ -0,0 +1,52 @@
+-----BEGIN PRIVATE KEY-----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+-----END PRIVATE KEY-----
--- a/examples/utils.js
+++ b/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
    }
--- a/examples/webrtc-direct/dialer.js
+++ b/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 () => {
--- a/examples/webrtc-direct/index.html
+++ b/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>
--- a/examples/webrtc-direct/listener.js
+++ b/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 () => {
--- a/examples/webrtc-direct/package.json
+++ b/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"
--- a/examples/webrtc-direct/test.js
+++ b/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 {
--- a/package-list.json
+++ b/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"],
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "libp2p",
-  "version": "0.31.6",
+  "version": "0.35.7",
  "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,33 +66,33 @@
  "homepage": "https://libp2p.io",
  "license": "MIT",
  "engines": {
-    "node": ">=14.0.0"
+    "node": ">=15.0.0"
  },
  "browser": {
-    "@motrix/nat-api": false
+    "nat-api": false
  },
  "eslintConfig": {
    "extends": "ipfs",
    "ignorePatterns": [
      "!.aegir.js",
-      "test/ts-use"
+      "test/ts-use",
+      "*.d.ts"
    ]
  },
  "dependencies": {
-    "@motrix/nat-api": "^0.3.1",
+    "@vascosantos/moving-average": "^1.1.0",
    "abort-controller": "^3.0.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": "^7.0.0",
+    "interface-datastore": "^6.0.2",
    "it-all": "^1.0.4",
    "it-buffer": "^0.1.2",
    "it-drain": "^1.0.3",
@@ -100,77 +101,78 @@
    "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",
+    "nat-api": "^0.3.1",
    "node-forge": "^0.10.0",
    "p-any": "^3.0.0",
    "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": "^5.0.0",
    "@nodeutils/defaults-deep": "^1.1.0",
    "@types/es6-promisify": "^6.0.0",
-    "@types/node-forge": "^0.9.7",
+    "@types/node": "^16.0.1",
+    "@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.4.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.1",
+    "libp2p-floodsub": "^0.28.0",
+    "libp2p-gossipsub": "^0.12.1",
+    "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,49 +182,75 @@
    "Maciej Krüger <mkg20001@gmail.com>",
    "Hugo Dias <mail@hugodias.me>",
    "Volker Mische <volker.mische@gmail.com>",
+    "Chris Dostert <chrisdostert@users.noreply.github.com>",
    "dirkmc <dirkmdev@gmail.com>",
+    "Robert Kiel <robert.kiel@hoprnet.org>",
    "Richard Littauer <richard.littauer@gmail.com>",
+    "zeim839 <50573884+zeim839@users.noreply.github.com>",
    "a1300 <matthias-knopp@gmx.net>",
+    "Ryan Bell <ryan@piing.net>",
    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
    "Andrew Nesbitt <andrewnez@gmail.com>",
-    "Elven <mon.samuel@qq.com>",
-    "Giovanni T. Parra <fiatjaf@gmail.com>",
-    "Ryan Bell <ryan@piing.net>",
-    "Samlior <samlior@foxmail.com>",
+    "Franck Royer <franck@royer.one>",
    "Thomas Eizinger <thomas@eizinger.io>",
-    "Didrik Nordström <didrik@betamos.se>",
-    "Felipe Martins <felipebrasil93@gmail.com>",
+    "Vít Habada <vithabada93@gmail.com>",
+    "Giovanni T. Parra <fiatjaf@gmail.com>",
+    "acolytec3 <17355484+acolytec3@users.noreply.github.com>",
+    "Alan Smithee <ggnore.alan.smithee@gmail.com>",
+    "Elven <mon.samuel@qq.com>",
+    "Samlior <samlior@foxmail.com>",
+    "Didrik Nordström <didrik.nordstrom@gmail.com>",
+    "Aditya Bose <13054902+adbose@users.noreply.github.com>",
+    "TJKoury <TJKoury@gmail.com>",
+    "TheStarBoys <41286328+TheStarBoys@users.noreply.github.com>",
+    "Tiago Alves <alvesjtiago@gmail.com>",
+    "Tim Daubenschütz <tim@daubenschuetz.de>",
+    "XiaoZhang <zxinmyth@gmail.com>",
+    "Yusef Napora <yusef@napora.org>",
+    "Zane Starr <zcstarr@gmail.com>",
+    "ebinks <elizabethjbinks@gmail.com>",
+    "greenSnot <greenSnot@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>",
+    "shresthagrawal <34920931+shresthagrawal@users.noreply.github.com>",
+    "swedneck <40505480+swedneck@users.noreply.github.com>",
+    "tuyennhv <vutuyen2636@gmail.com>",
+    "Sönke Hahn <soenkehahn@gmail.com>",
+    "Aleksei <vozhdb@gmail.com>",
+    "Bernd Strehl <bernd.strehl@gmail.com>",
+    "Chris Bratlien <chrisbratlien@gmail.com>",
+    "Cindy Wu <ciindy.wu@gmail.com>",
+    "Daijiro Wachi <daijiro.wachi@gmail.com>",
+    "Diogo Silva <fsdiogo@gmail.com>",
+    "Dmitriy Ryajov <dryajov@gmail.com>",
+    "Ethan Lam <elmemphis2000@gmail.com>",
    "Fei Liu <liu.feiwood@gmail.com>",
+    "Felipe Martins <felipebrasil93@gmail.com>",
+    "Florian-Merle <florian.david.merle@gmail.com>",
+    "Francis Gulotta <wizard@roborooter.com>",
+    "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>",
-    "Ethan Lam <elmemphis2000@gmail.com>",
+    "Lars Gierth <lgierth@users.noreply.github.com>",
+    "Leask Wong <i@leaskh.com>",
+    "Marcin Tojek <mtojek@users.noreply.github.com>",
+    "Marston Connell <34043723+TheMarstonConnell@users.noreply.github.com>",
+    "Michael Burns <5170+mburns@users.noreply.github.com>",
    "Miguel Mota <miguelmota2@gmail.com>",
    "Nuno Nogueira <nunofmn@gmail.com>",
-    "Dmitriy Ryajov <dryajov@gmail.com>",
    "Philipp Muens <raute1337@gmx.de>",
    "RasmusErik Voel Jensen <github@solsort.com>",
-    "Diogo Silva <fsdiogo@gmail.com>",
-    "robertkiel <robert.kiel@validitylabs.org>",
    "Smite Chow <xiaopengyou@live.com>",
-    "Soeren <nikorpoulsen@gmail.com>",
-    "Sönke Hahn <soenkehahn@gmail.com>",
-    "TJKoury <TJKoury@gmail.com>",
-    "Tiago Alves <alvesjtiago@gmail.com>",
-    "Daijiro Wachi <daijiro.wachi@gmail.com>",
-    "Yusef Napora <yusef@napora.org>",
-    "Zane Starr <zcstarr@gmail.com>",
-    "Aleksei <vozhdb@gmail.com>",
-    "Cindy Wu <ciindy.wu@gmail.com>",
-    "Chris Bratlien <chrisbratlien@gmail.com>",
-    "ebinks <elizabethjbinks@gmail.com>",
-    "Bernd Strehl <bernd.strehl@gmail.com>",
-    "Francis Gulotta <wizard@roborooter.com>",
-    "Franck Royer <franck@royer.one>",
-    "Florian-Merle <florian.david.merle@gmail.com>",
-    "isan_rivkin <isanrivkin@gmail.com>",
-    "Henrique Dias <hacdias@gmail.com>",
-    "Irakli Gozalishvili <rfobic@gmail.com>"
+    "Soeren <nikorpoulsen@gmail.com>"
  ]
 }
--- a/src/circuit/auto-relay.js
+++ b/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()}`)
    }
  }
--- a/src/circuit/circuit/hop.js
+++ b/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)
  }

--- a/src/circuit/circuit/stop.js
+++ b/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)
  }

--- a/src/circuit/circuit/utils.js
+++ b/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)
--- a/src/circuit/index.js
+++ b/src/circuit/index.js
@@ -4,7 +4,7 @@ const debug = require('debug')
 const log = Object.assign(debug('libp2p:relay'), {
  error: debug('libp2p:relay:err')
 })
-
+const { codes } = require('./../errors')
 const {
  setDelayedInterval,
  clearDelayedInterval
@@ -87,8 +87,8 @@ class Relay {
    try {
      const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
      await this._libp2p.contentRouting.provide(cid)
-    } catch (err) {
-      if (err.code === 'NO_ROUTERS_AVAILABLE') {
+    } catch (/** @type {any} */ err) {
+      if (err.code === codes.ERR_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
        this.stop()
--- a/src/circuit/transport.js
+++ b/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
--- a/src/circuit/utils.js
+++ b/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)
 }
--- a/src/config.js
+++ b/src/config.js
@@ -57,15 +57,10 @@ const DefaultConfig = {
    }
  },
  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,
--- a/src/connection-manager/auto-dialler.js
+++ b/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
--- a/src/connection-manager/index.js
+++ b/src/connection-manager/index.js
@@ -12,7 +12,7 @@ const LatencyMonitor = require('./latency-monitor')
 const retimer = require('retimer')

 const { EventEmitter } = require('events')
-
+const trackedMap = require('../metrics/tracked-map')
 const PeerId = require('peer-id')

 const {
@@ -32,6 +32,10 @@ const defaultOptions = {
  defaultPeerValue: 1
 }

+const METRICS_COMPONENT = 'connection-manager'
+const METRICS_PEER_CONNECTIONS = 'peer-connections'
+const METRICS_PEER_VALUES = 'peer-values'
+
 /**
 * @typedef {import('../')} Libp2p
 * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
@@ -83,20 +87,23 @@ class ConnectionManager extends EventEmitter {
     *
     * @type {Map<string, number>}
     */
-    this._peerValues = new Map()
+    this._peerValues = trackedMap(METRICS_COMPONENT, METRICS_PEER_VALUES, this._libp2p.metrics)

    /**
     * Map of connections per peer
     *
     * @type {Map<string, Connection[]>}
     */
-    this.connections = new Map()
+    this.connections = trackedMap(METRICS_COMPONENT, METRICS_PEER_CONNECTIONS, this._libp2p.metrics)

    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 +124,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 +138,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()
@@ -212,6 +215,7 @@ class ConnectionManager extends EventEmitter {
    const storedConn = this.connections.get(peerIdStr)

    this.emit('peer:connect', connection)
+
    if (storedConn) {
      storedConn.push(connection)
    } else {
@@ -244,6 +248,8 @@ class ConnectionManager extends EventEmitter {
      this.connections.delete(peerId)
      this._peerValues.delete(connection.remotePeer.toB58String())
      this.emit('peer:disconnect', connection)
+
+      this._libp2p.metrics && this._libp2p.metrics.onPeerDisconnected(connection.remotePeer)
    }
  }

@@ -308,53 +314,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.
--- a/src/connection-manager/latency-monitor.js
+++ b/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
   *
--- a/src/constants.js
+++ b/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,
--- a/src/content-routing/index.js
+++ b/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))
    }
  }

@@ -53,7 +54,7 @@ class ContentRouting {
   */
  async * findProviders (key, options = {}) {
    if (!this.routers.length) {
-      throw errCode(new Error('No content this.routers available'), 'NO_ROUTERS_AVAILABLE')
+      throw errCode(new Error('No content this.routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
    }

    yield * pipe(
@@ -76,7 +77,7 @@ class ContentRouting {
   */
  async provide (key) {
    if (!this.routers.length) {
-      throw errCode(new Error('No content routers available'), 'NO_ROUTERS_AVAILABLE')
+      throw errCode(new Error('No content routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
    }

    await Promise.all(this.routers.map((router) => router.provide(key)))
@@ -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)
+    }
  }
 }

--- a/src/dht/dht-content-routing.js
+++ b/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 }
--- a/src/dht/dht-peer-routing.js
+++ b/src/dht/dht-peer-routing.js
@@ -0,0 +1,55 @@
+'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 === 'PEER_RESPONSE') {
+        const peer = event.closer.find(peerData => peerData.id.equals(peerId))
+
+        if (peer) {
+          return 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 }
--- a/src/dialer/dial-request.js
+++ b/src/dialer/dial-request.js
@@ -1,11 +1,13 @@
 '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')
 const pAny = require('p-any')
+// @ts-expect-error setMaxListeners is missing from the types
+const { setMaxListeners } = require('events')
+const { codes } = require('../errors')

 /**
 * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
@@ -54,12 +56,17 @@ class DialRequest {
    const tokens = this.dialer.getTokens(this.addrs.length)
    // If no tokens are available, throw
    if (tokens.length < 1) {
-      throw errCode(new Error('No dial tokens available'), 'ERR_NO_DIAL_TOKENS')
+      throw errCode(new Error('No dial tokens available'), codes.ERR_NO_DIAL_TOKENS)
    }

    const tokenHolder = new FIFO()
    tokens.forEach(token => tokenHolder.push(token))
-    const dialAbortControllers = this.addrs.map(() => new AbortController())
+    const dialAbortControllers = this.addrs.map(() => {
+      const controller = new AbortController()
+      setMaxListeners && setMaxListeners(Infinity, controller.signal)
+
+      return controller
+    })
    let completedDials = 0

    try {
--- a/src/dialer/index.js
+++ b/src/dialer/index.js
@@ -6,21 +6,27 @@ 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')
-
+// @ts-expect-error setMaxListeners is missing from the types
+const { setMaxListeners } = require('events')
 const DialRequest = require('./dial-request')
 const { publicAddressesFirst } = require('libp2p-utils/src/address-sort')
 const getPeer = require('../get-peer')
-
+const trackedMap = require('../metrics/tracked-map')
 const { codes } = require('../errors')
 const {
  DIAL_TIMEOUT,
  MAX_PARALLEL_DIALS,
-  MAX_PER_PEER_DIALS
+  MAX_PER_PEER_DIALS,
+  MAX_ADDRS_TO_DIAL
 } = require('../constants')

+const METRICS_COMPONENT = 'dialler'
+const METRICS_PENDING_DIALS = 'pending-dials'
+const METRICS_PENDING_DIAL_TARGETS = 'pending-dial-targets'
+
 /**
 * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
 * @typedef {import('peer-id')} PeerId
@@ -39,17 +45,19 @@ 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
+ * @property {import('../metrics')} [metrics]
 *
 * @typedef DialTarget
 * @property {string} id
 * @property {Multiaddr[]} addrs
 *
 * @typedef PendingDial
- * @property {DialRequest} dialRequest
- * @property {TimeoutController} controller
+ * @property {import('./dial-request')} dialRequest
+ * @property {import('timeout-abort-controller').TimeoutController} controller
 * @property {Promise<Connection>} promise
 * @property {function():void} destroy
 */
@@ -64,18 +72,26 @@ class Dialer {
    peerStore,
    addressSorter = publicAddressesFirst,
    maxParallelDials = MAX_PARALLEL_DIALS,
+    maxAddrsToDial = MAX_ADDRS_TO_DIAL,
    dialTimeout = DIAL_TIMEOUT,
    maxDialsPerPeer = MAX_PER_PEER_DIALS,
-    resolvers = {}
+    resolvers = {},
+    metrics
  }) {
    this.transportManager = transportManager
    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()
+
+    /** @type {Map<string, PendingDial>} */
+    this._pendingDials = trackedMap(METRICS_COMPONENT, METRICS_PENDING_DIALS, metrics)
+
+    /** @type {Map<string, { resolve: (value: any) => void, reject: (err: Error) => void}>} */
+    this._pendingDialTargets = trackedMap(METRICS_COMPONENT, METRICS_PENDING_DIAL_TARGETS, metrics)

    for (const [key, value] of Object.entries(resolvers)) {
      Multiaddr.resolvers.set(key, value)
@@ -89,11 +105,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 +128,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 +139,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 +151,33 @@ 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 })
+    })
+
+    try {
+      const dialTarget = await Promise.race([
+        this._createDialTarget(peer),
+        cancellablePromise
+      ])
+
+      return dialTarget
+    } finally {
+      this._pendingDialTargets.delete(id)
+    }
+  }
+
  /**
   * Creates a DialTarget. The DialTarget is used to create and track
   * the DialRequest to a given peer.
@@ -166,6 +214,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
@@ -199,6 +252,10 @@ class Dialer {

    // Combine the timeout signal and options.signal, if provided
    const timeoutController = new TimeoutController(this.timeout)
+    // this controller will potentially be used while dialing lots of
+    // peers so prevent MaxListenersExceededWarning appearing in the console
+    setMaxListeners && setMaxListeners(Infinity, timeoutController.signal)
+
    const signals = [timeoutController.signal]
    options.signal && signals.push(options.signal)
    const signal = anySignal(signals)
@@ -213,6 +270,7 @@ class Dialer {
      }
    }
    this._pendingDials.set(dialTarget.id, pendingDial)
+
    return pendingDial
  }

--- a/src/errors.js
+++ b/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,10 +30,35 @@ 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',
  ERR_UNSUPPORTED_PROTOCOL: 'ERR_UNSUPPORTED_PROTOCOL',
  ERR_INVALID_MULTIADDR: 'ERR_INVALID_MULTIADDR',
-  ERR_SIGNATURE_NOT_VALID: 'ERR_SIGNATURE_NOT_VALID'
+  ERR_SIGNATURE_NOT_VALID: 'ERR_SIGNATURE_NOT_VALID',
+  ERR_FIND_SELF: 'ERR_FIND_SELF',
+  ERR_NO_ROUTERS_AVAILABLE: 'ERR_NO_ROUTERS_AVAILABLE',
+  ERR_CONNECTION_NOT_MULTIPLEXED: 'ERR_CONNECTION_NOT_MULTIPLEXED',
+  ERR_NO_DIAL_TOKENS: 'ERR_NO_DIAL_TOKENS',
+  ERR_KEYCHAIN_REQUIRED: 'ERR_KEYCHAIN_REQUIRED',
+  ERR_INVALID_CMS: 'ERR_INVALID_CMS',
+  ERR_MISSING_KEYS: 'ERR_MISSING_KEYS',
+  ERR_NO_KEY: 'ERR_NO_KEY',
+  ERR_INVALID_KEY_NAME: 'ERR_INVALID_KEY_NAME',
+  ERR_INVALID_KEY_TYPE: 'ERR_INVALID_KEY_TYPE',
+  ERR_KEY_ALREADY_EXISTS: 'ERR_KEY_ALREADY_EXISTS',
+  ERR_INVALID_KEY_SIZE: 'ERR_INVALID_KEY_SIZE',
+  ERR_KEY_NOT_FOUND: 'ERR_KEY_NOT_FOUND',
+  ERR_OLD_KEY_NAME_INVALID: 'ERR_OLD_KEY_NAME_INVALID',
+  ERR_NEW_KEY_NAME_INVALID: 'ERR_NEW_KEY_NAME_INVALID',
+  ERR_PASSWORD_REQUIRED: 'ERR_PASSWORD_REQUIRED',
+  ERR_PEM_REQUIRED: 'ERR_PEM_REQUIRED',
+  ERR_CANNOT_READ_KEY: 'ERR_CANNOT_READ_KEY',
+  ERR_MISSING_PRIVATE_KEY: 'ERR_MISSING_PRIVATE_KEY',
+  ERR_INVALID_OLD_PASS_TYPE: 'ERR_INVALID_OLD_PASS_TYPE',
+  ERR_INVALID_NEW_PASS_TYPE: 'ERR_INVALID_NEW_PASS_TYPE',
+  ERR_INVALID_PASS_LENGTH: 'ERR_INVALID_PASS_LENGTH',
+  ERR_NOT_IMPLEMENTED: 'ERR_NOT_IMPLEMENTED',
+  ERR_WRONG_PING_ACK: 'ERR_WRONG_PING_ACK'
 }
--- a/src/get-peer.js
+++ b/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
--- a/src/identify/consts.js
+++ b/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'
--- a/src/identify/index.js
+++ b/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)
    }

@@ -193,14 +211,14 @@ class IdentifyService {
        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)
    }

@@ -224,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)
@@ -269,7 +287,7 @@ class IdentifyService {
        stream,
        consume
      )
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      log.error('could not respond to identify request', err)
    }
  }
@@ -295,7 +313,7 @@ class IdentifyService {
        collect
      )
      message = Message.Identify.decode(data)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      return log.error('received invalid message', err)
    }

@@ -307,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)
    }

@@ -315,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)
    }

--- a/src/index.js
+++ b/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')

@@ -48,6 +48,8 @@ const { updateSelfPeerRecord } = require('./record/utils')
 * @typedef {import('libp2p-interfaces/src/pubsub').PubsubOptions} PubsubOptions
 * @typedef {import('interface-datastore').Datastore} Datastore
 * @typedef {import('./pnet')} Protector
+ * @typedef {Object} PersistentPeerStoreOptions
+ * @property {number} [threshold]
 */

 /**
@@ -56,16 +58,9 @@ const { updateSelfPeerRecord } = require('./record/utils')
 * @property {MuxedStream} stream
 * @property {string} protocol
 *
- * @typedef {Object} RandomWalkOptions
- * @property {boolean} [enabled = false]
- * @property {number} [queriesPerPeriod = 1]
- * @property {number} [interval = 300e3]
- * @property {number} [timeout = 10e3]
- *
 * @typedef {Object} DhtOptions
 * @property {boolean} [enabled = false]
 * @property {number} [kBucketSize = 20]
- * @property {RandomWalkOptions} [randomWalk]
 * @property {boolean} [clientMode]
 * @property {import('libp2p-interfaces/src/types').DhtSelectors} [selectors]
 * @property {import('libp2p-interfaces/src/types').DhtValidators} [validators]
@@ -117,7 +112,7 @@ const { updateSelfPeerRecord } = require('./record/utils')
 * @property {KeychainOptions & import('./keychain/index').KeychainOptions} [keychain]
 * @property {MetricsOptions & import('./metrics').MetricsOptions} [metrics]
 * @property {import('./peer-routing').PeerRoutingOptions} [peerRouting]
- * @property {PeerStoreOptions & import('./peer-store/persistent').PersistentPeerStoreOptions} [peerStore]
+ * @property {PeerStoreOptions & PersistentPeerStoreOptions} [peerStore]
 * @property {import('./transport-manager').TransportManagerOptions} [transportManager]
 * @property {Libp2pConfig} [config]
 *
@@ -168,6 +163,15 @@ class Libp2p extends EventEmitter {
    this.peerId = this._options.peerId
    this.datastore = this._options.datastore

+    // Create Metrics
+    if (this._options.metrics.enabled) {
+      const metrics = new Metrics({
+        ...this._options.metrics
+      })
+
+      this.metrics = metrics
+    }
+
    this.peerStore = (this.datastore && this._options.peerStore.persistence)
      ? new PersistentPeerStore({
        peerId: this.peerId,
@@ -194,17 +198,13 @@ class Libp2p extends EventEmitter {

    // Create the Connection Manager
    this.connectionManager = new ConnectionManager(this, {
-      autoDial: this._config.peerDiscovery.autoDial,
      ...this._options.connectionManager
    })
-
-    // Create Metrics
-    if (this._options.metrics.enabled) {
-      this.metrics = new Metrics({
-        ...this._options.metrics,
-        connectionManager: this.connectionManager
-      })
-    }
+    this._autodialler = new AutoDialler(this, {
+      enabled: this._config.peerDiscovery.autoDial,
+      minConnections: this._options.connectionManager.minConnections,
+      autoDialInterval: this._options.connectionManager.autoDialInterval
+    })

    // Create keychain
    if (this._options.keychain && this._options.keychain.datastore) {
@@ -265,6 +265,7 @@ class Libp2p extends EventEmitter {
    this.dialer = new Dialer({
      transportManager: this.transportManager,
      peerStore: this.peerStore,
+      metrics: this.metrics,
      ...this._options.dialer
    })

@@ -289,7 +290,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 +303,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 +360,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()
@@ -386,6 +382,8 @@ class Libp2p extends EventEmitter {

      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 +398,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 +406,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 +429,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 +622,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,6 +653,7 @@ class Libp2p extends EventEmitter {
    }

    this.connectionManager.start()
+    this._autodialler.start()

    // Peer discovery
    await this._setupPeerDiscovery()
@@ -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}`)
        }
      }
--- a/src/insecure/plaintext.js
+++ b/src/insecure/plaintext.js
@@ -55,7 +55,7 @@ async function encrypt (localId, conn, remoteId) {
  let peerId
  try {
    peerId = await PeerId.createFromPubKey(id.pubkey.Data)
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
    log.error(err)
    throw new InvalidCryptoExchangeError('Remote did not provide its public key')
  }
--- a/src/keychain/cms.js
+++ b/src/keychain/cms.js
@@ -8,8 +8,9 @@ require('node-forge/lib/pbe')
 const forge = require('node-forge/lib/forge')
 const { certificateForKey, findAsync } = require('./util')
 const errcode = require('err-code')
-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 { codes } = require('../errors')

 const privates = new WeakMap()

@@ -31,7 +32,7 @@ class CMS {
   */
  constructor (keychain, dek) {
    if (!keychain) {
-      throw errcode(new Error('keychain is required'), 'ERR_KEYCHAIN_REQUIRED')
+      throw errcode(new Error('keychain is required'), codes.ERR_KEYCHAIN_REQUIRED)
    }

    this.keychain = keychain
@@ -49,7 +50,7 @@ class CMS {
   */
  async encrypt (name, plain) {
    if (!(plain instanceof Uint8Array)) {
-      throw errcode(new Error('Plain data must be a Uint8Array'), 'ERR_INVALID_PARAMS')
+      throw errcode(new Error('Plain data must be a Uint8Array'), codes.ERR_INVALID_PARAMETERS)
    }

    const key = await this.keychain.findKeyByName(name)
@@ -81,7 +82,7 @@ class CMS {
   */
  async decrypt (cmsData) {
    if (!(cmsData instanceof Uint8Array)) {
-      throw errcode(new Error('CMS data is required'), 'ERR_INVALID_PARAMS')
+      throw errcode(new Error('CMS data is required'), codes.ERR_INVALID_PARAMETERS)
    }

    let cms
@@ -90,8 +91,8 @@ class CMS {
      const obj = forge.asn1.fromDer(buf)
      // @ts-ignore not defined
      cms = forge.pkcs7.messageFromAsn1(obj)
-    } catch (err) {
-      throw errcode(new Error('Invalid CMS: ' + err.message), 'ERR_INVALID_CMS')
+    } catch (/** @type {any} */ err) {
+      throw errcode(new Error('Invalid CMS: ' + err.message), codes.ERR_INVALID_CMS)
    }

    // Find a recipient whose key we hold. We only deal with recipient certs
@@ -114,7 +115,7 @@ class CMS {
      try {
        const key = await this.keychain.findKeyById(recipient.keyId)
        if (key) return true
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        return false
      }
      return false
@@ -123,7 +124,7 @@ class CMS {
    if (!r) {
      // @ts-ignore cms types not defined
      const missingKeys = recipients.map(r => r.keyId)
-      throw errcode(new Error('Decryption needs one of the key(s): ' + missingKeys.join(', ')), 'ERR_MISSING_KEYS', {
+      throw errcode(new Error('Decryption needs one of the key(s): ' + missingKeys.join(', ')), codes.ERR_MISSING_KEYS, {
        missingKeys
      })
    }
@@ -131,7 +132,7 @@ class CMS {
    const key = await this.keychain.findKeyById(r.keyId)

    if (!key) {
-      throw errcode(new Error('No key available to decrypto'), 'ERR_NO_KEY')
+      throw errcode(new Error('No key available to decrypto'), codes.ERR_NO_KEY)
    }

    const pem = await this.keychain._getPrivateKey(key.name)
--- a/src/keychain/index.js
+++ b/src/keychain/index.js
@@ -7,11 +7,12 @@ const log = Object.assign(debug('libp2p:keychain'), {
 const sanitize = require('sanitize-filename')
 const mergeOptions = require('merge-options')
 const crypto = require('libp2p-crypto')
-const { Key } = require('interface-datastore')
+const { Key } = require('interface-datastore/key')
 const CMS = require('./cms')
 const errcode = require('err-code')
-const uint8ArrayToString = require('uint8arrays/to-string')
-const uint8ArrayFromString = require('uint8arrays/from-string')
+const { codes } = require('../errors')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
+const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')

 // @ts-ignore node-forge sha512 types not exported
 require('node-forge/lib/sha512')
@@ -210,21 +211,21 @@ class Keychain {
    const self = this

    if (!validateKeyName(name) || name === 'self') {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
    }

    if (typeof type !== 'string') {
-      return throwDelayed(errcode(new Error(`Invalid key type '${type}'`), 'ERR_INVALID_KEY_TYPE'))
+      return throwDelayed(errcode(new Error(`Invalid key type '${type}'`), codes.ERR_INVALID_KEY_TYPE))
    }

    const dsname = DsName(name)
    const exists = await self.store.has(dsname)
-    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))

    switch (type.toLowerCase()) {
      case 'rsa':
        if (!Number.isSafeInteger(size) || size < 2048) {
-          return throwDelayed(errcode(new Error(`Invalid RSA key size ${size}`), 'ERR_INVALID_KEY_SIZE'))
+          return throwDelayed(errcode(new Error(`Invalid RSA key size ${size}`), codes.ERR_INVALID_KEY_SIZE))
        }
        break
      default:
@@ -248,7 +249,7 @@ class Keychain {
      batch.put(DsInfoName(name), uint8ArrayFromString(JSON.stringify(keyInfo)))

      await batch.commit()
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      return throwDelayed(err)
    }

@@ -284,7 +285,7 @@ class Keychain {
    try {
      const keys = await this.listKeys()
      return keys.find((k) => k.id === id)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      return throwDelayed(err)
    }
  }
@@ -297,15 +298,15 @@ class Keychain {
   */
  async findKeyByName (name) {
    if (!validateKeyName(name)) {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
    }

    const dsname = DsInfoName(name)
    try {
      const res = await this.store.get(dsname)
      return JSON.parse(uint8ArrayToString(res))
-    } catch (err) {
-      return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), 'ERR_KEY_NOT_FOUND'))
+    } catch (/** @type {any} */ err) {
+      return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), codes.ERR_KEY_NOT_FOUND))
    }
  }

@@ -318,7 +319,7 @@ class Keychain {
  async removeKey (name) {
    const self = this
    if (!validateKeyName(name) || name === 'self') {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
    }
    const dsname = DsName(name)
    const keyInfo = await self.findKeyByName(name)
@@ -339,10 +340,10 @@ class Keychain {
  async renameKey (oldName, newName) {
    const self = this
    if (!validateKeyName(oldName) || oldName === 'self') {
-      return throwDelayed(errcode(new Error(`Invalid old key name '${oldName}'`), 'ERR_OLD_KEY_NAME_INVALID'))
+      return throwDelayed(errcode(new Error(`Invalid old key name '${oldName}'`), codes.ERR_OLD_KEY_NAME_INVALID))
    }
    if (!validateKeyName(newName) || newName === 'self') {
-      return throwDelayed(errcode(new Error(`Invalid new key name '${newName}'`), 'ERR_NEW_KEY_NAME_INVALID'))
+      return throwDelayed(errcode(new Error(`Invalid new key name '${newName}'`), codes.ERR_NEW_KEY_NAME_INVALID))
    }
    const oldDsname = DsName(oldName)
    const newDsname = DsName(newName)
@@ -350,7 +351,7 @@ class Keychain {
    const newInfoName = DsInfoName(newName)

    const exists = await self.store.has(newDsname)
-    if (exists) return throwDelayed(errcode(new Error(`Key '${newName}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+    if (exists) return throwDelayed(errcode(new Error(`Key '${newName}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))

    try {
      const pem = await self.store.get(oldDsname)
@@ -365,7 +366,7 @@ class Keychain {
      batch.delete(oldInfoName)
      await batch.commit()
      return keyInfo
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      return throwDelayed(err)
    }
  }
@@ -379,10 +380,10 @@ class Keychain {
   */
  async exportKey (name, password) {
    if (!validateKeyName(name)) {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
    }
    if (!password) {
-      return throwDelayed(errcode(new Error('Password is required'), 'ERR_PASSWORD_REQUIRED'))
+      return throwDelayed(errcode(new Error('Password is required'), codes.ERR_PASSWORD_REQUIRED))
    }

    const dsname = DsName(name)
@@ -393,7 +394,7 @@ class Keychain {
      const dek = privates.get(this).dek
      const privateKey = await crypto.keys.import(pem, dek)
      return privateKey.export(password)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      return throwDelayed(err)
    }
  }
@@ -409,20 +410,20 @@ class Keychain {
  async importKey (name, pem, password) {
    const self = this
    if (!validateKeyName(name) || name === 'self') {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
    }
    if (!pem) {
-      return throwDelayed(errcode(new Error('PEM encoded key is required'), 'ERR_PEM_REQUIRED'))
+      return throwDelayed(errcode(new Error('PEM encoded key is required'), codes.ERR_PEM_REQUIRED))
    }
    const dsname = DsName(name)
    const exists = await self.store.has(dsname)
-    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))

    let privateKey
    try {
      privateKey = await crypto.keys.import(pem, password)
-    } catch (err) {
-      return throwDelayed(errcode(new Error('Cannot read the key, most likely the password is wrong'), 'ERR_CANNOT_READ_KEY'))
+    } catch (/** @type {any} */ err) {
+      return throwDelayed(errcode(new Error('Cannot read the key, most likely the password is wrong'), codes.ERR_CANNOT_READ_KEY))
    }

    let kid
@@ -431,7 +432,7 @@ class Keychain {
      /** @type {string} */
      const dek = privates.get(this).dek
      pem = await privateKey.export(dek)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      return throwDelayed(err)
    }

@@ -457,16 +458,16 @@ class Keychain {
  async importPeer (name, peer) {
    const self = this
    if (!validateKeyName(name)) {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
    }
    if (!peer || !peer.privKey) {
-      return throwDelayed(errcode(new Error('Peer.privKey is required'), 'ERR_MISSING_PRIVATE_KEY'))
+      return throwDelayed(errcode(new Error('Peer.privKey is required'), codes.ERR_MISSING_PRIVATE_KEY))
    }

    const privateKey = peer.privKey
    const dsname = DsName(name)
    const exists = await self.store.has(dsname)
-    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))

    try {
      const kid = await privateKey.id()
@@ -482,7 +483,7 @@ class Keychain {
      batch.put(DsInfoName(name), uint8ArrayFromString(JSON.stringify(keyInfo)))
      await batch.commit()
      return keyInfo
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      return throwDelayed(err)
    }
  }
@@ -495,15 +496,15 @@ class Keychain {
   */
  async _getPrivateKey (name) {
    if (!validateKeyName(name)) {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
    }

    try {
      const dsname = DsName(name)
      const res = await this.store.get(dsname)
      return uint8ArrayToString(res)
-    } catch (err) {
-      return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), 'ERR_KEY_NOT_FOUND'))
+    } catch (/** @type {any} */ err) {
+      return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), codes.ERR_KEY_NOT_FOUND))
    }
  }

@@ -515,13 +516,13 @@ class Keychain {
   */
  async rotateKeychainPass (oldPass, newPass) {
    if (typeof oldPass !== 'string') {
-      return throwDelayed(errcode(new Error(`Invalid old pass type '${typeof oldPass}'`), 'ERR_INVALID_OLD_PASS_TYPE'))
+      return throwDelayed(errcode(new Error(`Invalid old pass type '${typeof oldPass}'`), codes.ERR_INVALID_OLD_PASS_TYPE))
    }
    if (typeof newPass !== 'string') {
-      return throwDelayed(errcode(new Error(`Invalid new pass type '${typeof newPass}'`), 'ERR_INVALID_NEW_PASS_TYPE'))
+      return throwDelayed(errcode(new Error(`Invalid new pass type '${typeof newPass}'`), codes.ERR_INVALID_NEW_PASS_TYPE))
    }
    if (newPass.length < 20) {
-      return throwDelayed(errcode(new Error(`Invalid pass length ${newPass.length}`), 'ERR_INVALID_PASS_LENGTH'))
+      return throwDelayed(errcode(new Error(`Invalid pass length ${newPass.length}`), codes.ERR_INVALID_PASS_LENGTH))
    }
    log('recreating keychain')
    const oldDek = privates.get(this).dek
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Vasco Santos	bbdd559a02	chore: release version v0.35.7	2021-12-24 14:51:51 +00:00
Vasco Santos	4070dcdf55	chore: update contributors	2021-12-24 14:51:51 +00:00
tuyennhv	cb0d7d6c99	fix: type definitions for big dialrequest and persistent peerstore (#1078 ) Signed-off-by: Tuyen Nguyen <vutuyen2636@gmail.com>	2021-12-24 15:46:00 +01:00
Vasco Santos	d1c48dcbed	fix: main ci (#1079 )	2021-12-24 11:18:09 +01:00
Vít Habada	c4a442788b	docs: update example config ipfs links (#1077 )	2021-12-22 17:03:03 +01:00
Vít Habada	70a4bb9451	docs: peerstore configuration datastore fixed	2021-12-22 14:15:18 +01:00
Tim Daubenschütz	a0516ebc85	docs: update node and npm version badge according to package.json (#1074 )	2021-12-22 14:01:54 +01:00
Alex Potsides	b425fa1230	fix: add tracked map (#1069 ) Small refactor of the component stats - adds a `TrackedMap` which encapsulates updating the metrics and means we don't need to null guard on `this._metrics` everywhere. If metrics are not enabled a regular `Map` is used.	2021-12-21 15:51:06 +01:00
achingbrain	0a485d07b3	chore: release version v0.35.6	2021-12-18 07:55:27 +01:00
achingbrain	0c3ed0a4ac	chore: update contributors	2021-12-18 07:55:26 +01:00
Alex Potsides	09a0f940df	fix: increase the maxlisteners for timeout controllers (#1065 ) We use timeout controllers to ensure we're not dialling peers forever but we can end up registering lots of listeners for the `abort` event when peers have a lot of addresses. In node this means we see an unhelpful `MaxListenersExceededWarning` in the console warning of a potential memory leak. Increase the max number of listeners on the signal to silence the warning.	2021-12-18 07:34:27 +01:00
Alex Potsides	a642ad2a03	chore(deps-dev): bump libp2p-floodsub from 0.27.1 to 0.28.0 (#1062 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-12-15 09:30:49 +00:00
achingbrain	8ce2f08589	chore: release version v0.35.5	2021-12-15 09:28:05 +00:00
achingbrain	fe0d9828bb	chore: update contributors	2021-12-15 09:28:04 +00:00
achingbrain	c8e1b08c19	chore: typo	2021-12-15 09:25:40 +00:00
achingbrain	faf1f89d9e	chore: release version v0.35.4	2021-12-15 08:18:44 +00:00
achingbrain	76f4ea5e8a	chore: update contributors	2021-12-15 08:18:44 +00:00
Alex Potsides	2f0b311df7	feat: allow per-component metrics to be collected (#1061 ) Implements the idea from #1060 - allows us to get some insight into what's happening in a libp2p node out side of just bandwidth stats. Configures a few default metrics if metrics are enabled - current connections, the state of the dial queue, etc. Also makes the `Metrics` class not depend on the `ConnectionManager` class, otherwise we can't collect simple metrics from the connection manager class due to the circular dependency.	2021-12-15 08:03:09 +00:00
achingbrain	d172d0d952	chore: release version v0.35.3	2021-12-13 09:03:54 +00:00
achingbrain	f8e8023aed	chore: update contributors	2021-12-13 09:03:54 +00:00
Alex Potsides	bdc9f16d0c	fix: clean up pending dial targets (#1059 ) If the `Promise.race` throws, execution of the function is terminated so the pending dial target is never removed from the map and we leak memory. This can happen when there are invalid multiaddrs or when a peer reports more dialable addresses than the threshold. Instead wrap the `Promise.race` in a `try/finally` which will always remove the pending dial target in the event of success or failure.	2021-12-10 12:42:09 +00:00
Alex Potsides	1b46f47fdb	chore: run node tests in ci (#1057 ) Looks like this project stopped running the `test:node` npm script when it was migrated to gh actions. Re-enable it and fix all the related test failures.	2021-12-08 08:38:17 +00:00
dependabot[bot]	b539f9b655	chore(deps-dev): bump libp2p-gossipsub from 0.11.4 to 0.12.1 (#1045 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-12-07 21:06:06 +00:00
dependabot[bot]	103818733e	chore(deps-dev): bump @chainsafe/libp2p-noise from 4.1.1 to 5.0.0 (#1053 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-12-07 21:05:53 +00:00
Marston Connell	1f1bbc0ee6	docs: naming error in the documentation (#1056 ) Changed LevelStore to LevelDatastore	2021-12-07 21:05:33 +00:00
Robert Kiel	3b683e7156	fix: fix uncaught promise rejection when finding peers (#1044 ) Do not abort all attempts to find peers when `findPeers` on one router throws synchronously Co-authored-by: Robert Kiel <robert.kiel@hoprnet.io> Co-authored-by: achingbrain <alex@achingbrain.net>	2021-12-07 17:51:48 +00:00
Alex Potsides	b25e0fe531	fix: make error codes consistent (#1054 ) Sometimes they are `NOT_FOUND`, sometimes `ERR_NOT_FOUND`, etc. Move all error codes into `errors.js` and reference them from there.	2021-12-07 14:42:10 +00:00
Alex Potsides	cbaa5a2ef3	chore: switch to nat api (#1052 ) @motrix/nat-api is a fork, nat-api has the fix from https://github.com/alxhotel/nat-api/pull/25	2021-12-07 09:37:12 +00:00
Alan Smithee	51dabb1724	chore: pubsub example subscribe returns void (#1048 ) Seems like the correct return type of `Libp2p.pubsub.subscribe` is `void`, so the `await` can be removed: `ae21299ade/src/pubsub-adapter.js (L29)`	2021-12-06 21:12:38 +01:00
Vasco Santos	b9339bccaa	chore: release version v0.35.2	2021-12-06 21:07:39 +01:00
Vasco Santos	9b21893b64	chore: update contributors	2021-12-06 21:07:38 +01:00
Alex Potsides	b70fb43427	fix: increase maxlisteners on event target (#1050 ) Sometimes you encounter peers with lots of addresses. When this happens you can attach more than 10x event listeners to the abort signal we use to abort all the dials - this causes node to print a warning which is misleading. This PR increases the default number of listeners on the signal. Fixes #900	2021-12-06 20:54:44 +01:00
achingbrain	ae21299ade	chore: release version v0.35.1	2021-12-03 16:24:14 +00:00
achingbrain	149120bebc	chore: update contributors	2021-12-03 16:24:13 +00:00
Alex Potsides	91c2ec9856	fix: do not let closest peers run forever (#1047 ) The DHT takes a `signal` not a timeout so if a timeout is passed, create a `TimeoutController` that will abort the query after the timeout.	2021-12-03 15:47:30 +00:00
achingbrain	6d0ac819f1	chore: release version v0.35.0	2021-12-02 10:44:07 +00:00
achingbrain	15a0b1dbf2	chore: update contributors	2021-12-02 10:44:07 +00:00
Alex Potsides	9cbf36fcb5	chore: update peer id and libp2p crypto (#1042 ) BREAKING CHANGE: requires node 15+	2021-12-02 10:11:23 +00:00
Alex Potsides	3a9d5f64d9	fix: stop dht before connection manager (#1041 ) Stop the dht before the connection manager, otherwise in-flight eviction pings fail and we move on to the next one when we should just abort them all. Also pulls in the fix from #1039 and splits the auto-dialler out from the connection manager as during shutdown it can get into a weird state where it's simultaneously killing and creating connections so stop auto-dialling things before we cause connections to dip below the low watermark by killing existing connections. Fixes: https://github.com/ipfs/js-ipfs/issues/3923	2021-11-30 18:07:57 +00:00
Alex Potsides	eacd7e8f76	chore: update deps (#1038 )	2021-11-26 16:00:47 +00:00
dependabot[bot]	7f2cc4dc44	chore(deps-dev): bump ipfs-http-client from 52.0.5 to 54.0.2 (#1035 ) Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-11-26 14:26:26 +00:00
achingbrain	5cc5a8749a	chore: release version v0.34.0	2021-11-25 16:49:46 +00:00
achingbrain	ee60e18213	chore: update contributors	2021-11-25 16:49:46 +00:00
achingbrain	a4a2fac41e	chore: node_modules is not required	2021-11-25 16:48:41 +00:00
Alex Potsides	2f598eba09	feat: update dht (#1009 ) Changes dht creation to use factory function and updates docs BREAKING CHANGE: libp2p-kad-dht has a new event-based API which is exposed as `_dht`	2021-11-25 16:32:19 +00:00
Alan Smithee	443a102528	docs: minor corrections to discovery-mechanisms readme (#1030 )	2021-11-21 23:18:45 +01:00
Alex Potsides	3bed7b4cb2	chore: update aegir (#1027 ) Updates aegir, fixes all new linting errors.	2021-11-19 08:02:24 +00:00
Alex Potsides	3fb424914f	chore: fix examples (#1026 ) Uses npm to install deps for examples. We can put yarn back when we remove `node-fetch@2.x` from ipfs-utils, or when yarn can download tarball dependencies reliably. This either needs: 1. https://github.com/node-fetch/node-fetch/pull/1172 merging 2. Swap node-fetch for undici 3. Drop CJS support (node-fetch 3 has the above fix but is ESM-only)	2021-11-19 07:26:38 +00:00
patrickwoodhead	bb0ca28195	docs: update connection link in API docs (#1024 ) Fixes #1018 The issue was caused when the repo [js-libp2p-interfaces](https://github.com/libp2p/js-libp2p-interfaces) was renamed and refactored in this [commit](`946348f7f8`)	2021-11-16 15:55:00 +00:00
TheStarBoys	01a8b8da9b	chore: example docs for auto-relay with correct port	2021-11-12 10:50:11 +01:00
Vasco Santos	77d7cb8f08	fix: private ip ts compile has no call signatures (#1020 )	2021-11-12 10:34:44 +01:00
Robert Kiel	a335fda852	docs: fix datastore link (#999 )	2021-09-27 12:42:53 +02:00
Vasco Santos	43e3af0c12	chore: add migration guide to 0.33 (#997 )	2021-09-24 11:33:59 +02:00
Vasco Santos	2c9c3cf6d5	chore: release version v0.33.0	2021-09-24 10:32:46 +02:00
Vasco Santos	4d6587539c	chore: update contributors	2021-09-24 10:32:45 +02:00
Alex Potsides	83734ef520	chore: update datastore (#990 ) `interface-datastore` now only contains the interface definition, `datastore-core` has the various implementations. BREAKING CHANGE: datastore implementations provided to libp2p must be compliant with interface-datastore@6.0.0	2021-09-24 10:24:29 +02:00
Vasco Santos	1c2e4d89ac	chore: release version v0.32.5	2021-09-21 09:47:01 +02:00
Vasco Santos	c635b08d2f	chore: update contributors	2021-09-21 09:47:01 +02:00
dependabot[bot]	3aedf55115	chore(deps): bump es6-promisify from 6.1.1 to 7.0.0 (#974 ) Bumps [es6-promisify](https://github.com/mikehall314/es6-promisify) from 6.1.1 to 7.0.0. - [Release notes](https://github.com/mikehall314/es6-promisify/releases) - [Commits](https://github.com/mikehall314/es6-promisify/compare/v6.1.1...v7.0.0) --- updated-dependencies: - dependency-name: es6-promisify dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-09-21 09:40:36 +02:00
dependabot[bot]	ede653cad9	chore(deps-dev): bump into-stream from 6.0.0 to 7.0.0 (#972 ) Bumps [into-stream](https://github.com/sindresorhus/into-stream) from 6.0.0 to 7.0.0. - [Release notes](https://github.com/sindresorhus/into-stream/releases) - [Commits](https://github.com/sindresorhus/into-stream/compare/v6.0.0...v7.0.0) --- updated-dependencies: - dependency-name: into-stream dependency-type: direct:development update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-09-21 09:39:58 +02:00
dependabot[bot]	2ab811d708	chore(deps-dev): bump libp2p-kad-dht from 0.23.4 to 0.24.2 (#991 ) Bumps [libp2p-kad-dht](https://github.com/libp2p/js-libp2p-kad-dht) from 0.23.4 to 0.24.2. - [Release notes](https://github.com/libp2p/js-libp2p-kad-dht/releases) - [Changelog](https://github.com/libp2p/js-libp2p-kad-dht/blob/master/CHANGELOG.md) - [Commits](https://github.com/libp2p/js-libp2p-kad-dht/compare/v0.23.4...v0.24.2) --- updated-dependencies: - dependency-name: libp2p-kad-dht dependency-type: direct:development update-type: version-update:semver-minor ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-09-21 09:39:25 +02:00
XiaoZhang	122c89dd0d	fix: move abortable-iterator to dependencies (#992 ) fix #986	2021-09-21 09:36:37 +02:00
Leask Wong	97107c4ef7	chore: update datastore usage in CONFIGURATION.md (#982 ) Co-authored-by: Vasco Santos <vasco.santos@ua.pt>	2021-08-31 11:51:51 +02:00
dependabot[bot]	d3f78edffe	chore(deps-dev): bump ipfs-http-client from 50.1.2 to 52.0.2 (#973 ) Bumps [ipfs-http-client](https://github.com/ipfs/js-ipfs) from 50.1.2 to 52.0.2. - [Release notes](https://github.com/ipfs/js-ipfs/releases) - [Changelog](https://github.com/ipfs/js-ipfs/blob/master/CHANGELOG.md) - [Commits](https://github.com/ipfs/js-ipfs/compare/ipfs-http-client@50.1.2...ipfs-http-client@52.0.2) --- updated-dependencies: - dependency-name: ipfs-http-client dependency-type: direct:development update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] <support@github.com> Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>	2021-08-26 12:28:44 +02:00
Vasco Santos	f8e3cf10b0	chore: add dependabot (#968 )	2021-08-26 12:02:28 +02:00
Vasco Santos	f342c1ff50	docs: update package list (#969 )	2021-08-26 12:02:17 +02:00
Vasco Santos	fe63990a16	chore: libp2p interop job needs exit for aegir (#971 )	2021-08-26 11:19:13 +02:00
Vasco Santos	e82b6e414b	chore: release version v0.32.4	2021-08-20 09:25:15 +02:00
Vasco Santos	1d62ead8e5	chore: update contributors	2021-08-20 09:25:14 +02:00
Vasco Santos	3d25ff7fd0	chore: use new libp2p-noise	2021-08-20 09:13:21 +02:00
Vasco Santos	0f389a7828	chore: update uint8arrays	2021-08-20 09:13:21 +02:00
Vasco Santos	9f0582f372	chore: remove unused dev dep (#966 )	2021-08-19 09:38:39 +02:00
Vasco Santos	266f2c3c86	chore: release version v0.32.3	2021-08-16 18:20:41 +02:00
Vasco Santos	7783edb059	chore: update contributors	2021-08-16 18:20:40 +02:00
Vasco Santos	ba2b4d4b28	fix: uint8arrays is a dep (#964 )	2021-08-16 17:54:24 +02:00
Vasco Santos	06c3a6d407	chore: release version v0.32.2	2021-08-13 17:02:52 +02:00
Vasco Santos	833f789714	chore: update contributors	2021-08-13 17:02:51 +02:00
greenSnot	ef24fabf02	feat: custom protocol name (#962 ) Co-authored-by: mzdws <8580712+mzdws@user.noreply.gitee.com>	2021-08-13 16:21:50 +02:00
Vasco Santos	3b33fb4b73	fix: browser example ci	2021-08-12 15:15:13 +02:00
Vasco Santos	a07fb7960b	chore: update action setup node	2021-08-12 15:15:13 +02:00
Vasco Santos	b11126ca89	chore: release version v0.32.1	2021-07-22 11:51:39 +02:00
Vasco Santos	df53ab4e65	chore: update contributors	2021-07-22 11:51:39 +02:00
Robert Kiel	0701de40b1	fix: turn compliance tests into devDependency (#960 ) Co-authored-by: Robert Kiel <robert.kiel@hoprnet.io>	2021-07-22 11:42:04 +02:00
Vasco Santos	d6bb967243	chore: release version v0.32.0	2021-07-15 13:14:37 +02:00
Vasco Santos	d48005b8b7	chore: update contributors	2021-07-15 13:14:36 +02:00
Vasco Santos	67b97e32da	chore: add migration guide to 0.32 (#957 )	2021-07-15 12:34:15 +02:00
Vasco Santos	664ba2d1e7	chore: release version v0.32.0-rc.0	2021-07-09 09:01:25 +02:00
Vasco Santos	608564b033	chore: update contributors	2021-07-09 09:01:24 +02:00
Vasco Santos	af723b355e	fix: do not allow dial to large number of multiaddrs (#954 )	2021-07-09 08:46:24 +02:00
Alex Potsides	13cf476148	chore: update to new multiformats (#948 ) BREAKING CHANGE: uses the CID class from the new multiformats module Co-authored-by: Vasco Santos <vasco.santos@moxy.studio>	2021-07-09 08:43:34 +02:00
Vasco Santos	39b03586e8	chore: use libp2p-tcp with types (#952 )	2021-06-16 09:09:26 +02:00
Vasco Santos	f7183e8afd	chore: release version v0.31.7	2021-06-14 09:56:53 +02:00
Vasco Santos	b9988adce9	chore: update contributors	2021-06-14 09:56:53 +02:00
Vasco Santos	b291bc06ec	fix: dialer leaking resources after stopping (#947 ) * fix: dialer leaking resources after stopping * chore: add error code to test	2021-06-14 09:19:23 +02:00
Vasco Santos	755eb909f2	chore: update gossipsub dep for example	2021-06-13 21:42:36 +02:00
Vasco Santos	afe0f854e8	chore: use node 16	2021-06-13 21:42:36 +02:00
Vasco Santos	50f7f32e53	chore: update branch	2021-06-13 21:42:36 +02:00
Vasco Santos	052aad4e06	chore: use node 15 in ci	2021-06-13 21:42:36 +02:00
Vasco Santos	2c4b567b00	chore: restructure pubsub tests	2021-06-13 21:42:36 +02:00
Alex Potsides	2a6a635f13	chore: remove ipfs-utils dep (#953 ) * chore: remove ipfs-utils dep We only use it for the env detection, so use [wherearewe](https://www.npmjs.com/package/wherearewe) instead which is that, but pulled out into a tiny module. The `TextDecoder` class is global everywhere we support so we don't need to pull it in from `ipfs-utils` and it's been removed from v8 anyway. * chore: update ipfs-http-client	2021-06-11 10:01:40 +02:00
Franck Royer	cd152f122f	chore: add secure websockets example (#930 ) * Add Secure WebSockets example * Make dial accept self-signed cert	2021-06-11 09:45:47 +02:00
mcclure	2959794796	chore: add more details on DHT configuration in CONFIGURATION.md (#951 )	2021-06-10 09:06:26 +02:00
Ryan Bell	2068c845cb	chore: configuration format fix	2021-06-07 11:50:21 +02:00
Vasco Santos	d8ba284883	fix: chat example with new multiaddr (#946 )	2021-05-28 13:46:08 +02:00