chore: release version v0.35.8

chore: update contributors
fix: look for final peer event instead of peer response (#1092 )
2025-07-10 06:11:35 +00:00 · 2021-12-29 11:00:11 +01:00 · 2021-12-29 11:00:11 +01:00 · 2021-12-29 10:56:56 +01:00 · 2021-12-29 10:55:48 +01:00 · 2021-12-29 10:51:26 +01:00
76 changed files with 1191 additions and 527 deletions
--- 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 && npm install && 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 && npm install && 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 && npm install && 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 && npm install && 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 && npm install && 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 && npm install && 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 && npm install && 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 && npm install && 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 && npm install && 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 && npm install && 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 && npm install && 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 && npm install && 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
@ -14,13 +14,12 @@ jobs:
    - uses: actions/checkout@v2
    - uses: actions/setup-node@v2
      with:
-        node-version: 14
+        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@v32.1.0
+    - uses: ipfs/aegir/actions/bundle-size@master
      name: size
      with:
        github_token: ${{ secrets.GITHUB_TOKEN }}
@ -30,7 +29,7 @@ jobs:
    strategy:
      matrix:
        os: [windows-latest, ubuntu-latest, macos-latest]
-        node: [14, 16]
+        node: [16]
      fail-fast: true
    steps:
      - uses: actions/checkout@v2
@ -38,27 +37,36 @@ jobs:
        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:
@ -66,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 -- --exit
+      - run: npm run test:interop -- --bail -- --exit
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,3 +1,143 @@
+## [0.35.8](https://github.com/libp2p/js-libp2p/compare/v0.35.7...v0.35.8) (2021-12-29)
+
+
+### Bug Fixes
+
+* do not wait for autodial start ([#1089](https://github.com/libp2p/js-libp2p/issues/1089)) ([79b3cfc](https://github.com/libp2p/js-libp2p/commit/79b3cfc6ad02ecc76fe23a3c3ff2d0b32a0ae4a8))
+* increase listeners on any-signal ([#1084](https://github.com/libp2p/js-libp2p/issues/1084)) ([f18fc80](https://github.com/libp2p/js-libp2p/commit/f18fc80b70bf7b6b26fffa70b0a8d0502a6c4801))
+* look for final peer event instead of peer response ([#1092](https://github.com/libp2p/js-libp2p/issues/1092)) ([d2b7ec0](https://github.com/libp2p/js-libp2p/commit/d2b7ec0f6be0ee80f2c963279a8ec2385059a889))
+* record tracked map clears ([#1085](https://github.com/libp2p/js-libp2p/issues/1085)) ([b4b4324](https://github.com/libp2p/js-libp2p/commit/b4b432406ebc08ef2fc3a1922c64cde7c9060cae))
+
+
+
+## [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)


--- 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>

--- 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)
-  - [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

@ -374,11 +374,7 @@ const node = await Libp2p.create({
    dht: {                        // The DHT options (and defaults) can be found in its documentation
      kBucketSize: 20,
      enabled: true,              // This flag is required for DHT to run (disabled by default)
-      randomWalk: {
-        enabled: true,            // Allows to disable discovery (enabled by default)
-        interval: 300e3,
-        timeout: 10e3
-      }
+      clientMode: false           // Whether to run the WAN DHT in client or server mode (default: client mode)
    }
  }
 })
@ -501,9 +497,9 @@ 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 LevelStore('path/to/store')
+const datastore = new LevelDatastore('path/to/store')
 await datastore.open()

 const node = await Libp2p.create({
@ -676,18 +672,18 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
-const LevelStore = require('datastore-level')
+const LevelDatastore = require('datastore-level')

-const datastore = new LevelStore('path/to/store')
-const dsInstant = await datastore.open()
+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: dsInstant,
  peerStore: {
    persistence: true,
    threshold: 5
@ -788,7 +784,7 @@ By default under nodejs libp2p will attempt to use [UPnP](https://en.wikipedia.o

 #### Configuring protocol name

-Changing the protocol name prefix can isolate default public network (IPFS) for custom purposes. 
+Changing the protocol name prefix can isolate default public network (IPFS) for custom purposes.

 ```js
 const node = await Libp2p.create({
@ -810,8 +806,8 @@ protocols: [

 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/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/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.
--- a/examples/libp2p-in-the-browser/package.json
+++ b/examples/libp2p-in-the-browser/package.json
@ -28,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/pubsub/1.js
+++ b/examples/pubsub/1.js
@ -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/transports/3.js
+++ b/examples/transports/3.js
@ -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/README.md
+++ b/examples/transports/README.md
@ -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/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/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/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,7 +15,7 @@
    "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": {
@ -25,7 +24,7 @@
    "libp2p-mplex": "^0.10.4",
    "@chainsafe/libp2p-noise": "^4.1.0",
    "libp2p-webrtc-direct": "^0.7.0",
-    "peer-id": "^0.15.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
@ -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.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "libp2p",
-  "version": "0.33.0",
+  "version": "0.35.8",
  "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,23 +66,23 @@
  "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": {
-    "abortable-iterator": "^3.0.0",
-    "@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",
@ -103,8 +104,8 @@
    "it-merge": "^1.0.0",
    "it-pipe": "^1.1.0",
    "it-take": "^1.0.0",
-    "libp2p-crypto": "^0.19.4",
-    "libp2p-interfaces": "^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",
@ -112,60 +113,61 @@
    "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.15.0",
+    "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": "^6.0.0",
-    "timeout-abort-controller": "^1.1.1",
+    "timeout-abort-controller": "^2.0.0",
    "uint8arrays": "^3.0.0",
    "varint": "^6.0.0",
    "wherearewe": "^1.0.0",
    "xsalsa20": "^1.1.0"
  },
  "devDependencies": {
-    "@chainsafe/libp2p-noise": "^4.0.0",
+    "@chainsafe/libp2p-noise": "^5.0.0",
    "@nodeutils/defaults-deep": "^1.1.0",
    "@types/es6-promisify": "^6.0.0",
    "@types/node": "^16.0.1",
    "@types/node-forge": "^0.10.1",
    "@types/varint": "^6.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": "^7.0.0",
-    "ipfs-http-client": "^52.0.2",
+    "into-stream": "^6.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.13.0",
+    "libp2p-bootstrap": "^0.14.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-interfaces-compliance-tests": "^1.0.0",
-    "libp2p-kad-dht": "^0.24.2",
-    "libp2p-mdns": "^0.17.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-tcp": "^0.17.0",
-    "libp2p-webrtc-star": "^0.23.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": "^11.1.1",
+    "sinon": "^12.0.1",
    "util": "^0.12.3"
  },
  "contributors": [
@ -179,42 +181,45 @@
    "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
    "Maciej Krüger <mkg20001@gmail.com>",
    "Hugo Dias <mail@hugodias.me>",
-    "Chris Dostert <chrisdostert@users.noreply.github.com>",
    "dirkmc <dirkmdev@gmail.com>",
    "Volker Mische <volker.mische@gmail.com>",
+    "Chris Dostert <chrisdostert@users.noreply.github.com>",
    "zeim839 <50573884+zeim839@users.noreply.github.com>",
+    "Robert Kiel <robert.kiel@hoprnet.org>",
    "Richard Littauer <richard.littauer@gmail.com>",
    "a1300 <matthias-knopp@gmx.net>",
    "Ryan Bell <ryan@piing.net>",
    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
+    "Andrew Nesbitt <andrewnez@gmail.com>",
    "Franck Royer <franck@royer.one>",
    "Thomas Eizinger <thomas@eizinger.io>",
+    "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>",
-    "Andrew Nesbitt <andrewnez@gmail.com>",
    "Samlior <samlior@foxmail.com>",
    "Didrik Nordström <didrik.nordstrom@gmail.com>",
-    "RasmusErik Voel Jensen <github@solsort.com>",
-    "Robert Kiel <robert.kiel@hoprnet.org>",
-    "Smite Chow <xiaopengyou@live.com>",
-    "Soeren <nikorpoulsen@gmail.com>",
-    "Sönke Hahn <soenkehahn@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>",
-    "Aditya Bose <13054902+adbose@users.noreply.github.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>",
-    "greenSnot <greenSnot@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>",
@ -239,9 +244,13 @@
    "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>",
-    "Philipp Muens <raute1337@gmx.de>"
+    "Philipp Muens <raute1337@gmx.de>",
+    "RasmusErik Voel Jensen <github@solsort.com>",
+    "Smite Chow <xiaopengyou@live.com>",
+    "Soeren <nikorpoulsen@gmail.com>"
  ]
 }
--- a/src/circuit/auto-relay.js
+++ b/src/circuit/auto-relay.js
@ -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)
    }
@ -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
@ -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/config.js
+++ b/src/config.js
@ -60,13 +60,7 @@ const DefaultConfig = {
    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,120 @@
+'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().catch(err => {
+      log.error('could start autodial', err)
+    })
+    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,18 @@ 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,
@ -128,8 +130,6 @@ class ConnectionManager extends EventEmitter {

    this._started = true
    log('started')
-
-    this._options.autoDial && this._autoDial()
  }

  /**
@ -138,7 +138,6 @@ class ConnectionManager extends EventEmitter {
   * @async
   */
  async stop () {
-    this._autoDialTimeout && this._autoDialTimeout.clear()
    this._timer && this._timer.clear()

    this._latencyMonitor.removeListener('data', this._onLatencyMeasure)
@ -216,6 +215,7 @@ class ConnectionManager extends EventEmitter {
    const storedConn = this.connections.get(peerIdStr)

    this.emit('peer:connect', connection)
+
    if (storedConn) {
      storedConn.push(connection)
    } else {
@ -248,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)
    }
  }

@ -312,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/content-routing/index.js
+++ b/src/content-routing/index.js
@ -8,9 +8,10 @@ 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
@ -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,51 @@
+'use strict'
+
+const errCode = require('err-code')
+const { messages, codes } = require('../errors')
+
+/**
+ * @typedef {import('peer-id')} PeerId
+ * @typedef {import('libp2p-interfaces/src/peer-routing/types').PeerRouting} PeerRoutingModule
+ */
+
+/**
+ * Wrapper class to convert events into returned values
+ *
+ * @implements {PeerRoutingModule}
+ */
+class DHTPeerRouting {
+  /**
+   * @param {import('libp2p-kad-dht').DHT} dht
+   */
+  constructor (dht) {
+    this._dht = dht
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {any} options
+   */
+  async findPeer (peerId, options = {}) {
+    for await (const event of this._dht.findPeer(peerId, options)) {
+      if (event.name === 'FINAL_PEER') {
+        return event.peer
+      }
+    }
+
+    throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
+  }
+
+  /**
+   * @param {Uint8Array} key
+   * @param {any} options
+   */
+  async * getClosestPeers (key, options = {}) {
+    for await (const event of this._dht.getClosestPeers(key, options)) {
+      if (event.name === 'PEER_RESPONSE') {
+        yield * event.closer
+      }
+    }
+  }
+}
+
+module.exports = { DHTPeerRouting }
--- 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,15 +6,15 @@ 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,
@ -23,6 +23,10 @@ const {
  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
@ -45,14 +49,15 @@ const {
 * @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
 */
@ -70,7 +75,8 @@ class Dialer {
    maxAddrsToDial = MAX_ADDRS_TO_DIAL,
    dialTimeout = DIAL_TIMEOUT,
    maxDialsPerPeer = MAX_PER_PEER_DIALS,
-    resolvers = {}
+    resolvers = {},
+    metrics
  }) {
    this.transportManager = transportManager
    this.peerStore = peerStore
@ -80,8 +86,12 @@ class Dialer {
    this.timeout = dialTimeout
    this.maxDialsPerPeer = maxDialsPerPeer
    this.tokens = [...new Array(maxParallelDials)].map((_, index) => index)
-    this._pendingDials = new Map()
-    this._pendingDialTargets = 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)
@ -95,7 +105,7 @@ class Dialer {
    for (const dial of this._pendingDials.values()) {
      try {
        dial.controller.abort()
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        log.error(err)
      }
    }
@ -129,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
@ -156,14 +166,16 @@ class Dialer {
      this._pendingDialTargets.set(id, { resolve, reject })
    })

-    const dialTarget = await Promise.race([
-      this._createDialTarget(peer),
-      cancellablePromise
-    ])
+    try {
+      const dialTarget = await Promise.race([
+        this._createDialTarget(peer),
+        cancellablePromise
+      ])

-    this._pendingDialTargets.delete(id)
-
-    return dialTarget
+      return dialTarget
+    } finally {
+      this._pendingDialTargets.delete(id)
+    }
  }

  /**
@ -240,10 +252,15 @@ class Dialer {

    // Combine the timeout signal and options.signal, if provided
    const timeoutController = new TimeoutController(this.timeout)
+
    const signals = [timeoutController.signal]
    options.signal && signals.push(options.signal)
    const signal = anySignal(signals)

+    // this signal will potentially be used while dialing lots of
+    // peers so prevent MaxListenersExceededWarning appearing in the console
+    setMaxListeners && setMaxListeners(Infinity, signal)
+
    const pendingDial = {
      dialRequest,
      controller: timeoutController,
@ -254,6 +271,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 = {
@ -29,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/index.js
+++ b/src/identify/index.js
@ -124,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)
      }
@ -182,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)
    }

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

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

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

@ -333,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')
@ -47,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]
 */

 /**
@ -55,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]
@ -116,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]
 *
@ -167,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,
@ -193,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) {
@ -264,6 +265,7 @@ class Libp2p extends EventEmitter {
    this.dialer = new Dialer({
      transportManager: this.transportManager,
      peerStore: this.peerStore,
+      metrics: this.metrics,
      ...this._options.dialer
    })

@ -301,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
      })
    }
@ -363,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()
@ -385,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)
@ -399,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()
      ])

@ -408,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)
@ -431,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)
    }
  }
@ -624,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
@ -655,6 +653,7 @@ class Libp2p extends EventEmitter {
    }

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

    // Peer discovery
    await this._setupPeerDiscovery()
@ -698,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
@ -10,6 +10,7 @@ const { certificateForKey, findAsync } = require('./util')
 const errcode = require('err-code')
 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
@ -10,6 +10,7 @@ const crypto = require('libp2p-crypto')
 const { Key } = require('interface-datastore/key')
 const CMS = require('./cms')
 const errcode = require('err-code')
+const { codes } = require('../errors')
 const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')

@ -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/src/metrics/index.js
+++ b/src/metrics/index.js
@ -24,9 +24,6 @@ const directionToEvent = {
 */

 /**
- * @typedef MetricsProperties
- * @property {import('../connection-manager')} connectionManager
- *
 * @typedef MetricsOptions
 * @property {number} [computeThrottleMaxQueueSize = defaultOptions.computeThrottleMaxQueueSize]
 * @property {number} [computeThrottleTimeout = defaultOptions.computeThrottleTimeout]
@ -37,7 +34,7 @@ const directionToEvent = {
 class Metrics {
  /**
   * @class
-   * @param {MetricsProperties & MetricsOptions} options
+   * @param {MetricsOptions} options
   */
  constructor (options) {
    this._options = mergeOptions(defaultOptions, options)
@ -47,10 +44,7 @@ class Metrics {
    this._oldPeers = oldPeerLRU(this._options.maxOldPeersRetention)
    this._running = false
    this._onMessage = this._onMessage.bind(this)
-    this._connectionManager = options.connectionManager
-    this._connectionManager.on('peer:disconnect', (connection) => {
-      this.onPeerDisconnected(connection.remotePeer)
-    })
+    this._componentMetrics = new Map()
  }

  /**
@ -94,6 +88,22 @@ class Metrics {
    return Array.from(this._peerStats.keys())
  }

+  /**
+   * @returns {Map}
+   */
+  getComponentMetrics () {
+    return this._componentMetrics
+  }
+
+  updateComponentMetric (component, metric, value) {
+    if (!this._componentMetrics.has(component)) {
+      this._componentMetrics.set(component, new Map())
+    }
+
+    const map = this._componentMetrics.get(component)
+    map.set(metric, value)
+  }
+
  /**
   * Returns the `Stats` object for the given `PeerId` whether it
   * is a live peer, or in the disconnected peer LRU cache.
--- a/src/metrics/stats.js
+++ b/src/metrics/stats.js
@ -8,6 +8,7 @@ const retimer = require('retimer')

 /**
 * @typedef {import('@vascosantos/moving-average').IMovingAverage} IMovingAverage
+ * @typedef {import('bignumber.js').BigNumber} Big
 */

 class Stats extends EventEmitter {
--- a/src/metrics/tracked-map.js
+++ b/src/metrics/tracked-map.js
@ -0,0 +1,68 @@
+'use strict'
+
+/**
+ * @template K
+ * @template V
+ */
+class TrackedMap extends Map {
+  /**
+   * @param {string} component
+   * @param {string} name
+   * @param {import('.')} metrics
+   */
+  constructor (component, name, metrics) {
+    super()
+
+    this._component = component
+    this._name = name
+    this._metrics = metrics
+
+    this._metrics.updateComponentMetric(this._component, this._name, this.size)
+  }
+
+  /**
+   * @param {K} key
+   * @param {V} value
+   */
+  set (key, value) {
+    super.set(key, value)
+    this._metrics.updateComponentMetric(this._component, this._name, this.size)
+    return this
+  }
+
+  /**
+   * @param {K} key
+   */
+  delete (key) {
+    const deleted = super.delete(key)
+    this._metrics.updateComponentMetric(this._component, this._name, this.size)
+    return deleted
+  }
+
+  clear () {
+    super.clear()
+
+    this._metrics.updateComponentMetric(this._component, this._name, this.size)
+  }
+}
+
+/**
+ * @template K
+ * @template V
+ * @param {string} component
+ * @param {string} name
+ * @param {import('.')} [metrics]
+ * @returns {Map<K, V>}
+ */
+module.exports = (component, name, metrics) => {
+  /** @type {Map<K, V>} */
+  let map
+
+  if (metrics) {
+    map = new TrackedMap(component, name, metrics)
+  } else {
+    map = new Map()
+  }
+
+  return map
+}
--- a/src/nat-manager.js
+++ b/src/nat-manager.js
@ -1,7 +1,7 @@
 'use strict'

 // @ts-ignore nat-api does not export types
-const NatAPI = require('@motrix/nat-api')
+const NatAPI = require('nat-api')
 const debug = require('debug')
 const { promisify } = require('es6-promisify')
 const { Multiaddr } = require('multiaddr')
@ -114,7 +114,7 @@ class NatManager {
      const client = this._getClient()
      const publicIp = this._externalIp || await client.externalIp()

-      // @ts-ignore isPrivate has no call signatures
+      // @ts-expect-error types are wrong
      if (isPrivateIp(publicIp)) {
        throw new Error(`${publicIp} is private - please set config.nat.externalIp to an externally routable IP or ensure you are not behind a double NAT`)
      }
@ -188,7 +188,7 @@ class NatManager {
    try {
      await this._client.destroy()
      this._client = null
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      log.error(err)
    }
  }
--- a/src/peer-routing.js
+++ b/src/peer-routing.js
@ -5,11 +5,13 @@ const log = Object.assign(debug('libp2p:peer-routing'), {
  error: debug('libp2p:peer-routing:err')
 })
 const errCode = require('err-code')
+const errors = require('./errors')
 const {
  storeAddresses,
  uniquePeers,
  requirePeers
 } = require('./content-routing/utils')
+const { TimeoutController } = require('timeout-abort-controller')

 const merge = require('it-merge')
 const { pipe } = require('it-pipe')
@ -21,6 +23,9 @@ const {
  clearDelayedInterval
 // @ts-ignore module with no types
 } = require('set-delayed-interval')
+const { DHTPeerRouting } = require('./dht/dht-peer-routing')
+// @ts-expect-error setMaxListeners is missing from the types
+const { setMaxListeners } = require('events')

 /**
 * @typedef {import('peer-id')} PeerId
@ -33,6 +38,7 @@ const {
 * @property {boolean} [enabled = true] - Whether to enable the Refresh manager
 * @property {number} [bootDelay = 6e5] - Boot delay to start the Refresh Manager (in ms)
 * @property {number} [interval = 10e3] - Interval between each Refresh Manager run (in ms)
+ * @property {number} [timeout = 10e3] - How long to let each refresh run (in ms)
 *
 * @typedef {Object} PeerRoutingOptions
 * @property {RefreshManagerOptions} [refreshManager]
@ -51,7 +57,7 @@ class PeerRouting {

    // If we have the dht, add it to the available peer routers
    if (libp2p._dht && libp2p._config.dht.enabled) {
-      this._routers.push(libp2p._dht)
+      this._routers.push(new DHTPeerRouting(libp2p._dht))
    }

    this._refreshManagerOptions = libp2p._options.peerRouting.refreshManager
@ -78,8 +84,8 @@ class PeerRouting {
  async _findClosestPeersTask () {
    try {
      // nb getClosestPeers adds the addresses to the address book
-      await drain(this.getClosestPeers(this._peerId.id))
-    } catch (err) {
+      await drain(this.getClosestPeers(this._peerId.id, { timeout: this._refreshManagerOptions.timeout || 10e3 }))
+    } catch (/** @type {any} */ err) {
      log.error(err)
    }
  }
@ -101,19 +107,24 @@ class PeerRouting {
   */
  async findPeer (id, options) { // eslint-disable-line require-await
    if (!this._routers.length) {
-      throw errCode(new Error('No peer routers available'), 'NO_ROUTERS_AVAILABLE')
+      throw errCode(new Error('No peer routers available'), errors.codes.ERR_NO_ROUTERS_AVAILABLE)
    }

    if (id.toB58String() === this._peerId.toB58String()) {
-      throw errCode(new Error('Should not try to find self'), 'ERR_FIND_SELF')
+      throw errCode(new Error('Should not try to find self'), errors.codes.ERR_FIND_SELF)
    }

    const output = await pipe(
      merge(
-        ...this._routers.map(router => [router.findPeer(id, options)])
+        ...this._routers.map(router => (async function * () {
+          try {
+            yield await router.findPeer(id, options)
+          } catch (err) {
+            log.error(err)
+          }
+        })())
      ),
      (source) => filter(source, Boolean),
-      // @ts-ignore findPeer resolves a Promise
      (source) => storeAddresses(source, this._peerStore),
      (source) => first(source)
    )
@ -122,7 +133,7 @@ class PeerRouting {
      return output
    }

-    throw errCode(new Error('not found'), 'NOT_FOUND')
+    throw errCode(new Error(errors.messages.NOT_FOUND), errors.codes.ERR_NOT_FOUND)
  }

  /**
@ -130,12 +141,22 @@ class PeerRouting {
   *
   * @param {Uint8Array} key - A CID like key
   * @param {Object} [options]
-   * @param {number} [options.timeout=30e3] - How long the query can take.
+   * @param {number} [options.timeout=30e3] - How long the query can take
+   * @param {AbortSignal} [options.signal] - An AbortSignal to abort the request
   * @returns {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>}
   */
  async * getClosestPeers (key, options = { timeout: 30e3 }) {
    if (!this._routers.length) {
-      throw errCode(new Error('No peer routers available'), 'NO_ROUTERS_AVAILABLE')
+      throw errCode(new Error('No peer routers available'), errors.codes.ERR_NO_ROUTERS_AVAILABLE)
+    }
+
+    if (options.timeout) {
+      const controller = new TimeoutController(options.timeout)
+      // this controller will potentially be used while dialing lots of
+      // peers so prevent MaxListenersExceededWarning appearing in the console
+      setMaxListeners && setMaxListeners(Infinity, controller.signal)
+
+      options.signal = controller.signal
    }

    yield * pipe(
--- a/src/peer-store/address-book.js
+++ b/src/peer-store/address-book.js
@ -83,7 +83,7 @@ class AddressBook extends Book {
    let peerRecord
    try {
      peerRecord = PeerRecord.createFromProtobuf(envelope.payload)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      log.error('invalid peer record received')
      return false
    }
--- a/src/peer-store/book.js
+++ b/src/peer-store/book.js
@ -2,10 +2,7 @@

 const errcode = require('err-code')
 const PeerId = require('peer-id')
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
+const { codes } = require('../errors')

 /**
 * @param {any} data
@ -48,7 +45,7 @@ class Book {
   * @param {any[]|any} data
   */
  set (peerId, data) {
-    throw errcode(new Error('set must be implemented by the subclass'), 'ERR_NOT_IMPLEMENTED')
+    throw errcode(new Error('set must be implemented by the subclass'), codes.ERR_NOT_IMPLEMENTED)
  }

  /**
@ -94,7 +91,7 @@ class Book {
   */
  get (peerId) {
    if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
    }

    const rec = this.data.get(peerId.toB58String())
@ -111,7 +108,7 @@ class Book {
   */
  delete (peerId) {
    if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
    }

    if (!this.data.delete(peerId.toB58String())) {
--- a/src/peer-store/metadata-book.js
+++ b/src/peer-store/metadata-book.js
@ -80,10 +80,11 @@ class MetadataBook extends Book {
  /**
   * Set data into the datastructure
   *
-   * @override
   * @param {PeerId} peerId
   * @param {string} key
   * @param {Uint8Array} value
+   * @param {object} [opts]
+   * @param {boolean} [opts.emit]
   */
  _setValue (peerId, key, value, { emit = true } = {}) {
    const id = peerId.toB58String()
--- a/src/peer-store/persistent/index.js
+++ b/src/peer-store/persistent/index.js
@ -249,7 +249,7 @@ class PersistentPeerStore extends PeerStore {
      }).finish()

      batch.put(key, encodedData)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      log.error(err)
    }
  }
@ -275,7 +275,7 @@ class PersistentPeerStore extends PeerStore {
      const encodedData = peerId.marshalPubKey()

      batch.put(key, encodedData)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      log.error(err)
    }
  }
@ -302,7 +302,7 @@ class PersistentPeerStore extends PeerStore {
          batch.delete(key)
        }
      })
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      log.error(err)
    }
  }
@ -330,7 +330,7 @@ class PersistentPeerStore extends PeerStore {
      const encodedData = Protocols.encode({ protocols }).finish()

      batch.put(key, encodedData)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      log.error(err)
    }
  }
@ -399,7 +399,7 @@ class PersistentPeerStore extends PeerStore {
        default:
          log('invalid data persisted for: ', key.toString())
      }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      log.error(err)
    }
  }
--- a/src/ping/index.js
+++ b/src/ping/index.js
@ -5,7 +5,7 @@ const log = Object.assign(debug('libp2p:ping'), {
  error: debug('libp2p:ping:err')
 })
 const errCode = require('err-code')
-
+const { codes } = require('../errors')
 const crypto = require('libp2p-crypto')
 const { pipe } = require('it-pipe')
 // @ts-ignore it-buffer has no types exported
@ -50,7 +50,7 @@ async function ping (node, peer) {
  const end = Date.now()

  if (!equals(data, result)) {
-    throw errCode(new Error('Received wrong ping ack'), 'ERR_WRONG_PING_ACK')
+    throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
  }

  return end - start
--- a/src/pnet/crypto.js
+++ b/src/pnet/crypto.js
@ -77,7 +77,7 @@ module.exports.decodeV1PSK = (pskBuffer) => {
      codecName: codec,
      psk: psk
    }
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
    log.error(err)
    throw new Error(Errors.INVALID_PSK)
  }
--- a/src/pnet/key-generator.js
+++ b/src/pnet/key-generator.js
@ -28,6 +28,6 @@ try {
    // @ts-ignore
    generate(process.stdout)
  }
-} catch (error) {
+} catch (/** @type {any} */ error) {

 }
--- a/src/transport-manager.js
+++ b/src/transport-manager.js
@ -109,7 +109,7 @@ class TransportManager {

    try {
      return await transport.dial(ma, options)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      if (!err.code) err.code = codes.ERR_TRANSPORT_DIAL_FAILED
      throw err
    }
--- a/src/upgrader.js
+++ b/src/upgrader.js
@ -106,7 +106,7 @@ class Upgrader {
      } else {
        upgradedConn = encryptedConn
      }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      log.error('Failed to upgrade inbound connection', err)
      await maConn.close(err)
      throw err
@ -181,7 +181,7 @@ class Upgrader {
      } else {
        upgradedConn = encryptedConn
      }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      log.error('Failed to upgrade outbound connection', err)
      await maConn.close(err)
      throw err
@ -245,7 +245,7 @@ class Upgrader {
            if (this.metrics) this.metrics.trackStream({ stream, remotePeer, protocol })
            connection.addStream(muxedStream, { protocol })
            this._onStream({ connection, stream: { ...muxedStream, ...stream }, protocol })
-          } catch (err) {
+          } catch (/** @type {any} */ err) {
            log.error(err)
          }
        },
@ -263,7 +263,7 @@ class Upgrader {
          const { stream, protocol } = await mss.select(protocols)
          if (this.metrics) this.metrics.trackStream({ stream, remotePeer, protocol })
          return { stream: { ...muxedStream, ...stream }, protocol }
-        } catch (err) {
+        } catch (/** @type {any} */ err) {
          log.error('could not create new stream', err)
          throw errCode(err, codes.ERR_UNSUPPORTED_PROTOCOL)
        }
@ -283,7 +283,7 @@ class Upgrader {
              if (connection.stat.status === 'open') {
                await connection.close()
              }
-            } catch (err) {
+            } catch (/** @type {any} */ err) {
              log.error(err)
            } finally {
              this.onConnectionEnd(connection)
@ -297,7 +297,7 @@ class Upgrader {
    maConn.timeline.upgraded = Date.now()

    const errConnectionNotMultiplexed = () => {
-      throw errCode(new Error('connection is not multiplexed'), 'ERR_CONNECTION_NOT_MULTIPLEXED')
+      throw errCode(new Error('connection is not multiplexed'), codes.ERR_CONNECTION_NOT_MULTIPLEXED)
    }

    // Create the connection
@ -371,7 +371,7 @@ class Upgrader {
        ...await crypto.secureInbound(localPeer, stream),
        protocol
      }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      throw errCode(err, codes.ERR_ENCRYPTION_FAILED)
    }
  }
@ -406,7 +406,7 @@ class Upgrader {
        ...await crypto.secureOutbound(localPeer, stream, remotePeerId),
        protocol
      }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      throw errCode(err, codes.ERR_ENCRYPTION_FAILED)
    }
  }
@ -430,7 +430,7 @@ class Upgrader {
      log('%s selected as muxer protocol', protocol)
      const Muxer = muxers.get(protocol)
      return { stream, Muxer }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      throw errCode(err, codes.ERR_MUXER_UNAVAILABLE)
    }
  }
@ -453,7 +453,7 @@ class Upgrader {
      const { stream, protocol } = await listener.handle(protocols)
      const Muxer = muxers.get(protocol)
      return { stream, Muxer }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      throw errCode(err, codes.ERR_MUXER_UNAVAILABLE)
    }
  }
--- a/test/content-routing/content-routing.node.js
+++ b/test/content-routing/content-routing.node.js
@ -34,16 +34,16 @@ describe('content-routing', () => {
      try {
        for await (const _ of node.contentRouting.findProviders('a cid')) {} // eslint-disable-line
        throw new Error('.findProviders should return an error')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err).to.exist()
-        expect(err.code).to.equal('NO_ROUTERS_AVAILABLE')
+        expect(err.code).to.equal('ERR_NO_ROUTERS_AVAILABLE')
      }
    })

    it('.provide should return an error', async () => {
      await expect(node.contentRouting.provide('a cid'))
        .to.eventually.be.rejected()
-        .and.to.have.property('code', 'NO_ROUTERS_AVAILABLE')
+        .and.to.have.property('code', 'ERR_NO_ROUTERS_AVAILABLE')
    })
  })

@ -87,8 +87,11 @@ describe('content-routing', () => {
      sinon.stub(nodes[0]._dht, 'findProviders').callsFake(function * () {
        deferred.resolve()
        yield {
-          id: providerPeerId,
-          multiaddrs: []
+          name: 'PROVIDER',
+          providers: [{
+            id: providerPeerId,
+            multiaddrs: []
+          }]
        }
      })

@ -238,7 +241,7 @@ describe('content-routing', () => {
      try {
        for await (const _ of node.contentRouting.findProviders(cid)) { } // eslint-disable-line
        throw new Error('should handle errors when finding providers')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err).to.exist()
      }

@ -361,7 +364,12 @@ describe('content-routing', () => {
      }

      sinon.stub(node._dht, 'findProviders').callsFake(async function * () {
-        yield result1
+        yield {
+          name: 'PROVIDER',
+          providers: [
+            result1
+          ]
+        }
      })
      sinon.stub(delegate, 'findProviders').callsFake(async function * () {
        yield result2
@ -382,7 +390,8 @@ describe('content-routing', () => {
      const dhtDeferred = pDefer()
      const delegatedDeferred = pDefer()

-      sinon.stub(node._dht, 'provide').callsFake(() => {
+      sinon.stub(node._dht, 'provide').callsFake(async function * () {
+        yield
        dhtDeferred.resolve()
      })

@ -406,7 +415,12 @@ describe('content-routing', () => {
      }]

      sinon.stub(node._dht, 'findProviders').callsFake(function * () {
-        yield results[0]
+        yield {
+          name: 'PROVIDER',
+          providers: [
+            results[0]
+          ]
+        }
      })

      sinon.stub(delegate, 'findProviders').callsFake(function * () { // eslint-disable-line require-yield
--- a/test/content-routing/dht/configuration.node.js
+++ b/test/content-routing/dht/configuration.node.js
@ -38,13 +38,13 @@ describe('DHT subsystem is configurable', () => {
    })

    libp2p = await create(customOptions)
-    expect(libp2p._dht.isStarted).to.equal(false)
+    expect(libp2p._dht.isStarted()).to.equal(false)

    await libp2p.start()
-    expect(libp2p._dht.isStarted).to.equal(true)
+    expect(libp2p._dht.isStarted()).to.equal(true)

    await libp2p.stop()
-    expect(libp2p._dht.isStarted).to.equal(false)
+    expect(libp2p._dht.isStarted()).to.equal(false)
  })

  it('should not start if disabled once libp2p starts', async () => {
@ -63,10 +63,10 @@ describe('DHT subsystem is configurable', () => {
    })

    libp2p = await create(customOptions)
-    expect(libp2p._dht.isStarted).to.equal(false)
+    expect(libp2p._dht.isStarted()).to.equal(false)

    await libp2p.start()
-    expect(libp2p._dht.isStarted).to.equal(false)
+    expect(libp2p._dht.isStarted()).to.equal(false)
  })

  it('should allow a manual start', async () => {
@ -86,9 +86,9 @@ describe('DHT subsystem is configurable', () => {

    libp2p = await create(customOptions)
    await libp2p.start()
-    expect(libp2p._dht.isStarted).to.equal(false)
+    expect(libp2p._dht.isStarted()).to.equal(false)

    await libp2p._dht.start()
-    expect(libp2p._dht.isStarted).to.equal(true)
+    expect(libp2p._dht.isStarted()).to.equal(true)
  })
 })
--- a/test/content-routing/dht/operation.node.js
+++ b/test/content-routing/dht/operation.node.js
@ -60,8 +60,8 @@ describe('DHT subsystem operates correctly', () => {
      expect(connection).to.exist()

      return Promise.all([
-        pWaitFor(() => libp2p._dht.routingTable.size === 1),
-        pWaitFor(() => remoteLibp2p._dht.routingTable.size === 1)
+        pWaitFor(() => libp2p._dht._lan._routingTable.size === 1),
+        pWaitFor(() => remoteLibp2p._dht._lan._routingTable.size === 1)
      ])
    })

@ -71,14 +71,14 @@ describe('DHT subsystem operates correctly', () => {

      await libp2p.dialProtocol(remAddr, subsystemMulticodecs)
      await Promise.all([
-        pWaitFor(() => libp2p._dht.routingTable.size === 1),
-        pWaitFor(() => remoteLibp2p._dht.routingTable.size === 1)
+        pWaitFor(() => libp2p._dht._lan._routingTable.size === 1),
+        pWaitFor(() => remoteLibp2p._dht._lan._routingTable.size === 1)
      ])

      await libp2p.contentRouting.put(key, value)
-      const fetchedValue = await remoteLibp2p.contentRouting.get(key)

-      expect(fetchedValue).to.eql(value)
+      const fetchedValue = await remoteLibp2p.contentRouting.get(key)
+      expect(fetchedValue).to.have.property('val').that.equalBytes(value)
    })
  })

@ -119,11 +119,13 @@ describe('DHT subsystem operates correctly', () => {
      const connection = await libp2p.dial(remAddr)

      expect(connection).to.exist()
-      expect(libp2p._dht.routingTable.size).to.be.eql(0)
-      expect(remoteLibp2p._dht.routingTable.size).to.be.eql(0)
+      expect(libp2p._dht._lan._routingTable.size).to.be.eql(0)

      await remoteLibp2p._dht.start()
-      return pWaitFor(() => libp2p._dht.routingTable.size === 1)
+      // should be 0 directly after start - TODO this may be susceptible to timing bugs, we should have
+      // the ability to report stats on the DHT routing table instead of reaching into it's heart like this
+      expect(remoteLibp2p._dht._lan._routingTable.size).to.be.eql(0)
+      return pWaitFor(() => libp2p._dht._lan._routingTable.size === 1)
    })

    it('should put on a peer and get from the other', async () => {
@ -133,12 +135,12 @@ describe('DHT subsystem operates correctly', () => {
      const value = uint8ArrayFromString('world')

      await remoteLibp2p._dht.start()
-      await pWaitFor(() => libp2p._dht.routingTable.size === 1)
+      await pWaitFor(() => libp2p._dht._lan._routingTable.size === 1)

      await libp2p.contentRouting.put(key, value)

      const fetchedValue = await remoteLibp2p.contentRouting.get(key)
-      expect(fetchedValue).to.eql(value)
+      expect(fetchedValue).to.have.property('val').that.equalBytes(value)
    })
  })
 })
--- a/test/content-routing/dht/utils.js
+++ b/test/content-routing/dht/utils.js
@ -1,7 +1,6 @@
 'use strict'

 const KadDht = require('libp2p-kad-dht')
-const { multicodec } = require('libp2p-kad-dht')
 const Crypto = require('../../../src/insecure/plaintext')
 const Muxer = require('libp2p-mplex')
 const Transport = require('libp2p-tcp')
@ -25,13 +24,12 @@ const subsystemOptions = mergeOptions(baseOptions, {
  config: {
    dht: {
      kBucketSize: 20,
-      randomWalk: {
-        enabled: true
-      },
      enabled: true
    }
  }
 })

 module.exports.subsystemOptions = subsystemOptions
-module.exports.subsystemMulticodecs = [multicodec]
+module.exports.subsystemMulticodecs = [
+  '/ipfs/lan/kad/1.0.0'
+]
--- a/test/content-routing/utils.js
+++ b/test/content-routing/utils.js
@ -13,9 +13,6 @@ const routingOptions = mergeOptions(baseOptions, {
  config: {
    dht: {
      kBucketSize: 20,
-      randomWalk: {
-        enabled: true
-      },
      enabled: true
    }
  }
--- a/test/dialing/dial-request.spec.js
+++ b/test/dialing/dial-request.spec.js
@ -125,7 +125,7 @@ describe('Dial Request', () => {
    try {
      await dialRequest.run({ signal: controller.signal })
      expect.fail('Should have thrown')
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      expect(err).to.be.an.instanceof(AggregateError)
    }

@ -162,7 +162,7 @@ describe('Dial Request', () => {
    try {
      await dialRequest.run({ signal: controller.signal })
      expect.fail('Should have thrown')
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      expect(err).to.be.an.instanceof(AggregateError)
    }

@ -212,7 +212,7 @@ describe('Dial Request', () => {
      setTimeout(() => controller.abort(), 100)
      await dialRequest.run({ signal: controller.signal })
      expect.fail('dial should have failed')
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      expect(err).to.be.an.instanceof(AggregateError)
    }

--- a/test/dialing/direct.node.js
+++ b/test/dialing/direct.node.js
@ -277,7 +277,7 @@ describe('Dialing (direct, TCP)', () => {

      try {
        await libp2p.dial(remoteLibp2p.transportManager.getAddrs()[0])
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err).to.have.property('code', ErrorCodes.ERR_INVALID_MULTIADDR)
        return
      }
--- a/test/dialing/direct.spec.js
+++ b/test/dialing/direct.spec.js
@ -304,7 +304,7 @@ describe('Dialing (direct, WebSockets)', () => {
      dialer.destroy()
      await dialPromise
      expect.fail('should have failed')
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      expect(err).to.be.an.instanceof(AggregateError)
      expect(dialer._pendingDials.size).to.equal(0) // 1 dial request
    }
--- a/test/keychain/keychain.spec.js
+++ b/test/keychain/keychain.spec.js
@ -296,7 +296,7 @@ describe('keychain', () => {
    it('requires plain data as a Uint8Array', async () => {
      const err = await ks.cms.encrypt(rsaKeyName, 'plain data').then(fail, err => err)
      expect(err).to.exist()
-      expect(err).to.have.property('code', 'ERR_INVALID_PARAMS')
+      expect(err).to.have.property('code', 'ERR_INVALID_PARAMETERS')
    })

    it('encrypts', async () => {
@ -308,7 +308,7 @@ describe('keychain', () => {
    it('is a PKCS #7 message', async () => {
      const err = await ks.cms.decrypt('not CMS').then(fail, err => err)
      expect(err).to.exist()
-      expect(err).to.have.property('code', 'ERR_INVALID_PARAMS')
+      expect(err).to.have.property('code', 'ERR_INVALID_PARAMETERS')
    })

    it('is a PKCS #7 binary message', async () => {
@ -519,7 +519,7 @@ describe('keychain', () => {
    it('should validate newPass is a string', async () => {
      try {
        await kc.rotateKeychainPass(oldPass, 1234567890)
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err).to.exist()
      }
    })
@ -527,7 +527,7 @@ describe('keychain', () => {
    it('should validate oldPass is a string', async () => {
      try {
        await kc.rotateKeychainPass(1234, 'newInsecurePassword1')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err).to.exist()
      }
    })
@ -535,7 +535,7 @@ describe('keychain', () => {
    it('should validate newPass is at least 20 characters', async () => {
      try {
        await kc.rotateKeychainPass(oldPass, 'not20Chars')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err).to.exist()
      }
    })
@ -586,7 +586,7 @@ describe('libp2p.keychain', () => {

    try {
      await libp2p.keychain.createKey('keyName', 'rsa', 2048)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      expect(err).to.exist()
      return
    }
--- a/test/metrics/index.spec.js
+++ b/test/metrics/index.spec.js
@ -3,9 +3,6 @@

 const { expect } = require('aegir/utils/chai')
 const sinon = require('sinon')
-
-const { EventEmitter } = require('events')
-
 const { randomBytes } = require('libp2p-crypto')
 const duplexPair = require('it-pair/duplex')
 const pipe = require('it-pipe')
@ -34,8 +31,7 @@ describe('Metrics', () => {
    const [local, remote] = duplexPair()
    const metrics = new Metrics({
      computeThrottleMaxQueueSize: 1, // compute after every message
-      movingAverageIntervals: [10, 100, 1000],
-      connectionManager: new EventEmitter()
+      movingAverageIntervals: [10, 100, 1000]
    })

    metrics.trackStream({
@ -70,8 +66,7 @@ describe('Metrics', () => {
    const [local, remote] = duplexPair()
    const metrics = new Metrics({
      computeThrottleMaxQueueSize: 1, // compute after every message
-      movingAverageIntervals: [10, 100, 1000],
-      connectionManager: new EventEmitter()
+      movingAverageIntervals: [10, 100, 1000]
    })

    metrics.trackStream({
@ -119,8 +114,7 @@ describe('Metrics', () => {
    const [local2, remote2] = duplexPair()
    const metrics = new Metrics({
      computeThrottleMaxQueueSize: 1, // compute after every message
-      movingAverageIntervals: [10, 100, 1000],
-      connectionManager: new EventEmitter()
+      movingAverageIntervals: [10, 100, 1000]
    })
    const protocol = '/echo/1.0.0'
    metrics.start()
@ -175,8 +169,7 @@ describe('Metrics', () => {
    const [local, remote] = duplexPair()
    const metrics = new Metrics({
      computeThrottleMaxQueueSize: 1, // compute after every message
-      movingAverageIntervals: [10, 100, 1000],
-      connectionManager: new EventEmitter()
+      movingAverageIntervals: [10, 100, 1000]
    })
    metrics.start()

@ -231,8 +224,7 @@ describe('Metrics', () => {
    }))

    const metrics = new Metrics({
-      maxOldPeersRetention: 5, // Only keep track of 5
-      connectionManager: new EventEmitter()
+      maxOldPeersRetention: 5 // Only keep track of 5
    })

    // Clone so trackedPeers isn't modified
@ -262,4 +254,22 @@ describe('Metrics', () => {
      expect(spy).to.have.property('callCount', 1)
    }
  })
+
+  it('should allow components to track metrics', () => {
+    const metrics = new Metrics({
+      maxOldPeersRetention: 5 // Only keep track of 5
+    })
+
+    expect(metrics.getComponentMetrics()).to.be.empty()
+
+    const component = 'my-component'
+    const metric = 'some-metric'
+    const value = 1
+
+    metrics.updateComponentMetric(component, metric, value)
+
+    expect(metrics.getComponentMetrics()).to.have.lengthOf(1)
+    expect(metrics.getComponentMetrics().get(component)).to.have.lengthOf(1)
+    expect(metrics.getComponentMetrics().get(component).get(metric)).to.equal(value)
+  })
 })
--- a/test/nat-manager/nat-manager.node.js
+++ b/test/nat-manager/nat-manager.node.js
@ -244,6 +244,10 @@ describe('Nat Manager (TCP)', () => {
  })

  it('shuts the nat api down when stopping', async function () {
+    if (process.env.CI) {
+      return this.skip('CI environments will not let us map external ports')
+    }
+
    function findRoutableAddress () {
      const interfaces = networkInterfaces()

@ -261,7 +265,7 @@ describe('Nat Manager (TCP)', () => {

    if (!addr) {
      // skip test if no non-loopback address is found
-      this.skip()
+      return this.skip()
    }

    const {
--- a/test/peer-discovery/index.node.js
+++ b/test/peer-discovery/index.node.js
@ -161,20 +161,13 @@ describe('peer discovery scenarios', () => {
          autoDial: false
        },
        dht: {
-          randomWalk: {
-            enabled: false,
-            delay: 1000, // start the first query quickly
-            interval: 10000,
-            timeout: 5000
-          },
          enabled: true
        }
      }
    })

    const localConfig = getConfig(peerId)
-    // Only run random walk on our local node
-    localConfig.config.dht.randomWalk.enabled = true
+
    libp2p = new Libp2p(localConfig)

    const remoteLibp2p1 = new Libp2p(getConfig(remotePeerId1))
--- a/test/peer-routing/peer-routing.node.js
+++ b/test/peer-routing/peer-routing.node.js
@ -36,16 +36,16 @@ describe('peer-routing', () => {
    it('.findPeer should return an error', async () => {
      await expect(node.peerRouting.findPeer('a cid'))
        .to.eventually.be.rejected()
-        .and.to.have.property('code', 'NO_ROUTERS_AVAILABLE')
+        .and.to.have.property('code', 'ERR_NO_ROUTERS_AVAILABLE')
    })

    it('.getClosestPeers should return an error', async () => {
      try {
        for await (const _ of node.peerRouting.getClosestPeers('a cid')) { } // eslint-disable-line
        throw new Error('.getClosestPeers should return an error')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err).to.exist()
-        expect(err.code).to.equal('NO_ROUTERS_AVAILABLE')
+        expect(err.code).to.equal('ERR_NO_ROUTERS_AVAILABLE')
      }
    })
  })
@ -72,33 +72,38 @@ describe('peer-routing', () => {

    after(() => Promise.all(nodes.map((n) => n.stop())))

-    it('should use the nodes dht', () => {
-      const deferred = pDefer()
-
-      sinon.stub(nodes[0]._dht, 'findPeer').callsFake(() => {
-        deferred.resolve()
-        return nodes[1].peerId
-      })
-
-      nodes[0].peerRouting.findPeer()
-      return deferred.promise
-    })
-
-    it('should use the nodes dht to get the closest peers', async () => {
-      const deferred = pDefer()
-      const [remotePeerId] = await peerUtils.createPeerId({ fixture: false })
-
-      sinon.stub(nodes[0]._dht, 'getClosestPeers').callsFake(function * () {
-        deferred.resolve()
+    it('should use the nodes dht', async () => {
+      sinon.stub(nodes[0]._dht, 'findPeer').callsFake(async function * () {
        yield {
-          id: remotePeerId,
-          multiaddrs: []
+          name: 'PEER_RESPONSE',
+          closer: [{
+            id: nodes[1].peerId,
+            multiaddrs: []
+          }]
        }
      })

-      await nodes[0].peerRouting.getClosestPeers().next()
+      expect(nodes[0]._dht.findPeer.called).to.be.false()
+      await nodes[0].peerRouting.findPeer(nodes[1].peerId)
+      expect(nodes[0]._dht.findPeer.called).to.be.true()
+      nodes[0]._dht.findPeer.restore()
+    })

-      return deferred.promise
+    it('should use the nodes dht to get the closest peers', async () => {
+      sinon.stub(nodes[0]._dht, 'getClosestPeers').callsFake(async function * () {
+        yield {
+          name: 'PEER_RESPONSE',
+          closer: [{
+            id: nodes[1].peerId,
+            multiaddrs: []
+          }]
+        }
+      })
+
+      expect(nodes[0]._dht.getClosestPeers.called).to.be.false()
+      await drain(nodes[0].peerRouting.getClosestPeers(nodes[1].peerId))
+      expect(nodes[0]._dht.getClosestPeers.called).to.be.true()
+      nodes[0]._dht.getClosestPeers.restore()
    })

    it('should error when peer tries to find itself', async () => {
@ -106,6 +111,95 @@ describe('peer-routing', () => {
        .to.eventually.be.rejected()
        .and.to.have.property('code', 'ERR_FIND_SELF')
    })
+
+    it('should handle error thrown synchronously during find peer', async () => {
+      const unknownPeers = await peerUtils.createPeerId({ number: 1, fixture: false })
+
+      nodes[0].peerRouting._routers = [{
+        findPeer () {
+          throw new Error('Thrown sync')
+        }
+      }]
+
+      await expect(nodes[0].peerRouting.findPeer(unknownPeers[0]))
+        .to.eventually.be.rejected()
+        .and.to.have.property('code', 'ERR_NOT_FOUND')
+    })
+
+    it('should handle error thrown asynchronously during find peer', async () => {
+      const unknownPeers = await peerUtils.createPeerId({ number: 1, fixture: false })
+
+      nodes[0].peerRouting._routers = [{
+        async findPeer () {
+          throw new Error('Thrown async')
+        }
+      }]
+
+      await expect(nodes[0].peerRouting.findPeer(unknownPeers[0]))
+        .to.eventually.be.rejected()
+        .and.to.have.property('code', 'ERR_NOT_FOUND')
+    })
+
+    it('should handle error thrown asynchronously after delay during find peer', async () => {
+      const unknownPeers = await peerUtils.createPeerId({ number: 1, fixture: false })
+
+      nodes[0].peerRouting._routers = [{
+        async findPeer () {
+          await delay(100)
+          throw new Error('Thrown async after delay')
+        }
+      }]
+
+      await expect(nodes[0].peerRouting.findPeer(unknownPeers[0]))
+        .to.eventually.be.rejected()
+        .and.to.have.property('code', 'ERR_NOT_FOUND')
+    })
+
+    it('should return value when one router errors synchronously and another returns a value', async () => {
+      const [peer] = await peerUtils.createPeerId({ number: 1, fixture: false })
+
+      nodes[0].peerRouting._routers = [{
+        findPeer () {
+          throw new Error('Thrown sync')
+        }
+      }, {
+        async findPeer () {
+          return Promise.resolve({
+            id: peer,
+            multiaddrs: []
+          })
+        }
+      }]
+
+      await expect(nodes[0].peerRouting.findPeer(peer))
+        .to.eventually.deep.equal({
+          id: peer,
+          multiaddrs: []
+        })
+    })
+
+    it('should return value when one router errors asynchronously and another returns a value', async () => {
+      const [peer] = await peerUtils.createPeerId({ number: 1, fixture: false })
+
+      nodes[0].peerRouting._routers = [{
+        async findPeer () {
+          throw new Error('Thrown sync')
+        }
+      }, {
+        async findPeer () {
+          return Promise.resolve({
+            id: peer,
+            multiaddrs: []
+          })
+        }
+      }]
+
+      await expect(nodes[0].peerRouting.findPeer(peer))
+        .to.eventually.deep.equal({
+          id: peer,
+          multiaddrs: []
+        })
+    })
  })

  describe('via delegate router', () => {
@ -145,36 +239,35 @@ describe('peer-routing', () => {
    })

    it('should use the delegate router to find peers', async () => {
-      const deferred = pDefer()
      const [remotePeerId] = await peerUtils.createPeerId({ fixture: false })

      sinon.stub(delegate, 'findPeer').callsFake(() => {
-        deferred.resolve()
        return {
          id: remotePeerId,
          multiaddrs: []
        }
      })

-      await node.peerRouting.findPeer()
-      return deferred.promise
+      expect(delegate.findPeer.called).to.be.false()
+      await node.peerRouting.findPeer(remotePeerId)
+      expect(delegate.findPeer.called).to.be.true()
+      delegate.findPeer.restore()
    })

    it('should use the delegate router to get the closest peers', async () => {
-      const deferred = pDefer()
      const [remotePeerId] = await peerUtils.createPeerId({ fixture: false })

      sinon.stub(delegate, 'getClosestPeers').callsFake(function * () {
-        deferred.resolve()
        yield {
          id: remotePeerId,
          multiaddrs: []
        }
      })

-      await node.peerRouting.getClosestPeers().next()
-
-      return deferred.promise
+      expect(delegate.getClosestPeers.called).to.be.false()
+      await drain(node.peerRouting.getClosestPeers(remotePeerId))
+      expect(delegate.getClosestPeers.called).to.be.true()
+      delegate.getClosestPeers.restore()
    })

    it('should be able to find a peer', async () => {
@ -200,7 +293,7 @@ describe('peer-routing', () => {
    })

    it('should error when a peer cannot be found', async () => {
-      const peerKey = 'key of a peer not on the network'
+      const peerId = await PeerId.create({ keyType: 'ed25519' })
      const mockApi = nock('http://0.0.0.0:60197')
        .post('/api/v0/dht/findpeer')
        .query(true)
@ -209,20 +302,20 @@ describe('peer-routing', () => {
          'X-Chunked-Output', '1'
        ])

-      await expect(node.peerRouting.findPeer(peerKey))
+      await expect(node.peerRouting.findPeer(peerId))
        .to.eventually.be.rejected()

      expect(mockApi.isDone()).to.equal(true)
    })

    it('should handle errors from the api', async () => {
-      const peerKey = 'key of a peer not on the network'
+      const peerId = await PeerId.create({ keyType: 'ed25519' })
      const mockApi = nock('http://0.0.0.0:60197')
        .post('/api/v0/dht/findpeer')
        .query(true)
        .reply(502)

-      await expect(node.peerRouting.findPeer(peerKey))
+      await expect(node.peerRouting.findPeer(peerId))
        .to.eventually.be.rejected()

      expect(mockApi.isDone()).to.equal(true)
@ -230,7 +323,6 @@ describe('peer-routing', () => {

    it('should be able to get the closest peers', async () => {
      const peerId = await PeerId.create({ keyType: 'ed25519' })
-
      const closest1 = '12D3KooWLewYMMdGWAtuX852n4rgCWkK7EBn4CWbwwBzhsVoKxk3'
      const closest2 = '12D3KooWDtoQbpKhtnWddfj72QmpFvvLDTsBLTFkjvgQm6cde2AK'

@ -249,15 +341,12 @@ describe('peer-routing', () => {
            'X-Chunked-Output', '1'
          ])

-      const closestPeers = []
-      for await (const peer of node.peerRouting.getClosestPeers(peerId.id, { timeout: 1000 })) {
-        closestPeers.push(peer)
-      }
+      const closestPeers = await all(node.peerRouting.getClosestPeers(peerId.id, { timeout: 1000 }))

      expect(closestPeers).to.have.length(2)
-      expect(closestPeers[0].id.toB58String()).to.equal(closest2)
+      expect(closestPeers[0].id.toB58String()).to.equal(closest1)
      expect(closestPeers[0].multiaddrs).to.have.lengthOf(2)
-      expect(closestPeers[1].id.toB58String()).to.equal(closest1)
+      expect(closestPeers[1].id.toB58String()).to.equal(closest2)
      expect(closestPeers[1].multiaddrs).to.have.lengthOf(2)
      expect(mockApi.isDone()).to.equal(true)
    })
@ -275,7 +364,7 @@ describe('peer-routing', () => {
      try {
        for await (const _ of node.peerRouting.getClosestPeers(peerId.id)) { } // eslint-disable-line
        throw new Error('should handle errors when getting the closest peers')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err).to.exist()
      }

@ -316,7 +405,7 @@ describe('peer-routing', () => {
        multiaddrs: []
      }

-      sinon.stub(node._dht, 'findPeer').callsFake(() => {})
+      sinon.stub(node._dht, 'findPeer').callsFake(async function * () {})
      sinon.stub(delegate, 'findPeer').callsFake(() => {
        return results
      })
@ -334,7 +423,8 @@ describe('peer-routing', () => {

      const defer = pDefer()

-      sinon.stub(node._dht, 'findPeer').callsFake(async () => {
+      sinon.stub(node._dht, 'findPeer').callsFake(async function * () {
+        yield
        await defer.promise
      })
      sinon.stub(delegate, 'findPeer').callsFake(() => {
@ -349,29 +439,34 @@ describe('peer-routing', () => {

    it('should not wait for the delegate to return if the dht does first', async () => {
      const [remotePeerId] = await peerUtils.createPeerId({ fixture: false })
-      const results = {
+      const result = {
        id: remotePeerId,
        multiaddrs: []
      }

      const defer = pDefer()

-      sinon.stub(node._dht, 'findPeer').callsFake(() => {
-        return results
+      sinon.stub(node._dht, 'findPeer').callsFake(async function * () {
+        yield {
+          name: 'PEER_RESPONSE',
+          closer: [
+            result
+          ]
+        }
      })
      sinon.stub(delegate, 'findPeer').callsFake(async () => {
        await defer.promise
      })

      const peer = await node.peerRouting.findPeer(remotePeerId)
-      expect(peer).to.eql(results)
+      expect(peer).to.eql(result)

      defer.resolve()
    })

    it('should store the addresses of the found peer', async () => {
      const [remotePeerId] = await peerUtils.createPeerId({ fixture: false })
-      const results = {
+      const result = {
        id: remotePeerId,
        multiaddrs: [
          new Multiaddr('/ip4/123.123.123.123/tcp/38982')
@ -380,14 +475,19 @@ describe('peer-routing', () => {

      const spy = sinon.spy(node.peerStore.addressBook, 'add')

-      sinon.stub(node._dht, 'findPeer').callsFake(() => {
-        return results
+      sinon.stub(node._dht, 'findPeer').callsFake(async function * () {
+        yield {
+          name: 'PEER_RESPONSE',
+          closer: [
+            result
+          ]
+        }
      })
      sinon.stub(delegate, 'findPeer').callsFake(() => {})

      await node.peerRouting.findPeer(remotePeerId)

-      expect(spy.calledWith(results.id, results.multiaddrs)).to.be.true()
+      expect(spy.calledWith(result.id, result.multiaddrs)).to.be.true()
    })

    it('should use the delegate if the dht fails to get the closest peer', async () => {
@ -487,8 +587,18 @@ describe('peer-routing', () => {

      sinon.spy(node.peerStore.addressBook, 'add')
      sinon.stub(node._dht, 'getClosestPeers').callsFake(function * () {
-        yield results[0]
-        yield results[1]
+        yield {
+          name: 'PEER_RESPONSE',
+          closer: [
+            results[0]
+          ]
+        }
+        yield {
+          name: 'PEER_RESPONSE',
+          closer: [
+            results[1]
+          ]
+        }
      })

      await node.start()
@ -522,7 +632,7 @@ describe('peer-routing', () => {
        started: false
      })

-      sinon.stub(node._dht, 'getClosestPeers').callsFake(function * () {
+      sinon.stub(node._dht, 'getClosestPeers').callsFake(async function * () {
        yield
        throw new Error('should not be called')
      })
--- a/test/peer-routing/utils.js
+++ b/test/peer-routing/utils.js
@ -13,9 +13,6 @@ const routingOptions = mergeOptions(baseOptions, {
  config: {
    dht: {
      kBucketSize: 20,
-      randomWalk: {
-        enabled: true
-      },
      enabled: true
    }
  }
--- a/test/peer-store/address-book.spec.js
+++ b/test/peer-store/address-book.spec.js
@ -45,7 +45,7 @@ describe('addressBook', () => {
    it('throwns invalid parameters error if invalid PeerId is provided', () => {
      try {
        ab.set('invalid peerId')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -55,7 +55,7 @@ describe('addressBook', () => {
    it('throwns invalid parameters error if no addresses provided', () => {
      try {
        ab.set(peerId)
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -65,7 +65,7 @@ describe('addressBook', () => {
    it('throwns invalid parameters error if invalid multiaddrs are provided', () => {
      try {
        ab.set(peerId, ['invalid multiaddr'])
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -159,7 +159,7 @@ describe('addressBook', () => {
    it('throwns invalid parameters error if invalid PeerId is provided', () => {
      try {
        ab.add('invalid peerId')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -169,7 +169,7 @@ describe('addressBook', () => {
    it('throwns invalid parameters error if no addresses provided', () => {
      try {
        ab.add(peerId)
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -179,7 +179,7 @@ describe('addressBook', () => {
    it('throwns invalid parameters error if invalid multiaddrs are provided', () => {
      try {
        ab.add(peerId, ['invalid multiaddr'])
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -308,7 +308,7 @@ describe('addressBook', () => {
    it('throwns invalid parameters error if invalid PeerId is provided', () => {
      try {
        ab.get('invalid peerId')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -343,7 +343,7 @@ describe('addressBook', () => {
    it('throwns invalid parameters error if invalid PeerId is provided', () => {
      try {
        ab.getMultiaddrsForPeer('invalid peerId')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -391,7 +391,7 @@ describe('addressBook', () => {
    it('throwns invalid parameters error if invalid PeerId is provided', () => {
      try {
        ab.delete('invalid peerId')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
--- a/test/peer-store/key-book.spec.js
+++ b/test/peer-store/key-book.spec.js
@ -23,7 +23,7 @@ describe('keyBook', () => {
  it('throws invalid parameters error if invalid PeerId is provided in set', () => {
    try {
      kb.set('invalid peerId')
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
      return
    }
@ -33,7 +33,7 @@ describe('keyBook', () => {
  it('throws invalid parameters error if invalid PeerId is provided in get', () => {
    try {
      kb.get('invalid peerId')
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
      return
    }
--- a/test/peer-store/metadata-book.spec.js
+++ b/test/peer-store/metadata-book.spec.js
@ -34,7 +34,7 @@ describe('metadataBook', () => {
    it('throws invalid parameters error if invalid PeerId is provided', () => {
      try {
        mb.set('invalid peerId')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -44,7 +44,7 @@ describe('metadataBook', () => {
    it('throws invalid parameters error if no key provided', () => {
      try {
        mb.set(peerId)
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -54,7 +54,7 @@ describe('metadataBook', () => {
    it('throws invalid parameters error if no value provided', () => {
      try {
        mb.set(peerId, 'location')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -64,7 +64,7 @@ describe('metadataBook', () => {
    it('throws invalid parameters error if value is not a buffer', () => {
      try {
        mb.set(peerId, 'location', 'mars')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -163,7 +163,7 @@ describe('metadataBook', () => {
    it('throws invalid parameters error if invalid PeerId is provided', () => {
      try {
        mb.get('invalid peerId')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -199,7 +199,7 @@ describe('metadataBook', () => {
    it('throws invalid parameters error if invalid PeerId is provided', () => {
      try {
        mb.getValue('invalid peerId')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -248,7 +248,7 @@ describe('metadataBook', () => {
    it('throwns invalid parameters error if invalid PeerId is provided', () => {
      try {
        mb.delete('invalid peerId')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
@ -305,7 +305,7 @@ describe('metadataBook', () => {
    it('throws invalid parameters error if invalid PeerId is provided', () => {
      try {
        mb.deleteValue('invalid peerId')
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        expect(err.code).to.equal(ERR_INVALID_PARAMETERS)
        return
      }
--- a/test/transports/transport-manager.node.js
+++ b/test/transports/transport-manager.node.js
@ -13,6 +13,7 @@ const { Multiaddr } = require('multiaddr')
 const mockUpgrader = require('../utils/mockUpgrader')
 const sinon = require('sinon')
 const Peers = require('../fixtures/peers')
+const pWaitFor = require('p-wait-for')
 const addrs = [
  new Multiaddr('/ip4/127.0.0.1/tcp/0'),
  new Multiaddr('/ip4/127.0.0.1/tcp/0')
@ -72,9 +73,13 @@ describe('Transport Manager (TCP)', () => {
    tm.add(Transport.prototype[Symbol.toStringTag], Transport)
    await tm.listen(addrs)

-    // Should created Self Peer record on new listen address
-    signedPeerRecord = await tm.libp2p.peerStore.addressBook.getPeerRecord(localPeer)
-    expect(signedPeerRecord).to.exist()
+    // Should created Self Peer record on new listen address, but it is done async
+    // with no event so we have to wait a bit
+    await pWaitFor(async () => {
+      signedPeerRecord = await tm.libp2p.peerStore.addressBook.getPeerRecord(localPeer)
+
+      return signedPeerRecord != null
+    }, { interval: 100, timeout: 2000 })

    const record = PeerRecord.createFromProtobuf(signedPeerRecord.payload)
    expect(record).to.exist()
--- a/test/transports/transport-manager.spec.js
+++ b/test/transports/transport-manager.spec.js
@ -201,7 +201,7 @@ describe('libp2p.transportManager (dial only)', () => {

    try {
      await libp2p.start()
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      expect(err).to.exist()
      expect(err.code).to.equal(ErrorCodes.ERR_NO_VALID_ADDRESSES)
      return
--- a/test/ts-use/package.json
+++ b/test/ts-use/package.json
@ -7,16 +7,16 @@
    "libp2p": "file:../..",
    "libp2p-bootstrap": "^0.13.0",
    "libp2p-delegated-content-routing": "^0.11.0",
-    "libp2p-delegated-peer-routing": "^0.10.0",
+    "libp2p-delegated-peer-routing": "^0.11.1",
    "libp2p-gossipsub": "^0.9.0",
    "libp2p-interfaces": "^1.0.1",
-    "libp2p-kad-dht": "^0.23.1",
+    "libp2p-kad-dht": "^0.26.5",
    "libp2p-mplex": "^0.10.4",
    "@chainsafe/libp2p-noise": "^4.1.0",
    "libp2p-record": "^0.10.4",
    "libp2p-tcp": "^0.17.1",
    "libp2p-websockets": "^0.16.1",
-    "peer-id": "^0.15.0"
+    "peer-id": "^0.16.0"
  },
  "scripts": {
    "build": "npx tsc",
--- a/test/ts-use/src/main.ts
+++ b/test/ts-use/src/main.ts
@ -123,11 +123,6 @@ async function main() {
      dht: {
        enabled: true,
        kBucketSize: 20,
-        randomWalk: {
-          enabled: true,            // Allows to disable discovery (enabled by default)
-          interval: 300e3,
-          timeout: 10e3
-        },
        clientMode: true,
        validators: {
          pk: Libp2pRecord.validator.validators.pk
--- a/test/utils/mockConnection.js
+++ b/test/utils/mockConnection.js
@ -108,7 +108,7 @@ function createConnection ({
        // Need to be able to notify a peer of this this._onStream({ connection, stream, protocol })
        const handler = protocols.get(protocol)
        handler({ connection, stream, protocol })
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
        // Do nothing
      }
    },
@ -124,7 +124,7 @@ function createConnection ({
    try {
      const { stream, protocol } = await mss.select(protocols)
      return { stream: { ...muxedStream, ...stream }, protocol }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
      throw errCode(err, codes.ERR_UNSUPPORTED_PROTOCOL)
    }
  }
--- a/tsconfig.json
+++ b/tsconfig.json
@ -1,5 +1,5 @@
 {
-  "extends": "./node_modules/aegir/src/config/tsconfig.aegir.json",
+  "extends": "aegir/src/config/tsconfig.aegir.json",
  "compilerOptions": {
    "outDir": "dist"
  },
Author	SHA1	Message	Date
achingbrain	ef54e0a10e	chore: release version v0.35.8	2021-12-29 11:00:11 +01:00
achingbrain	61bf546c46	chore: update contributors	2021-12-29 11:00:11 +01:00
Alex Potsides	d2b7ec0f6b	fix: look for final peer event instead of peer response (#1092 ) `FINAL_PEER` means we found the peer, `PEER_RESPONSE` means a peer responded to our query.	2021-12-29 10:56:56 +01:00
Alex Potsides	79b3cfc6ad	fix: do not wait for autodial start (#1089 ) When we've previously seen loads of peers and stored them in the datastore we'll try to dial them as part of starting the autodial component. If we or our peers have bad network connections this can make starting a libp2p node take ages so don't wait for a round of auto dialing before considering the component started.	2021-12-29 10:55:48 +01:00
Alex Potsides	f18fc80b70	fix: increase listeners on any-signal (#1084 ) Increase the number of listeners we allow on the actual signal we pass along, instead of the signal we pass into any-signal.	2021-12-29 10:51:26 +01:00
Alex Potsides	b4b432406e	fix: record tracked map clears (#1085 ) Record the size of a map after we `.clear()` it.	2021-12-27 07:14:27 +01:00
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