test(fix): fix listening test for ci

chore: release version v0.27.0-rc.0
chore: update contributors
2025-07-09 22:01:34 +00:00 · 2020-01-24 14:31:38 +01:00 · 2020-01-24 11:55:59 +01:00 · 2020-01-24 11:55:59 +01:00 · 2020-01-24 11:43:56 +01:00 · 2020-01-23 17:12:41 +01:00
73 changed files with 858 additions and 1065 deletions
--- a/.aegir.js
+++ b/.aegir.js
@ -45,7 +45,7 @@ const after = async () => {
 }

 module.exports = {
-  bundlesize: { maxSize: '179kB' },
+  bundlesize: { maxSize: '220kB' },
  hooks: {
    pre: before,
    post: after
--- a/.travis.yml
+++ b/.travis.yml
@ -39,12 +39,5 @@ jobs:
      script:
        - npx aegir test -t browser -t webworker -- --browsers FirefoxHeadless

-    - stage: test
-      name: interop
-      script:
-        - cd node_modules/interop-libp2p
-        - npm install
-        - LIBP2P_JS=${TRAVIS_BUILD_DIR}/src/index.js npx aegir test -t node --bail
-
 notifications:
  email: false
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@ -1,115 +1,3 @@
-<a name="0.27.7"></a>
-## [0.27.7](https://github.com/libp2p/js-libp2p/compare/v0.27.6...v0.27.7) (2020-04-24)
-
-
-### Bug Fixes
-
-* remove node global ([#587](https://github.com/libp2p/js-libp2p/issues/587)) ([9b13fe3](https://github.com/libp2p/js-libp2p/commit/9b13fe3))
-
-
-
-<a name="0.27.6"></a>
-## [0.27.6](https://github.com/libp2p/js-libp2p/compare/v0.27.5...v0.27.6) (2020-04-16)
-
-
-### Bug Fixes
-
-* add null check in libp2p.hangUp() ([c940f2d](https://github.com/libp2p/js-libp2p/commit/c940f2d))
-* make circuit relay listening addresses more forgiving ([#604](https://github.com/libp2p/js-libp2p/issues/604)) ([e192eb6](https://github.com/libp2p/js-libp2p/commit/e192eb6))
-
-
-
-<a name="0.27.5"></a>
-## [0.27.5](https://github.com/libp2p/js-libp2p/compare/v0.27.4...v0.27.5) (2020-04-06)
-
-
-### Bug Fixes
-
-* await peer discovery start in libp2p start ([#600](https://github.com/libp2p/js-libp2p/issues/600)) ([bd7fd0f](https://github.com/libp2p/js-libp2p/commit/bd7fd0f))
-
-
-
-<a name="0.27.4"></a>
-## [0.27.4](https://github.com/libp2p/js-libp2p/compare/v0.27.3...v0.27.4) (2020-03-31)
-
-
-### Bug Fixes
-
-* only use a single export ([#596](https://github.com/libp2p/js-libp2p/issues/596)) ([3072875](https://github.com/libp2p/js-libp2p/commit/3072875))
-* pass libp2p to discovery services ([#597](https://github.com/libp2p/js-libp2p/issues/597)) ([9e35fbc](https://github.com/libp2p/js-libp2p/commit/9e35fbc))
-* **test:** improve flakey random walk discovery test ([#574](https://github.com/libp2p/js-libp2p/issues/574)) ([f4ec355](https://github.com/libp2p/js-libp2p/commit/f4ec355))
-* remove use of assert module ([#561](https://github.com/libp2p/js-libp2p/issues/561)) ([a8984c6](https://github.com/libp2p/js-libp2p/commit/a8984c6))
-
-
-
-<a name="0.27.3"></a>
-## [0.27.3](https://github.com/libp2p/js-libp2p/compare/v0.27.2...v0.27.3) (2020-02-11)
-
-
-### Bug Fixes
-
-* dont allow multiaddr dials without a peer id ([#558](https://github.com/libp2p/js-libp2p/issues/558)) ([a317a8b](https://github.com/libp2p/js-libp2p/commit/a317a8b))
-
-
-
-<a name="0.27.2"></a>
-## [0.27.2](https://github.com/libp2p/js-libp2p/compare/v0.27.1...v0.27.2) (2020-02-05)
-
-
-### Bug Fixes
-
-* ensure identify streams are closed ([#551](https://github.com/libp2p/js-libp2p/issues/551)) ([f662fdc](https://github.com/libp2p/js-libp2p/commit/f662fdc))
-
-
-
-<a name="0.27.1"></a>
-## [0.27.1](https://github.com/libp2p/js-libp2p/compare/v0.27.0...v0.27.1) (2020-02-03)
-
-
-### Bug Fixes
-
-* stop stream after first pong received ([#545](https://github.com/libp2p/js-libp2p/issues/545)) ([be8fc9d](https://github.com/libp2p/js-libp2p/commit/be8fc9d))
-
-
-
-<a name="0.27.0"></a>
-# [0.27.0](https://github.com/libp2p/js-libp2p/compare/v0.26.2...v0.27.0) (2020-01-28)
-
-
-### Bug Fixes
-
-* clean up peer discovery flow ([#494](https://github.com/libp2p/js-libp2p/issues/494)) ([12fc069](https://github.com/libp2p/js-libp2p/commit/12fc069))
-* clean up pending dials abort per feedback ([633b0c2](https://github.com/libp2p/js-libp2p/commit/633b0c2))
-* conn mngr min/max connection values ([#528](https://github.com/libp2p/js-libp2p/issues/528)) ([ba4681b](https://github.com/libp2p/js-libp2p/commit/ba4681b))
-* correct release readme ([ce8e60b](https://github.com/libp2p/js-libp2p/commit/ce8e60b))
-* examples readme typos ([#481](https://github.com/libp2p/js-libp2p/issues/481)) ([35ac02d](https://github.com/libp2p/js-libp2p/commit/35ac02d))
-* make dialer configurable ([#521](https://github.com/libp2p/js-libp2p/issues/521)) ([4ca481b](https://github.com/libp2p/js-libp2p/commit/4ca481b))
-* performance bottleneck in stat.js ([#463](https://github.com/libp2p/js-libp2p/issues/463)) ([93a1e42](https://github.com/libp2p/js-libp2p/commit/93a1e42))
-* registrar should filter the disconnected conn ([#532](https://github.com/libp2p/js-libp2p/issues/532)) ([bb2e56e](https://github.com/libp2p/js-libp2p/commit/bb2e56e))
-* release tokens as soon as they are available ([2570a1b](https://github.com/libp2p/js-libp2p/commit/2570a1b))
-* replace peerInfo addresses with listen addresses ([#485](https://github.com/libp2p/js-libp2p/issues/485)) ([1999606](https://github.com/libp2p/js-libp2p/commit/1999606))
-* stop discoveries ([#530](https://github.com/libp2p/js-libp2p/issues/530)) ([4222c49](https://github.com/libp2p/js-libp2p/commit/4222c49))
-* token release logic ([90ecc57](https://github.com/libp2p/js-libp2p/commit/90ecc57))
-* upgrader should not need muxers ([#517](https://github.com/libp2p/js-libp2p/issues/517)) ([5d7ee50](https://github.com/libp2p/js-libp2p/commit/5d7ee50))
-* use toB58String everywhere to be consistent ([#537](https://github.com/libp2p/js-libp2p/issues/537)) ([c1038be](https://github.com/libp2p/js-libp2p/commit/c1038be))
-
-
-### Features
-
-* abort all pending dials on stop ([ba02764](https://github.com/libp2p/js-libp2p/commit/ba02764))
-* add early token recycling in ([a5b54a7](https://github.com/libp2p/js-libp2p/commit/a5b54a7))
-* add libp2p.connections getter ([#522](https://github.com/libp2p/js-libp2p/issues/522)) ([6445fda](https://github.com/libp2p/js-libp2p/commit/6445fda))
-* add token based dialer ([e445a17](https://github.com/libp2p/js-libp2p/commit/e445a17))
-* allow transport options to be passed on creation ([#524](https://github.com/libp2p/js-libp2p/issues/524)) ([c339be1](https://github.com/libp2p/js-libp2p/commit/c339be1))
-* coalescing dial support ([#518](https://github.com/libp2p/js-libp2p/issues/518)) ([15f7c2a](https://github.com/libp2p/js-libp2p/commit/15f7c2a))
-* discovery modules ([#486](https://github.com/libp2p/js-libp2p/issues/486)) ([18a062e](https://github.com/libp2p/js-libp2p/commit/18a062e))
-* discovery modules from transports should be added ([#510](https://github.com/libp2p/js-libp2p/issues/510)) ([f1eb373](https://github.com/libp2p/js-libp2p/commit/f1eb373))
-* peer store ([#470](https://github.com/libp2p/js-libp2p/issues/470)) ([582094a](https://github.com/libp2p/js-libp2p/commit/582094a))
-* registrar ([#471](https://github.com/libp2p/js-libp2p/issues/471)) ([9d52b80](https://github.com/libp2p/js-libp2p/commit/9d52b80))
-* support peer-id instances in peer store operations ([#491](https://github.com/libp2p/js-libp2p/issues/491)) ([8da9fc9](https://github.com/libp2p/js-libp2p/commit/8da9fc9))
-
-
-
 <a name="0.27.0-rc.0"></a>
 # [0.27.0-rc.0](https://github.com/libp2p/js-libp2p/compare/v0.27.0-pre.2...v0.27.0-rc.0) (2020-01-24)

--- a/ISSUE_TEMPLATE.md
+++ b/ISSUE_TEMPLATE.md
@ -37,7 +37,7 @@ One of following:

 <!--
 This is for you! Please read, and then delete this text before posting it.
-The js-libp2p issues are only for bug reports and directly actionable features.
+The js-ipfs issues are only for bug reports and directly actionable features.

 Read https://github.com/ipfs/community/blob/master/CONTRIBUTING.md#reporting-issues if your issue doesn't fit either of those categories.
 -->
--- a/README.md
+++ b/README.md
@ -5,14 +5,12 @@
 <h3 align="center">The JavaScript implementation of the libp2p Networking Stack.</h3>

 <p align="center">
-  <a href="http://protocol.ai"><img src="https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square" /></a>
+  <a href="http://ipn.io"><img src="https://img.shields.io/badge/made%20by-Protocol%20Labs-blue.svg?style=flat-square" /></a>
  <a href="http://libp2p.io/"><img src="https://img.shields.io/badge/project-libp2p-yellow.svg?style=flat-square" /></a>
  <a href="http://webchat.freenode.net/?channels=%23libp2p"><img src="https://img.shields.io/badge/freenode-%23libp2p-yellow.svg?style=flat-square" /></a>
-  <a href="https://riot.im/app/#/room/#libp2p:matrix.org"><img src="https://img.shields.io/badge/matrix-%23libp2p%3Apermaweb.io-blue.svg?style=flat-square" /> </a>
+  <a href="https://riot.permaweb.io/#/room/#libp2p:permaweb.io"><img src="https://img.shields.io/badge/matrix-%23libp2p%3Apermaweb.io-blue.svg?style=flat-square" /> </a>
  <a href="https://discord.gg/66KBrm2"><img src="https://img.shields.io/discord/475789330380488707?color=blueviolet&label=discord&style=flat-square" /></a>
  <a href="https://discuss.libp2p.io"><img src="https://img.shields.io/discourse/https/discuss.libp2p.io/posts.svg" /></a>
-  <a href="https://www.npmjs.com/package/libp2p"><img src="https://img.shields.io/npm/dm/libp2p.svg" /></a>
-  <a href="https://www.jsdelivr.com/package/npm/libp2p"><img src="https://data.jsdelivr.com/v1/package/npm/libp2p/badge"/></a>
 </p>

 <p align="center">
@ -32,9 +30,6 @@

 We've come a long way, but this project is still in Alpha, lots of development is happening, API might change, beware of the Dragons 🐉..

-The documentation in the master branch may contain changes from a pre-release.
-If you are looking for the documentation of the latest release, you can view the latest release on [**npm**](https://www.npmjs.com/package/libp2p), or select the tag in github that matches the version you are looking for.
-
 **Want to get started?** Check our [examples folder](/examples).

 [**`Weekly Core Dev Calls`**](https://github.com/ipfs/pm/issues/650)
@ -137,45 +132,49 @@ List of packages currently in existence for libp2p
 | Package | Version | Deps | CI | Coverage | Lead Maintainer |
 | ---------|---------|---------|---------|---------|--------- |
 | **libp2p** |
-| [`libp2p`](//github.com/libp2p/js-libp2p) | [![npm](https://img.shields.io/npm/v/libp2p.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p/master)](https://travis-ci.com/libp2p/js-libp2p) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p) | [Jacob Heun](mailto:jacobheun@gmail.com) |
-| [`libp2p-daemon`](//github.com/libp2p/js-libp2p-daemon) | [![npm](https://img.shields.io/npm/v/libp2p-daemon.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-daemon/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-daemon.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-daemon) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-daemon/master)](https://travis-ci.com/libp2p/js-libp2p-daemon) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-daemon/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-daemon) | [Jacob Heun](mailto:jacobheun@gmail.com) |
-| [`libp2p-daemon-client`](//github.com/libp2p/js-libp2p-daemon-client) | [![npm](https://img.shields.io/npm/v/libp2p-daemon-client.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-daemon-client/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-daemon-client.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-daemon-client) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-daemon-client/master)](https://travis-ci.com/libp2p/js-libp2p-daemon-client) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-daemon-client/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-daemon-client) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
-| [`libp2p-interfaces`](//github.com/libp2p/js-interfaces) | [![npm](https://img.shields.io/npm/v/libp2p-interfaces.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-interfaces/releases) | [![Deps](https://david-dm.org/libp2p/js-interfaces.svg?style=flat-square)](https://david-dm.org/libp2p/js-interfaces) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-interfaces/master)](https://travis-ci.com/libp2p/js-interfaces) | [![codecov](https://codecov.io/gh/libp2p/js-interfaces/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-interfaces) | [Jacob Heun](mailto:jacobheun@gmail.com) |
-| [`interop-libp2p`](//github.com/libp2p/interop) | [![npm](https://img.shields.io/npm/v/interop-libp2p.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/interop/releases) | [![Deps](https://david-dm.org/libp2p/interop.svg?style=flat-square)](https://david-dm.org/libp2p/interop) | [![Travis CI](https://flat.badgen.net/travis/libp2p/interop/master)](https://travis-ci.com/libp2p/interop) | [![codecov](https://codecov.io/gh/libp2p/interop/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/interop) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
+| [`libp2p`](//github.com/libp2p/js-libp2p) | [![npm](https://img.shields.io/npm/v/libp2p.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p) | [Jacob Heun](mailto:jacobheun@gmail.com) |
+| [`libp2p-daemon`](//github.com/libp2p/js-libp2p-daemon) | [![npm](https://img.shields.io/npm/v/libp2p-daemon.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-daemon/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-daemon.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-daemon) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-daemon.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-daemon) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-daemon/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-daemon) | [Jacob Heun](mailto:jacobheun@gmail.com) |
+| [`libp2p-daemon-client`](//github.com/libp2p/js-libp2p-daemon-client) | [![npm](https://img.shields.io/npm/v/libp2p-daemon-client.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-daemon-client/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-daemon-client.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-daemon-client) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-daemon-client.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-daemon-client) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-daemon-client/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-daemon-client) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
+| [`libp2p-interfaces`](//github.com/libp2p/js-interfaces) | [![npm](https://img.shields.io/npm/v/libp2p-interfaces.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-interfaces/releases) | [![Deps](https://david-dm.org/libp2p/js-interfaces.svg?style=flat-square)](https://david-dm.org/libp2p/js-interfaces) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-interfaces.svg?branch=master)](https://travis-ci.com/libp2p/js-interfaces) | [![codecov](https://codecov.io/gh/libp2p/js-interfaces/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-interfaces) | [Jacob Heun](mailto:jacobheun@gmail.com) |
+| [`interop-libp2p`](//github.com/libp2p/interop) | [![npm](https://img.shields.io/npm/v/interop-libp2p.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/interop/releases) | [![Deps](https://david-dm.org/libp2p/interop.svg?style=flat-square)](https://david-dm.org/libp2p/interop) | [![Travis CI](https://flat.badgen.net/travis/libp2p/interop.svg?branch=master)](https://travis-ci.com/libp2p/interop) | [![codecov](https://codecov.io/gh/libp2p/interop/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/interop) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
 | **transports** |
-| [`libp2p-tcp`](//github.com/libp2p/js-libp2p-tcp) | [![npm](https://img.shields.io/npm/v/libp2p-tcp.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-tcp/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-tcp.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-tcp) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-tcp/master)](https://travis-ci.com/libp2p/js-libp2p-tcp) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-tcp/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-tcp) | [Jacob Heun](mailto:jacobheun@gmail.com) |
-| [`libp2p-webrtc-direct`](//github.com/libp2p/js-libp2p-webrtc-direct) | [![npm](https://img.shields.io/npm/v/libp2p-webrtc-direct.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-webrtc-direct/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-webrtc-direct.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-webrtc-direct) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-webrtc-direct/master)](https://travis-ci.com/libp2p/js-libp2p-webrtc-direct) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-webrtc-direct/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-webrtc-direct) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
-| [`libp2p-webrtc-star`](//github.com/libp2p/js-libp2p-webrtc-star) | [![npm](https://img.shields.io/npm/v/libp2p-webrtc-star.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-webrtc-star/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-webrtc-star.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-webrtc-star) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-webrtc-star/master)](https://travis-ci.com/libp2p/js-libp2p-webrtc-star) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-webrtc-star/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-webrtc-star) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
-| [`libp2p-websockets`](//github.com/libp2p/js-libp2p-websockets) | [![npm](https://img.shields.io/npm/v/libp2p-websockets.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-websockets/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-websockets.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-websockets) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-websockets/master)](https://travis-ci.com/libp2p/js-libp2p-websockets) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-websockets/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-websockets) | [Jacob Heun](mailto:jacobheun@gmail.com) |
+| [`libp2p-tcp`](//github.com/libp2p/js-libp2p-tcp) | [![npm](https://img.shields.io/npm/v/libp2p-tcp.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-tcp/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-tcp.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-tcp) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-tcp.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-tcp) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-tcp/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-tcp) | [Jacob Heun](mailto:jacobheun@gmail.com) |
+| [`libp2p-utp`](//github.com/libp2p/js-libp2p-utp) | [![npm](https://img.shields.io/npm/v/libp2p-utp.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-utp/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-utp.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-utp) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-utp.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-utp) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-utp/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-utp) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
+| [`libp2p-webrtc-direct`](//github.com/libp2p/js-libp2p-webrtc-direct) | [![npm](https://img.shields.io/npm/v/libp2p-webrtc-direct.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-webrtc-direct/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-webrtc-direct.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-webrtc-direct) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-webrtc-direct.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-webrtc-direct) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-webrtc-direct/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-webrtc-direct) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
+| [`libp2p-webrtc-star`](//github.com/libp2p/js-libp2p-webrtc-star) | [![npm](https://img.shields.io/npm/v/libp2p-webrtc-star.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-webrtc-star/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-webrtc-star.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-webrtc-star) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-webrtc-star.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-webrtc-star) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-webrtc-star/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-webrtc-star) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
+| [`libp2p-websockets`](//github.com/libp2p/js-libp2p-websockets) | [![npm](https://img.shields.io/npm/v/libp2p-websockets.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-websockets/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-websockets.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-websockets) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-websockets.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-websockets) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-websockets/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-websockets) | [Jacob Heun](mailto:jacobheun@gmail.com) |
+| [`libp2p-websocket-star`](//github.com/libp2p/js-libp2p-websocket-star) | [![npm](https://img.shields.io/npm/v/libp2p-websocket-star.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-websocket-star/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-websocket-star.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-websocket-star) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-websocket-star.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-websocket-star) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-websocket-star/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-websocket-star) | [Jacob Heun](mailto:jacobheun@gmail.com) |
 | **secure channels** |
-| [`libp2p-secio`](//github.com/libp2p/js-libp2p-secio) | [![npm](https://img.shields.io/npm/v/libp2p-secio.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-secio/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-secio.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-secio) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-secio/master)](https://travis-ci.com/libp2p/js-libp2p-secio) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-secio/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-secio) | [Friedel Ziegelmayer](mailto:dignifiedquire@gmail.com) |
+| [`libp2p-secio`](//github.com/libp2p/js-libp2p-secio) | [![npm](https://img.shields.io/npm/v/libp2p-secio.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-secio/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-secio.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-secio) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-secio.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-secio) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-secio/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-secio) | [Friedel Ziegelmayer](mailto:dignifiedquire@gmail.com) |
 | **stream multiplexers** |
-| [`libp2p-mplex`](//github.com/libp2p/js-libp2p-mplex) | [![npm](https://img.shields.io/npm/v/libp2p-mplex.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-mplex/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-mplex.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-mplex) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-mplex/master)](https://travis-ci.com/libp2p/js-libp2p-mplex) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-mplex/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-mplex) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
+| [`libp2p-mplex`](//github.com/libp2p/js-libp2p-mplex) | [![npm](https://img.shields.io/npm/v/libp2p-mplex.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-mplex/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-mplex.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-mplex) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-mplex.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-mplex) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-mplex/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-mplex) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
+| [`libp2p-spdy`](//github.com/libp2p/js-libp2p-spdy) | [![npm](https://img.shields.io/npm/v/libp2p-spdy.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-spdy/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-spdy.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-spdy) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-spdy.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-spdy) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-spdy/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-spdy) | [Jacob Heun](mailto:jacobheun@gmail.com) |
 | **peer discovery** |
-| [`libp2p-bootstrap`](//github.com/libp2p/js-libp2p-bootstrap) | [![npm](https://img.shields.io/npm/v/libp2p-bootstrap.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-bootstrap/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-bootstrap.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-bootstrap) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-bootstrap/master)](https://travis-ci.com/libp2p/js-libp2p-bootstrap) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-bootstrap/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-bootstrap) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
-| [`libp2p-kad-dht`](//github.com/libp2p/js-libp2p-kad-dht) | [![npm](https://img.shields.io/npm/v/libp2p-kad-dht.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-kad-dht/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-kad-dht.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-dht) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-kad-dht/master)](https://travis-ci.com/libp2p/js-libp2p-kad-dht) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-kad-dht/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-kad-dht) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
-| [`libp2p-mdns`](//github.com/libp2p/js-libp2p-mdns) | [![npm](https://img.shields.io/npm/v/libp2p-mdns.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-mdns/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-mdns.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-mdns) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-mdns/master)](https://travis-ci.com/libp2p/js-libp2p-mdns) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-mdns/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-mdns) | [Jacob Heun](mailto:jacobheun@gmail.com) |
-| [`libp2p-webrtc-star`](//github.com/libp2p/js-libp2p-webrtc-star) | [![npm](https://img.shields.io/npm/v/libp2p-webrtc-star.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-webrtc-star/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-webrtc-star.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-webrtc-star) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-webrtc-star/master)](https://travis-ci.com/libp2p/js-libp2p-webrtc-star) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-webrtc-star/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-webrtc-star) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
-| [`discv5`](//github.com/ChainSafe/discv5) | [![npm](https://img.shields.io/npm/v/discv5.svg?maxAge=86400&style=flat-square)](//github.com/ChainSafe/discv5/releases) | [![Deps](https://david-dm.org/ChainSafe/discv5.svg?style=flat-square)](https://david-dm.org/ChainSafe/discv5) | [![Travis CI](https://flat.badgen.net/travis/ChainSafe/discv5/master)](https://travis-ci.com/ChainSafe/discv5) | [![codecov](https://codecov.io/gh/ChainSafe/discv5/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/ChainSafe/discv5) | [Cayman Nava](mailto:caymannava@gmail.com) |
+| [`libp2p-bootstrap`](//github.com/libp2p/js-libp2p-bootstrap) | [![npm](https://img.shields.io/npm/v/libp2p-bootstrap.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-bootstrap/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-bootstrap.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-bootstrap) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-bootstrap.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-bootstrap) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-bootstrap/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-bootstrap) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
+| [`libp2p-kad-dht`](//github.com/libp2p/js-libp2p-kad-dht) | [![npm](https://img.shields.io/npm/v/libp2p-kad-dht.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-kad-dht/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-kad-dht.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-dht) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-kad-dht.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-kad-dht) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-kad-dht/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-kad-dht) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
+| [`libp2p-mdns`](//github.com/libp2p/js-libp2p-mdns) | [![npm](https://img.shields.io/npm/v/libp2p-mdns.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-mdns/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-mdns.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-mdns) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-mdns.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-mdns) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-mdns/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-mdns) | [Jacob Heun](mailto:jacobheun@gmail.com) |
+| [`libp2p-rendezvous`](//github.com/libp2p/js-libp2p-rendezvous) | [![npm](https://img.shields.io/npm/v/libp2p-rendezvous.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-rendezvous/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-rendezvous.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-rendezvous) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-rendezvous.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-rendezvous) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-rendezvous/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-rendezvous) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
+| [`libp2p-webrtc-star`](//github.com/libp2p/js-libp2p-webrtc-star) | [![npm](https://img.shields.io/npm/v/libp2p-webrtc-star.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-webrtc-star/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-webrtc-star.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-webrtc-star) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-webrtc-star.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-webrtc-star) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-webrtc-star/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-webrtc-star) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
+| [`libp2p-websocket-star`](//github.com/libp2p/js-libp2p-websocket-star) | [![npm](https://img.shields.io/npm/v/libp2p-websocket-star.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-websocket-star/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-websocket-star.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-websocket-star) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-websocket-star.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-websocket-star) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-websocket-star/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-websocket-star) | [Jacob Heun](mailto:jacobheun@gmail.com) |
 | **content routing** |
-| [`libp2p-delegated-content-routing`](//github.com/libp2p/js-libp2p-delegated-content-routing) | [![npm](https://img.shields.io/npm/v/libp2p-delegated-content-routing.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-delegated-content-routing/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-delegated-content-routing.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-delegated-content-routing) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-delegated-content-routing/master)](https://travis-ci.com/libp2p/js-libp2p-delegated-content-routing) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-delegated-content-routing/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-delegated-content-routing) | [Jacob Heun](mailto:jacobheun@gmail.com) |
-| [`libp2p-kad-dht`](//github.com/libp2p/js-libp2p-kad-dht) | [![npm](https://img.shields.io/npm/v/libp2p-kad-dht.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-kad-dht/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-kad-dht.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-dht) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-kad-dht/master)](https://travis-ci.com/libp2p/js-libp2p-kad-dht) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-kad-dht/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-kad-dht) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
+| [`libp2p-delegated-content-routing`](//github.com/libp2p/js-libp2p-delegated-content-routing) | [![npm](https://img.shields.io/npm/v/libp2p-delegated-content-routing.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-delegated-content-routing/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-delegated-content-routing.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-delegated-content-routing) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-delegated-content-routing.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-delegated-content-routing) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-delegated-content-routing/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-delegated-content-routing) | [Jacob Heun](mailto:jacobheun@gmail.com) |
+| [`libp2p-kad-dht`](//github.com/libp2p/js-libp2p-kad-dht) | [![npm](https://img.shields.io/npm/v/libp2p-kad-dht.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-kad-dht/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-kad-dht.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-dht) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-kad-dht.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-kad-dht) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-kad-dht/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-kad-dht) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
 | **peer routing** |
-| [`libp2p-delegated-peer-routing`](//github.com/libp2p/js-libp2p-delegated-peer-routing) | [![npm](https://img.shields.io/npm/v/libp2p-delegated-peer-routing.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-delegated-peer-routing/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-delegated-peer-routing.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-delegated-peer-routing) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-delegated-peer-routing/master)](https://travis-ci.com/libp2p/js-libp2p-delegated-peer-routing) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-delegated-peer-routing/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-delegated-peer-routing) | [Jacob Heun](mailto:jacobheun@gmail.com) |
-| [`libp2p-kad-dht`](//github.com/libp2p/js-libp2p-kad-dht) | [![npm](https://img.shields.io/npm/v/libp2p-kad-dht.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-kad-dht/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-kad-dht.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-dht) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-kad-dht/master)](https://travis-ci.com/libp2p/js-libp2p-kad-dht) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-kad-dht/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-kad-dht) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
+| [`libp2p-delegated-peer-routing`](//github.com/libp2p/js-libp2p-delegated-peer-routing) | [![npm](https://img.shields.io/npm/v/libp2p-delegated-peer-routing.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-delegated-peer-routing/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-delegated-peer-routing.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-delegated-peer-routing) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-delegated-peer-routing.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-delegated-peer-routing) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-delegated-peer-routing/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-delegated-peer-routing) | [Jacob Heun](mailto:jacobheun@gmail.com) |
+| [`libp2p-kad-dht`](//github.com/libp2p/js-libp2p-kad-dht) | [![npm](https://img.shields.io/npm/v/libp2p-kad-dht.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-kad-dht/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-kad-dht.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-dht) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-kad-dht.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-kad-dht) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-kad-dht/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-kad-dht) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
 | **utilities** |
-| [`libp2p-crypto`](//github.com/libp2p/js-libp2p-crypto) | [![npm](https://img.shields.io/npm/v/libp2p-crypto.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-crypto/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-crypto.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-crypto) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-crypto/master)](https://travis-ci.com/libp2p/js-libp2p-crypto) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-crypto/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-crypto) | [Jacob Heun](mailto:jacobheun@gmail.com) |
-| [`libp2p-crypto-secp256k1`](//github.com/libp2p/js-libp2p-crypto-secp256k1) | [![npm](https://img.shields.io/npm/v/libp2p-crypto-secp256k1.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-crypto-secp256k1/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-crypto-secp256k1.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-crypto-secp256k1) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-crypto-secp256k1/master)](https://travis-ci.com/libp2p/js-libp2p-crypto-secp256k1) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-crypto-secp256k1/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-crypto-secp256k1) | [Friedel Ziegelmayer](mailto:dignifiedquire@gmail.com) |
+| [`libp2p-crypto`](//github.com/libp2p/js-libp2p-crypto) | [![npm](https://img.shields.io/npm/v/libp2p-crypto.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-crypto/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-crypto.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-crypto) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-crypto.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-crypto) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-crypto/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-crypto) | [Jacob Heun](mailto:jacobheun@gmail.com) |
+| [`libp2p-crypto-secp256k1`](//github.com/libp2p/js-libp2p-crypto-secp256k1) | [![npm](https://img.shields.io/npm/v/libp2p-crypto-secp256k1.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-crypto-secp256k1/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-crypto-secp256k1.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-crypto-secp256k1) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-crypto-secp256k1.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-crypto-secp256k1) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-crypto-secp256k1/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-crypto-secp256k1) | [Friedel Ziegelmayer](mailto:dignifiedquire@gmail.com) |
 | **data types** |
-| [`peer-id`](//github.com/libp2p/js-peer-id) | [![npm](https://img.shields.io/npm/v/peer-id.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-peer-id/releases) | [![Deps](https://david-dm.org/libp2p/js-peer-id.svg?style=flat-square)](https://david-dm.org/libp2p/js-peer-id) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-peer-id/master)](https://travis-ci.com/libp2p/js-peer-id) | [![codecov](https://codecov.io/gh/libp2p/js-peer-id/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-peer-id) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
-| [`peer-info`](//github.com/libp2p/js-peer-info) | [![npm](https://img.shields.io/npm/v/peer-info.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-peer-info/releases) | [![Deps](https://david-dm.org/libp2p/js-peer-info.svg?style=flat-square)](https://david-dm.org/libp2p/js-peer-info) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-peer-info/master)](https://travis-ci.com/libp2p/js-peer-info) | [![codecov](https://codecov.io/gh/libp2p/js-peer-info/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-peer-info) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
+| [`peer-id`](//github.com/libp2p/js-peer-id) | [![npm](https://img.shields.io/npm/v/peer-id.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-peer-id/releases) | [![Deps](https://david-dm.org/libp2p/js-peer-id.svg?style=flat-square)](https://david-dm.org/libp2p/js-peer-id) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-peer-id.svg?branch=master)](https://travis-ci.com/libp2p/js-peer-id) | [![codecov](https://codecov.io/gh/libp2p/js-peer-id/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-peer-id) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
+| [`peer-info`](//github.com/libp2p/js-peer-info) | [![npm](https://img.shields.io/npm/v/peer-info.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-peer-info/releases) | [![Deps](https://david-dm.org/libp2p/js-peer-info.svg?style=flat-square)](https://david-dm.org/libp2p/js-peer-info) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-peer-info.svg?branch=master)](https://travis-ci.com/libp2p/js-peer-info) | [![codecov](https://codecov.io/gh/libp2p/js-peer-info/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-peer-info) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
 | **pubsub** |
-| [`libp2p-pubsub`](//github.com/libp2p/js-libp2p-pubsub) | [![npm](https://img.shields.io/npm/v/libp2p-pubsub.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-pubsub/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-pubsub.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-pubsub) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-pubsub/master)](https://travis-ci.com/libp2p/js-libp2p-pubsub) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-pubsub/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-pubsub) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
-| [`libp2p-floodsub`](//github.com/libp2p/js-libp2p-floodsub) | [![npm](https://img.shields.io/npm/v/libp2p-floodsub.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-floodsub/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-floodsub.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-floodsub) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-floodsub/master)](https://travis-ci.com/libp2p/js-libp2p-floodsub) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-floodsub/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-floodsub) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
-| [`libp2p-gossipsub`](//github.com/ChainSafe/gossipsub-js) | [![npm](https://img.shields.io/npm/v/libp2p-gossipsub.svg?maxAge=86400&style=flat-square)](//github.com/ChainSafe/gossipsub-js/releases) | [![Deps](https://david-dm.org/ChainSafe/gossipsub-js.svg?style=flat-square)](https://david-dm.org/ChainSafe/gossipsub-js) | [![Travis CI](https://flat.badgen.net/travis/ChainSafe/gossipsub-js/master)](https://travis-ci.com/ChainSafe/gossipsub-js) | [![codecov](https://codecov.io/gh/ChainSafe/gossipsub-js/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/ChainSafe/gossipsub-js) | [Cayman Nava](mailto:caymannava@gmail.com) |
+| [`libp2p-pubsub`](//github.com/libp2p/js-libp2p-pubsub) | [![npm](https://img.shields.io/npm/v/libp2p-pubsub.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-pubsub/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-pubsub.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-pubsub) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-pubsub.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-pubsub) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-pubsub/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-pubsub) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
+| [`libp2p-floodsub`](//github.com/libp2p/js-libp2p-floodsub) | [![npm](https://img.shields.io/npm/v/libp2p-floodsub.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-floodsub/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-floodsub.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-floodsub) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-floodsub.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-floodsub) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-floodsub/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-floodsub) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
+| [`libp2p-gossipsub`](//github.com/ChainSafe/gossipsub-js) | [![npm](https://img.shields.io/npm/v/libp2p-gossipsub.svg?maxAge=86400&style=flat-square)](//github.com/ChainSafe/gossipsub-js/releases) | [![Deps](https://david-dm.org/ChainSafe/gossipsub-js.svg?style=flat-square)](https://david-dm.org/ChainSafe/gossipsub-js) | [![Travis CI](https://flat.badgen.net/travis/ChainSafe/gossipsub-js.svg?branch=master)](https://travis-ci.com/ChainSafe/gossipsub-js) | [![codecov](https://codecov.io/gh/ChainSafe/gossipsub-js/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/ChainSafe/gossipsub-js) | [Cayman Nava](mailto:caymannava@gmail.com) |
 | **extensions** |
-| [`libp2p-nat-mgnr`](//github.com/libp2p/js-libp2p-nat-mgnr) | [![npm](https://img.shields.io/npm/v/libp2p-nat-mgnr.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-nat-mgnr/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-nat-mgnr.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-nat-mgnr) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-nat-mgnr/master)](https://travis-ci.com/libp2p/js-libp2p-nat-mgnr) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-nat-mgnr/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-nat-mgnr) | N/A |
-| [`libp2p-utils`](//github.com/libp2p/js-libp2p-utils) | [![npm](https://img.shields.io/npm/v/libp2p-utils.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-utils/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-utils.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-utils) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-utils/master)](https://travis-ci.com/libp2p/js-libp2p-utils) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-utils/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-utils) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
+| [`libp2p-nat-mgnr`](//github.com/libp2p/js-libp2p-nat-mgnr) | [![npm](https://img.shields.io/npm/v/libp2p-nat-mgnr.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-nat-mgnr/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-nat-mgnr.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-nat-mgnr) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-nat-mgnr.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-nat-mgnr) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-nat-mgnr/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-nat-mgnr) | N/A |
+| [`libp2p-utils`](//github.com/libp2p/js-libp2p-utils) | [![npm](https://img.shields.io/npm/v/libp2p-utils.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-utils/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-utils.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-utils) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-utils.svg?branch=master)](https://travis-ci.com/libp2p/js-libp2p-utils) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-utils/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-utils) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |

 ## Contribute

--- a/doc/API.md
+++ b/doc/API.md
@ -51,7 +51,7 @@ Creates an instance of Libp2p.
 | [options.datastore] | `Object` | must implement [ipfs/interface-datastore](https://github.com/ipfs/interface-datastore) (in memory datastore will be used if not provided) |
 | [options.dialer] | `Object` | libp2p Dialer configuration
 | [options.metrics] | `Object` | libp2p Metrics configuration
-| [options.peerInfo] | [`PeerInfo`][peer-info] | peerInfo instance (it will be created if not provided) |
+| [options.peerInfo] | [PeerInfo](https://github.com/libp2p/js-peer-info) | peerInfo instance (it will be created if not provided) |

 For Libp2p configurations and modules details read the [Configuration Document](./CONFIGURATION.md).

@ -73,7 +73,7 @@ const options = {}
 const libp2p = await Libp2p.create(options)
 ```

-Note: The [`PeerInfo`][peer-info] option is not required and will be generated if it is not provided.
+Note: The `PeerInfo` option is not required and will be generated if it is not provided.

 <details><summary>Alternative</summary>
 As an alternative, it is possible to create a Libp2p instance with the constructor:
@ -92,7 +92,7 @@ const libp2p = new Libp2p(options)

 Required keys in the `options` object:

- `peerInfo`: instance of [`PeerInfo`][peer-info] that contains the [`PeerId`][peer-id], Keys and [multiaddrs][multiaddr] of the libp2p Node (optional when using `.create`).
+- `peerInfo`: instance of [PeerInfo][] that contains the [PeerId][], Keys and [multiaddrs][multiaddr] of the libp2p Node (optional when using `.create`).
 - `modules.transport`: An array that must include at least 1 compliant transport. See [modules that implement the transport interface](https://github.com/libp2p/js-interfaces/tree/master/src/transport#modules-that-implement-the-interface).

 </details>
@ -174,13 +174,15 @@ for (const [peerId, connections] of libp2p.connections) {

 ### dial

+Dials to another peer in the network and establishes the connection.
+
 `dial(peer, options)`

 #### Parameters

 | Name | Type | Description |
 |------|------|-------------|
-| peer | [`PeerInfo`][peer-info]\|[`PeerId`][peer-id]\|[`Multiaddr`][multiaddr]\|`string` | The peer to dial. If a [`Multiaddr`][multiaddr] or its string is provided, it **must** include the peer id |
+| peer | [PeerInfo](https://github.com/libp2p/js-peer-info), [PeerId][peer-id], [multiaddr](https://github.com/multiformats/js-multiaddr), `string` | peer to dial |
 | [options] | `Object` | dial options |
 | [options.signal] | [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) | An `AbortSignal` instance obtained from an [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController) that can be used to abort the connection before it completes |

@ -215,7 +217,7 @@ Dials to another peer in the network and selects a protocol to communicate with

 | Name | Type | Description |
 |------|------|-------------|
-| peer | [`PeerInfo`][peer-info]\|[`PeerId`][peer-id]\|[`Multiaddr`][multiaddr]\|`string` | The peer to dial. If a [`Multiaddr`][multiaddr] or its string is provided, it **must** include the peer id |
+| peer | [PeerInfo](https://github.com/libp2p/js-peer-info), [PeerId][peer-id], [multiaddr](https://github.com/multiformats/js-multiaddr), `string` | peer to dial |
 | protocols | `String|Array<String>` |  A list of protocols (or single protocol) to negotiate with. Protocols are attempted in order until a match is made. (e.g '/ipfs/bitswap/1.1.0') |
 | [options] | `Object` | dial options |
 | [options.signal] | [`AbortSignal`](https://developer.mozilla.org/en-US/docs/Web/API/AbortSignal) | An `AbortSignal` instance obtained from an [`AbortController`](https://developer.mozilla.org/en-US/docs/Web/API/AbortController) that can be used to abort the connection before it completes |
@ -248,7 +250,7 @@ Attempts to gracefully close an open connection to the given peer. If the connec

 | Name | Type | Description |
 |------|------|-------------|
-| peer | [`PeerInfo`][peer-info]\|[`PeerId`][peer-id]\|[`Multiaddr`][multiaddr]\|`string` | peer to hang up |
+| peer | [PeerInfo](https://github.com/libp2p/js-peer-info), [PeerId][peer-id], [multiaddr](https://github.com/multiformats/js-multiaddr), `string` | peer to hang up |

 #### Returns

@ -319,7 +321,7 @@ Pings a given peer and get the operation's latency.

 | Name | Type | Description |
 |------|------|-------------|
-| peer | [`PeerInfo`][peer-info]\|[`PeerId`][peer-id]\|[`Multiaddr`][multiaddr]\|`string` | peer to ping |
+| peer | `PeerInfo|PeerId|Multiaddr|string` | peer to ping |

 #### Returns

@ -372,7 +374,7 @@ Once a content router succeeds, the iteration will stop. If the DHT is enabled,

 | Name | Type | Description |
 |------|------|-------------|
-| cid | [`CID`][cid] | cid to find |
+| cid | [`CID`](https://github.com/multiformats/js-cid) | cid to find |
 | options | `Object` | operation options |
 | options.timeout | `number` | maximum time the query should run |
 | options.maxNumProviders | `number` | maximum number of providers to find |
@ -381,7 +383,7 @@ Once a content router succeeds, the iteration will stop. If the DHT is enabled,

 | Type | Description |
 |------|-------------|
-| `AsyncIterator<PeerInfo>` |  Async iterator for [`PeerInfo`][peer-info] |
+| `AsyncIterator<PeerInfo>` |  Async iterator for [`PeerInfo`](https://github.com/libp2p/js-peer-info) |

 #### Example

@ -402,7 +404,7 @@ Iterates over all content routers in parallel, in order to notify it is a provid

 | Name | Type | Description |
 |------|------|-------------|
-| cid | [`CID`][cid] | cid to provide |
+| cid | [`CID`](https://github.com/multiformats/js-cid) | cid to provide |

 #### Returns

@ -647,7 +649,7 @@ Enables users to change the value of certain peers in a range of 0 to 1. Peers w

 | Name | Type | Description |
 |------|------|-------------|
-| peerId | [`PeerId`][peer-id] | The peer to set the value for |
+| peerId | `PeerId` | The peer to set the value for |
 | value | `number` | The value of the peer from 0 to 1 |

 #### Returns
@ -675,7 +677,7 @@ const peerIdStrings = libp2p.metrics.peers

 ### metrics.peers

-An array of [`PeerId`][peer-id] strings of each peer currently being tracked.
+An array of `PeerId` strings of each peer currently being tracked.

 #### Example

@ -695,7 +697,7 @@ const protocols = libp2p.metrics.protocols

 ### metrics.forPeer

-Returns the [`Stats`](#stats) object for a given [`PeerId`][peer-id] if it is being tracked.
+Returns the [`Stats`](#stats) object for a given `PeerId` if it is being tracked.

 `libp2p.metrics.forPeer(peerId)`

@ -703,7 +705,7 @@ Returns the [`Stats`](#stats) object for a given [`PeerId`][peer-id] if it is be

 | Name | Type | Description |
 |------|------|-------------|
-| peerId | [`PeerId`][peer-id] | The peer to get stats for |
+| peerId | `PeerId` | The peer to get stats for |

 #### Returns

@ -760,7 +762,7 @@ Once you have a libp2p instance, you can listen to several events it emits, so t
 If `autoDial` option is `true`, applications should **not** attempt to connect to the peer
 unless they are performing a specific action. See [peer discovery and auto dial](./PEER_DISCOVERY.md) for more information.

- `peer`: instance of [`PeerInfo`][peer-info]
+- `peer`: instance of [PeerInfo][https://github.com/libp2p/js-peer-info]

 #### A new connection to a peer has been opened

@ -768,7 +770,7 @@ This event will be triggered anytime a new Connection is established to another

 `libp2p.on('peer:connect', (peer) => {})`

- `peer`: instance of [`PeerInfo`][peer-info]
+- `peer`: instance of [PeerInfo][https://github.com/libp2p/js-peer-info]

 #### An existing connection to a peer has been closed

@ -776,7 +778,7 @@ This event will be triggered anytime we are disconnected from another peer, rega

 `libp2p.on('peer:disconnect', (peer) => {})`

- `peer`: instance of [`PeerInfo`][peer-info]
+- `peer`: instance of [PeerInfo][https://github.com/libp2p/js-peer-info]

 ## Types

@ -798,8 +800,5 @@ This event will be triggered anytime we are disconnected from another peer, rega
    - `['300000']<MovingAverage>`: The [MovingAverage](https://www.npmjs.com/package/moving-averages) at a 5 minute interval.
    - `['900000']<MovingAverage>`: The [MovingAverage](https://www.npmjs.com/package/moving-averages) at a 15 minute interval.

-[cid]: https://github.com/multiformats/js-cid
 [connection]: https://github.com/libp2p/js-interfaces/tree/master/src/connection
-[multiaddr]: https://github.com/multiformats/js-multiaddr
 [peer-id]: https://github.com/libp2p/js-peer-id
-[peer-info]: https://github.com/libp2p/js-peer-info
--- a/doc/CONFIGURATION.md
+++ b/doc/CONFIGURATION.md
@ -113,7 +113,6 @@ Some available peer discovery modules are:
 - [js-libp2p-bootstrap](https://github.com/libp2p/js-libp2p-bootstrap)
 - [js-libp2p-kad-dht](https://github.com/libp2p/js-libp2p-kad-dht)
 - [js-libp2p-webrtc-star](https://github.com/libp2p/js-libp2p-webrtc-star)
- [discv5](https://github.com/chainsafe/discv5)

 **Note**: `peer-discovery` services within transports (such as `js-libp2p-webrtc-star`) are automatically gathered from the `transport`, via it's `discovery` property. As such, they do not need to be added in the discovery modules. However, these transports can also be configured and disabled as the other ones.

--- a/doc/migrations/v0.26-v0.27.md
+++ b/doc/migrations/v0.26-v0.27.md
@ -1,178 +0,0 @@
-# Migrating to the new API
-
-A migration guide for refactoring your application code from libp2p v0.26.x to v0.27.0.
-
-## Table of Contents
-
- [Migrating from callbacks](#migrating-from-callbacks)
- [Pull Streams to Streaming Iterables](#pull-streams-to-streaming-iterables)
- [Sample API Migrations](#sample-api-migrations)
-  - [Registering Protocol Handlers](#registering-protocol-handlers)
-  - [Dialing and Sending Data](#dialing-and-sending-data)
-  - [Checking if a peer is connected](#checking-if-a-peer-is-connected)
-  - [Pinging another peer](#pinging-another-peer)
-  - [Pubsub](#pubsub)
-    - [Getting subscribers](#getting-subscribers)
-    - [Getting subscribed topics](#getting-subscribed-topics)
-
-## Migrating from callbacks
-
-Callbacks are no longer supported in the libp2p API, as the API has now fully moved to async / await. You can see a full list of the available methods in the [API readme][api]
-
-**Before**
-```js
-libp2p.start((err) => {
-  if (err) throw err
-  console.log('libp2p started')
-})
-```
-
-**After**
-```js
-await libp2p.start()
-console.log('libp2p started')
-```
-
-## Pull Streams to Streaming Iterables
-
-The libp2p API no longer supports Pull Streams and has migrated to [Streaming Iterables][streaming_iterable]. If you would like to continue using Pull Streams in your application code, or need additional time to migrate your code base, you can leverage the conversion modules [async-iterator-to-pull-stream](https://github.com/alanshaw/async-iterator-to-pull-stream) and [pull-stream-to-async-iterator](https://github.com/alanshaw/pull-stream-to-async-iterator).
-
-For a growing list of async iterator modules, you should follow the [it-awesome repo][it_awesome].
-
-## Sample API Migrations
-
-### Registering Protocol Handlers
-
-Protocol registration is very similar to how it previously was, however, the handler now takes a single parameter containing the incoming stream and its protocol. Additionally, you can now pass an array of protocols to `.handle`, but a single string is still supported.
-
-**Before**
-```js
-const pull = require('pull-stream')
-libp2p.handle('/echo/1.0.0', (protocol, conn) => pull(conn, conn))
-```
-
-**After**
-```js
-const pipe = require('it-pipe')
-libp2p.handle(['/echo/1.0.0'], ({ protocol, stream }) => pipe(stream, stream))
-```
-
-### Dialing and Sending Data
-
-`dialProtocol` no longer takes a callback, and will now return a [Streaming Iterable][streaming_iterable] and the protocol that was successfully negotiated. The new stream can be used with async iterator modules, see [it-awesome][it_awesome], instead of pull streams.
-
-**Before**
-```js
-const pull = require('pull-stream')
-libp2p.dialProtocol(peerInfo, '/echo/1.0.0', (err, conn) => {
-  if (err) { throw err }
-  pull(
-    pull.values(['hey']),
-    conn,
-    pull.drain((data) => {
-      console.log('received echo:', data.toString())
-    }, (err) => {
-      if (err) { throw err }
-    })
-  )
-})
-```
-
-**After**
-```js
-const pipe = require('it-pipe')
-const { protocol, stream } = await libp2p.dialProtocol(peerInfo, '/echo/1.0.0')
-await pipe(
-  ['hey'],
-  stream,
-  async function (source) {
-    for await (const data of source) {
-      console.log('received echo:', data.toString())
-    }
-  }
-)
-```
-
-### Checking if a peer is connected
-
-`peerInfo.isConnected` has been deprecated. libp2p now tracks all connections centrally and will no longer update the state of `peerInfo.isConnected`. Consumers should switch to using `libp2p.registrar.getConnection(peerInfo)`, which will return an open connection to that peer if one exists.
-
-**Before**
-```js
-if (peerInfo.isConnected()) {
-  // ...do something if connected
-}
-```
-
-**After**
-```js
-const connection = libp2p.registrar.getConnection(peerInfo)
-if (connection) {
-  // ...do something if connected
-}
-```
-
-### Pinging another peer
-
-`libp2p.ping` will no longer callback with a `Ping` event emitter. The internal logic has been simplified to give more flexibility to the API. `libp2p.ping` will now execute a single ping and return the latency.
-
-**Before**
-```js
-libp2p.ping(peerInfo, (err, ping) => {
-  if (err) throw err
-  ping.once('ping', (latency) => {
-    console.log('Latency is %s ms', latency)
-    ping.stop()
-  })
-
-  ping.start()
-})
-```
-
-**After**
-```js
-const latency = await libp2p.ping(peerInfo)
-console.log('Latency is %s ms', latency)
-```
-
-### Pubsub
-
-#### Getting subscribers
-
-`libp2p.pubsub.peers()` is now `libp2p.pubsub.getSubscribers()` and is no longer an asynchronous action.
-
-**Before**
-```js
-libp2p.pubsub.peers(topic, (err, subscribers) => {
-  if (err) throw err
-  console.log('Subscribers:', subscribers)
-})
-```
-
-**After**
-```js
-const subscribers = libp2p.pubsub.getSubscribers(topic)
-console.log('Subscribers:', subscribers)
-```
-
-#### Getting subscribed topics
-
-`libp2p.pubsub.ls()` is now `libp2p.pubsub.getTopics()` and is no longer an asynchronous action.
-
-**Before**
-```js
-libp2p.pubsub.ls((err, topics) => {
-  if (err) throw err
-  console.log('Topics:', topics)
-})
-```
-
-**After**
-```js
-const topics = libp2p.pubsub.getTopics()
-console.log('Topics:', topics)
-```
-
-[api]: ../API.md
-[it_awesome]: https://github.com/alanshaw/it-awesome
-[streaming_iterable]: ../STREAMING_ITERABLES.md
--- a/examples/delegated-routing/README.md
+++ b/examples/delegated-routing/README.md
@ -1,7 +1,3 @@
-❗❗Outdated: This example is still not refactored with the `0.27.*` release. 
-WIP on [libp2p/js-libp2p#507](https://github.com/libp2p/js-libp2p/pull/507)
-======
-
 # Delegated Routing with Libp2p and IPFS

 This example shows how to use delegated peer and content routing. The [Peer and Content Routing Example](../peer-and-content-routing) focuses
--- a/examples/pnet/index.js
+++ b/examples/pnet/index.js
@ -1,7 +1,6 @@
 /* eslint no-console: ["off"] */
 'use strict'

-const { Buffer } = require('buffer')
 const { generate } = require('libp2p/src/pnet')
 const privateLibp2pNode = require('./libp2p-node')

@ -18,7 +17,7 @@ generate(otherSwarmKey)
 ;(async () => {
  const node1 = await privateLibp2pNode(swarmKey)

-  // TASK: switch the commented out line below so we're using a different key, to see the nodes fail to connect
+  // TASK: switch the commented out line below so we're using a different key, to see the nodes fail to connect	
  const node2 = await privateLibp2pNode(swarmKey)
  // const node2 = await privateLibp2pNode(otherSwarmKey)

@ -48,4 +47,4 @@ generate(otherSwarmKey)
    ['This message is sent on a private network'],
    stream
  )
-})()
+})();
--- a/examples/pubsub/1.js
+++ b/examples/pubsub/1.js
@ -1,7 +1,6 @@
 /* eslint-disable no-console */
 'use strict'

-const { Buffer } = require('buffer')
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
@ -32,7 +31,7 @@ const createNode = async () => {

  const [node1, node2] = await Promise.all([
    createNode(),
-    createNode()
+    createNode(),
  ])

  await node1.dial(node2.peerInfo)
@ -49,4 +48,4 @@ const createNode = async () => {
  setInterval(() => {
    node2.pubsub.publish(topic, Buffer.from('Bird bird bird, bird is the word!'))
  }, 1000)
-})()
+})();
--- a/package-list.json
+++ b/package-list.json
@ -17,22 +17,26 @@

    "transports",
    ["libp2p/js-libp2p-tcp", "libp2p-tcp"],
+    ["libp2p/js-libp2p-utp", "libp2p-utp"],
    ["libp2p/js-libp2p-webrtc-direct", "libp2p-webrtc-direct"],
    ["libp2p/js-libp2p-webrtc-star", "libp2p-webrtc-star"],
    ["libp2p/js-libp2p-websockets", "libp2p-websockets"],
+    ["libp2p/js-libp2p-websocket-star", "libp2p-websocket-star"],

    "secure channels",
    ["libp2p/js-libp2p-secio", "libp2p-secio"],

    "stream multiplexers",
    ["libp2p/js-libp2p-mplex", "libp2p-mplex"],
+    ["libp2p/js-libp2p-spdy", "libp2p-spdy"],

    "peer discovery",
    ["libp2p/js-libp2p-bootstrap", "libp2p-bootstrap"],
    ["libp2p/js-libp2p-kad-dht", "libp2p-kad-dht"],
    ["libp2p/js-libp2p-mdns", "libp2p-mdns"],
+    ["libp2p/js-libp2p-rendezvous", "libp2p-rendezvous"],
    ["libp2p/js-libp2p-webrtc-star", "libp2p-webrtc-star"],
-    ["ChainSafe/discv5", "discv5"],
+    ["libp2p/js-libp2p-websocket-star", "libp2p-websocket-star"],

    "content routing",
    ["libp2p/js-libp2p-delegated-content-routing", "libp2p-delegated-content-routing"],
--- a/package.json
+++ b/package.json
@ -1,6 +1,6 @@
 {
  "name": "libp2p",
-  "version": "0.27.7",
+  "version": "0.27.0-rc.0",
  "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
  "leadMaintainer": "Jacob Heun <jacobheun@gmail.com>",
  "main": "src/index.js",
@ -47,108 +47,119 @@
    "bignumber.js": "^9.0.0",
    "class-is": "^1.1.0",
    "debug": "^4.1.1",
-    "err-code": "^2.0.0",
-    "events": "^3.1.0",
+    "err-code": "^1.1.2",
    "hashlru": "^2.3.0",
-    "ipfs-utils": "^2.2.0",
    "it-all": "^1.0.1",
-    "it-buffer": "^0.1.2",
+    "it-buffer": "^0.1.1",
    "it-handshake": "^1.0.1",
-    "it-length-prefixed": "^3.0.1",
+    "it-length-prefixed": "^3.0.0",
    "it-pipe": "^1.1.0",
    "it-protocol-buffers": "^0.2.0",
-    "libp2p-crypto": "^0.17.6",
-    "libp2p-interfaces": "^0.2.8",
-    "libp2p-utils": "^0.1.2",
+    "latency-monitor": "~0.2.1",
+    "libp2p-crypto": "^0.17.1",
+    "libp2p-interfaces": "^0.2.3",
    "mafmt": "^7.0.0",
    "merge-options": "^2.0.0",
    "moving-average": "^1.0.0",
-    "multiaddr": "^7.4.3",
+    "multiaddr": "^7.2.1",
    "multistream-select": "^0.15.0",
    "mutable-proxy": "^1.0.0",
-    "p-any": "^3.0.0",
+    "p-any": "^2.1.0",
    "p-fifo": "^1.0.0",
-    "p-settle": "^4.0.1",
-    "peer-id": "^0.13.11",
+    "p-settle": "^3.1.0",
+    "peer-id": "^0.13.4",
    "peer-info": "^0.17.0",
    "protons": "^1.0.1",
    "retimer": "^2.0.0",
-    "streaming-iterables": "^4.1.0",
    "timeout-abort-controller": "^1.0.0",
    "xsalsa20": "^1.0.2"
  },
  "devDependencies": {
    "@nodeutils/defaults-deep": "^1.1.0",
-    "abortable-iterator": "^3.0.0",
-    "aegir": "^21.9.0",
+    "abortable-iterator": "^2.1.0",
+    "aegir": "^20.5.1",
    "chai": "^4.2.0",
    "chai-as-promised": "^7.1.1",
-    "cids": "^0.8.0",
+    "cids": "^0.7.1",
    "delay": "^4.3.0",
    "dirty-chai": "^2.0.1",
-    "interop-libp2p": "~0.0.1",
    "it-concat": "^1.0.0",
    "it-pair": "^1.0.0",
    "it-pushable": "^1.4.0",
    "libp2p-bootstrap": "^0.10.3",
-    "libp2p-delegated-content-routing": "^0.4.5",
-    "libp2p-delegated-peer-routing": "^0.4.3",
+    "libp2p-delegated-content-routing": "^0.4.1",
+    "libp2p-delegated-peer-routing": "^0.4.0",
    "libp2p-floodsub": "^0.20.0",
-    "libp2p-gossipsub": "^0.2.6",
-    "libp2p-kad-dht": "^0.18.6",
+    "libp2p-gossipsub": "^0.2.0",
+    "libp2p-kad-dht": "^0.18.2",
    "libp2p-mdns": "^0.13.0",
-    "libp2p-mplex": "^0.9.5",
-    "libp2p-secio": "^0.12.4",
+    "libp2p-mplex": "^0.9.1",
+    "libp2p-secio": "^0.12.1",
    "libp2p-tcp": "^0.14.1",
-    "libp2p-webrtc-star": "^0.17.9",
+    "libp2p-webrtc-star": "^0.17.0",
    "libp2p-websockets": "^0.13.1",
-    "nock": "^12.0.3",
+    "nock": "^10.0.6",
    "p-defer": "^3.0.0",
    "p-times": "^2.1.0",
    "p-wait-for": "^3.1.0",
-    "sinon": "^9.0.2",
+    "sinon": "^8.1.0",
+    "streaming-iterables": "^4.1.0",
    "wrtc": "^0.4.1"
  },
  "contributors": [
-    "David Dias <daviddias.p@gmail.com>",
-    "Jacob Heun <jacobheun@gmail.com>",
-    "Vasco Santos <vasco.santos@moxy.studio>",
+    "Aditya Bose <13054902+adbose@users.noreply.github.com>",
+    "Alan Shaw <alan.shaw@protocol.ai>",
    "Alan Shaw <alan@tableflip.io>",
-    "Pedro Teixeira <i@pgte.me>",
-    "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
-    "Maciej Krüger <mkg20001@gmail.com>",
    "Alex Potsides <alex@achingbrain.net>",
-    "Hugo Dias <mail@hugodias.me>",
-    "dirkmc <dirkmdev@gmail.com>",
-    "Volker Mische <volker.mische@gmail.com>",
-    "Richard Littauer <richard.littauer@gmail.com>",
-    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
    "Andrew Nesbitt <andrewnez@gmail.com>",
-    "Cayman <caymannava@gmail.com>",
+    "Chris Bratlien <chrisbratlien@gmail.com>",
+    "Chris Dostert <chrisdostert@users.noreply.github.com>",
+    "Daijiro Wachi <daijiro.wachi@gmail.com>",
+    "David Dias <daviddias.p@gmail.com>",
+    "Didrik Nordström <didrik.nordstrom@gmail.com>",
+    "Diogo Silva <fsdiogo@gmail.com>",
+    "Dmitriy Ryajov <dryajov@gmail.com>",
    "Elven <mon.samuel@qq.com>",
-    "Giovanni T. Parra <fiatjaf@gmail.com>",
-    "Ryan Bell <ryan@piing.net>",
-    "Thomas Eizinger <thomas@eizinger.io>",
-    "Kevin Kwok <antimatter15@gmail.com>",
-    "Henrique Dias <hacdias@gmail.com>",
-    "Nuno Nogueira <nunofmn@gmail.com>",
-    "RasmusErik Voel Jensen <github@solsort.com>",
+    "Fei Liu <liu.feiwood@gmail.com>",
    "Florian-Merle <florian.david.merle@gmail.com>",
+    "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
+    "Giovanni T. Parra <fiatjaf@gmail.com>",
+    "Guy Sviry <32539816+guysv@users.noreply.github.com>",
+    "Henrique Dias <hacdias@gmail.com>",
+    "Hugo Dias <mail@hugodias.me>",
+    "Hugo Dias <hugomrdias@gmail.com>",
+    "Irakli Gozalishvili <rfobic@gmail.com>",
+    "Jacob Heun <jacobheun@gmail.com>",
+    "Joel Gustafson <joelg@mit.edu>",
+    "John Rees <johnrees@users.noreply.github.com>",
+    "João Santos <joaosantos15@users.noreply.github.com>",
+    "Kevin Kwok <antimatter15@gmail.com>",
+    "Lars Gierth <lgierth@users.noreply.github.com>",
+    "Maciej Krüger <mkg20001@gmail.com>",
+    "Marcin Tojek <mtojek@users.noreply.github.com>",
+    "Nuno Nogueira <nunofmn@gmail.com>",
+    "Pedro Teixeira <pedro@protocol.ai>",
+    "Pedro Teixeira <i@pgte.me>",
+    "RasmusErik Voel Jensen <github@solsort.com>",
+    "Richard Littauer <richard.littauer@gmail.com>",
+    "Ryan Bell <ryan@piing.net>",
    "Soeren <nikorpoulsen@gmail.com>",
    "Sönke Hahn <soenkehahn@gmail.com>",
+    "Thomas Eizinger <thomas@eizinger.io>",
    "Tiago Alves <alvesjtiago@gmail.com>",
-    "Fei Liu <liu.feiwood@gmail.com>",
-    "Dmitriy Ryajov <dryajov@gmail.com>",
-    "Diogo Silva <fsdiogo@gmail.com>",
+    "Vasco Santos <vasco.santos@moxy.studio>",
+    "Vasco Santos <vasco.santos@ua.pt>",
+    "Volker Mische <volker.mische@gmail.com>",
    "Yusef Napora <yusef@napora.org>",
    "Zane Starr <zcstarr@gmail.com>",
-    "Didrik Nordström <didrik.nordstrom@gmail.com>",
-    "Daijiro Wachi <daijiro.wachi@gmail.com>",
+    "a1300 <a1300@users.noreply.github.com>",
+    "dirkmc <dirkmdev@gmail.com>",
    "ebinks <elizabethjbinks@gmail.com>",
-    "Chris Bratlien <chrisbratlien@gmail.com>",
+    "greenkeeperio-bot <support@greenkeeper.io>",
    "isan_rivkin <isanrivkin@gmail.com>",
-    "robertkiel <robert.kiel@validitylabs.org>",
-    "Irakli Gozalishvili <rfobic@gmail.com>",
-    "Joel Gustafson <joelg@mit.edu>"
+    "mayerwin <mayerwin@users.noreply.github.com>",
+    "phillmac <phillmac@users.noreply.github.com>",
+    "swedneck <40505480+swedneck@users.noreply.github.com>",
+    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>"
  ]
 }
--- a/pdd/README.md
+++ b/pdd/README.md
@ -0,0 +1,3 @@
+# PDD Test Stories Implementation
+
+> Implementation of the Compliance tests from https://github.com/libp2p/interop
--- a/pdd/package.json
+++ b/pdd/package.json
@ -0,0 +1,20 @@
+{
+  "name": "pdd-impl",
+  "version": "0.0.0",
+  "description": "PDD Test Stories implementation",
+  "repository": {
+    "type": "git",
+    "url": "  "
+  },
+  "keywords": [
+    "PDD",
+    "libp2p"
+  ],
+  "author": "David Dias <daviddias@ipfs.io>",
+  "license": "MIT",
+  "dependencies": {
+    "libp2p": "file:./..",
+    "libp2p-interop": "github:libp2p/interop#master",
+    "tape": "^4.8.0"
+  }
+}
--- a/pdd/pdd-the-ipfs-bundle--story-1--peer-a.js
+++ b/pdd/pdd-the-ipfs-bundle--story-1--peer-a.js
@ -0,0 +1,104 @@
+'use strict'
+
+const test = require('tape')
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const WebSockets = require('libp2p-websockets')
+const SECIO = require('libp2p-secio')
+const Multiplex = require('libp2p-multiplex')
+const Railing = require('libp2p-railing')
+const MulticastDNS = require('libp2p-mdns')
+const KadDHT = require('libp2p-kad-dht')
+const PeerInfo = require('peer-info')
+const pull = require('pull-stream')
+const waterfall = require('async/waterfall')
+const series = require('async/series')
+const PeerA = require('libp2p-interop/peer-a.json')
+const PeerB = require('libp2p-interop/peer-b.json')
+
+class IPFSBundle extends libp2p {
+  constructor (peerInfo, options) {
+    options = Object.assign({ bootstrap: [] }, options)
+
+    const modules = {
+      transport: [
+        new TCP(),
+        new WebSockets()
+      ],
+      connection: {
+        muxer: [
+          Multiplex
+        ],
+        crypto: [
+          SECIO
+        ]
+      },
+      discovery: [
+        new MulticastDNS(peerInfo, 'ipfs.local'),
+        new Railing(options.bootstrap)
+      ],
+      DHT: KadDHT
+    }
+
+    super(modules, peerInfo, undefined, options)
+  }
+}
+
+test('story 1 - peerA', (t) => {
+  t.plan(10)
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(PeerA, cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/10000')
+      node = new IPFSBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => {
+    t.ifErr(err, 'created Node successfully')
+    t.ok(node.isStarted(), 'PeerA is Running')
+
+    const peerBAddr = `/ip4/127.0.0.1/tcp/10001/p2p/${PeerB.id}`
+
+    node.handle('/time/1.0.0', (protocol, conn) => {
+      pull(
+        pull.values([Date.now().toString()]),
+        conn,
+        pull.onEnd((err) => {
+          t.ifErr(err)
+          t.pass('Sent time successfully')
+        })
+      )
+    })
+
+    series([
+      (cb) => setTimeout(cb, 5 * 1000), // time to run both scripts
+      (cb) => node.ping(peerBAddr, (err, p) => {
+        t.ifErr(err, 'initiated Ping to PeerB')
+        p.once('error', (err) => t.ifErr(err, 'Ping should not fail'))
+        p.once('ping', (time) => {
+          t.pass('ping PeerB successfully')
+          p.stop()
+          cb()
+        })
+      }),
+      (cb) => node.dial(peerBAddr, '/echo/1.0.0', (err, conn) => {
+        t.ifErr(err, 'dial successful')
+
+        const data = Buffer.from('Hey')
+
+        pull(
+          pull.values([data]),
+          conn,
+          pull.collect((err, values) => {
+            t.ifErr(err, 'Received echo back')
+            t.deepEqual(values[0], data)
+            cb()
+          })
+        )
+      }),
+      (cb) => setTimeout(cb, 2 * 1000) // time to both finish
+    ], () => node.stop((err) => t.ifErr(err, 'PeerA has stopped')))
+  })
+})
--- a/pdd/pdd-the-ipfs-bundle--story-1--peer-b.js
+++ b/pdd/pdd-the-ipfs-bundle--story-1--peer-b.js
@ -0,0 +1,98 @@
+'use strict'
+
+const test = require('tape')
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const WebSockets = require('libp2p-websockets')
+const SECIO = require('libp2p-secio')
+const Multiplex = require('libp2p-multiplex')
+const Railing = require('libp2p-railing')
+const MulticastDNS = require('libp2p-mdns')
+const KadDHT = require('libp2p-kad-dht')
+const PeerInfo = require('peer-info')
+const pull = require('pull-stream')
+const waterfall = require('async/waterfall')
+const series = require('async/series')
+const PeerA = require('libp2p-interop/peer-a.json')
+const PeerB = require('libp2p-interop/peer-b.json')
+
+class IPFSBundle extends libp2p {
+  constructor (peerInfo, options) {
+    options = Object.assign({ bootstrap: [] }, options)
+
+    const modules = {
+      transport: [
+        new TCP(),
+        new WebSockets()
+      ],
+      connection: {
+        muxer: [
+          Multiplex
+        ],
+        crypto: [
+          SECIO
+        ]
+      },
+      discovery: [
+        new MulticastDNS(peerInfo, 'ipfs.local'),
+        new Railing(options.bootstrap)
+      ],
+      DHT: KadDHT
+    }
+
+    super(modules, peerInfo, undefined, options)
+  }
+}
+
+test('story 1 - peerA', (t) => {
+  t.plan(8)
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(PeerB, cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/10001')
+      node = new IPFSBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => {
+    t.ifErr(err, 'created Node successfully')
+    t.ok(node.isStarted(), 'PeerB is Running')
+
+    const peerAAddr = `/ip4/127.0.0.1/tcp/10000/p2p/${PeerA.id}`
+
+    node.handle('/echo/1.0.0', (protocol, conn) => {
+      pull(
+        conn,
+        conn,
+        pull.onEnd((err) => t.ifErr(err, 'echo was successful'))
+      )
+    })
+
+    series([
+      (cb) => setTimeout(cb, 5 * 1000), // time to run both scripts
+      (cb) => node.ping(peerAAddr, (err, p) => {
+        t.ifErr(err, 'initiated Ping to PeerA')
+        p.once('error', (err) => t.ifErr(err, 'Ping should not fail'))
+        p.once('ping', (time) => {
+          t.pass('ping PeerA successfully')
+          p.stop()
+          cb()
+        })
+      }),
+      (cb) => node.dial(peerAAddr, '/time/1.0.0', (err, conn) => {
+        t.ifErr(err, 'dial successful')
+
+        pull(
+          pull.values([]),
+          conn,
+          pull.collect((err, values) => {
+            t.ifErr(err, 'Received time')
+            cb()
+          })
+        )
+      }),
+      (cb) => setTimeout(cb, 2 * 1000) // time to both finish
+    ], () => node.stop((err) => t.ifErr(err, 'PeerB has stopped')))
+  })
+})
--- a/pdd/pdd-the-ipfs-bundle--story-2--peer-a.js
+++ b/pdd/pdd-the-ipfs-bundle--story-2--peer-a.js
--- a/pdd/pdd-the-ipfs-bundle--story-2--peer-b.js
+++ b/pdd/pdd-the-ipfs-bundle--story-2--peer-b.js
--- a/pdd/pdd-the-ipfs-bundle--story-3--peer-a.js
+++ b/pdd/pdd-the-ipfs-bundle--story-3--peer-a.js
--- a/pdd/pdd-the-ipfs-bundle--story-3--peer-b.js
+++ b/pdd/pdd-the-ipfs-bundle--story-3--peer-b.js
--- a/pdd/pdd-the-ipfs-bundle--story-3--peer-c.js
+++ b/pdd/pdd-the-ipfs-bundle--story-3--peer-c.js
--- a/pdd/pdd-the-ipfs-bundle--story-4--peer-a.js
+++ b/pdd/pdd-the-ipfs-bundle--story-4--peer-a.js
--- a/pdd/pdd-the-ipfs-bundle--story-4--peer-b.js
+++ b/pdd/pdd-the-ipfs-bundle--story-4--peer-b.js
--- a/pdd/pdd-the-ipfs-bundle--story-4--peer-c.js
+++ b/pdd/pdd-the-ipfs-bundle--story-4--peer-c.js
--- a/pdd/pdd-the-ipfs-bundle--story-4--peer-d.js
+++ b/pdd/pdd-the-ipfs-bundle--story-4--peer-d.js
--- a/pdd/pdd-the-ipfs-bundle--story-4--peer-e.js
+++ b/pdd/pdd-the-ipfs-bundle--story-4--peer-e.js
--- a/pdd/pdd-the-ipfs-bundle--story-5--peer-a.js
+++ b/pdd/pdd-the-ipfs-bundle--story-5--peer-a.js
--- a/pdd/pdd-the-ipfs-bundle--story-5--peer-b.js
+++ b/pdd/pdd-the-ipfs-bundle--story-5--peer-b.js
--- a/pdd/pdd-the-ipfs-bundle--story-5--peer-c.js
+++ b/pdd/pdd-the-ipfs-bundle--story-5--peer-c.js
--- a/pdd/pdd-the-ipfs-bundle--story-5--peer-d.js
+++ b/pdd/pdd-the-ipfs-bundle--story-5--peer-d.js
--- a/pdd/pdd-the-ipfs-bundle--story-5--peer-e.js
+++ b/pdd/pdd-the-ipfs-bundle--story-5--peer-e.js
--- a/pdd/pdd-transport--story-1--peer-a.js
+++ b/pdd/pdd-transport--story-1--peer-a.js
@ -0,0 +1,54 @@
+'use strict'
+
+const test = require('tape')
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const pull = require('pull-stream')
+const PeerA = require('libp2p-interop/peer-a.json')
+const PeerB = require('libp2p-interop/peer-b.json')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+test('story 1 - peerA', (t) => {
+  t.plan(6)
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(PeerA, cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/10000')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => {
+    t.ifErr(err, 'created Node')
+    t.ok(node.isStarted(), 'PeerA is running')
+
+    const PeerBAddr = `/ip4/127.0.0.1/tcp/10001/p2p/${PeerB.id}`
+
+    node.dial(PeerBAddr, '/echo/1.0.0', (err, conn) => {
+      t.ifErr(err, 'dial successful')
+
+      const data = Buffer.from('Heey')
+
+      pull(
+        pull.values([data]),
+        conn,
+        pull.collect((err, values) => {
+          t.ifErr(err, 'Received echo back')
+          t.deepEqual(values[0], data)
+          node.stop((err) => t.ifErr(err, 'PeerA has stopped'))
+        })
+      )
+    })
+  })
+})
--- a/pdd/pdd-transport--story-1--peer-b.js
+++ b/pdd/pdd-transport--story-1--peer-b.js
@ -0,0 +1,49 @@
+'use strict'
+
+const test = require('tape')
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const pull = require('pull-stream')
+const PeerB = require('libp2p-interop/peer-b.json')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+test('story 1 - peerB', (t) => {
+  t.plan(5)
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(PeerB, cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/10001')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => {
+    t.ifErr(err)
+    t.ok(node.isStarted(), 'PeerB is running')
+
+    node.handle('/echo/1.0.0', (protocol, conn) => {
+      pull(
+        conn,
+        conn,
+        pull.onEnd((err) => {
+          t.ifErr(err)
+          t.pass('Received End of Connection')
+          node.stop((err) => {
+            t.ifErr(err, 'PeerB has stopped')
+          })
+        })
+      )
+    })
+  })
+})
--- a/pdd/pdd-transport--story-2--peer-a.js
+++ b/pdd/pdd-transport--story-2--peer-a.js
@ -0,0 +1,54 @@
+'use strict'
+
+const test = require('tape')
+const libp2p = require('libp2p')
+const WebSockets = require('libp2p-websockets')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const pull = require('pull-stream')
+const PeerA = require('libp2p-interop/peer-a.json')
+const PeerB = require('libp2p-interop/peer-b.json')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new WebSockets()]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+test('story 2 - peerA', (t) => {
+  t.plan(6)
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(PeerA, cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/10000/ws')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => {
+    t.ifErr(err, 'created Node')
+    t.ok(node.isStarted(), 'PeerA is running')
+
+    const PeerBAddr = `/ip4/127.0.0.1/tcp/10001/p2p/${PeerB.id}`
+
+    node.dial(PeerBAddr, '/echo/1.0.0', (err, conn) => {
+      t.ifErr(err, 'dial successful')
+
+      const data = Buffer.from('Heey')
+
+      pull(
+        pull.values([data]),
+        conn,
+        pull.collect((err, values) => {
+          t.ifErr(err, 'Received echo back')
+          t.deepEqual(values[0], data)
+          node.stop((err) => t.ifErr(err, 'PeerA has stopped'))
+        })
+      )
+    })
+  })
+})
--- a/pdd/pdd-transport--story-2--peer-b.js
+++ b/pdd/pdd-transport--story-2--peer-b.js
@ -0,0 +1,49 @@
+'use strict'
+
+const test = require('tape')
+const libp2p = require('libp2p')
+const WebSockets = require('libp2p-websockets')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const pull = require('pull-stream')
+const PeerB = require('libp2p-interop/peer-b.json')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new WebSockets()]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+test('story 2 - peerB', (t) => {
+  t.plan(5)
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(PeerB, cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/10001/ws')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => {
+    t.ifErr(err)
+    t.ok(node.isStarted(), 'PeerB is running')
+
+    node.handle('/echo/1.0.0', (protocol, conn) => {
+      pull(
+        conn,
+        pull.through(v => v, err => {
+          t.ifErr(err)
+          t.pass('Received End of Connection')
+          node.stop((err) => {
+            t.ifErr(err, 'PeerB has stopped')
+          })
+        }),
+        conn
+      )
+    })
+  })
+})
--- a/pdd/pdd-transport--story-3--peer-a.js
+++ b/pdd/pdd-transport--story-3--peer-a.js
@ -0,0 +1,42 @@
+'use strict'
+
+const test = require('tape')
+const libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const PeerA = require('libp2p-interop/peer-a.json')
+const PeerB = require('libp2p-interop/peer-b.json')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new TCP()]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+test('story 3 - peerA', (t) => {
+  t.plan(4)
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(PeerA, cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/10000')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => {
+    t.ifErr(err, 'created Node')
+    t.ok(node.isStarted(), 'PeerA is running')
+
+    const PeerBAddr = `/ip4/127.0.0.1/tcp/10001/ws/p2p/${PeerB.id}`
+
+    setTimeout(() => node.dial(PeerBAddr, '/echo/1.0.0', (err, conn) => {
+      t.ok(err, 'dial failed')
+      node.stop((err) => t.ifErr(err, 'PeerA has stopped'))
+    }), 1000)
+  })
+})
--- a/pdd/pdd-transport--story-3--peer-b.js
+++ b/pdd/pdd-transport--story-3--peer-b.js
@ -0,0 +1,42 @@
+'use strict'
+
+const test = require('tape')
+const libp2p = require('libp2p')
+const WebSockets = require('libp2p-websockets')
+const PeerInfo = require('peer-info')
+const waterfall = require('async/waterfall')
+const PeerA = require('libp2p-interop/peer-a.json')
+const PeerB = require('libp2p-interop/peer-b.json')
+
+class MyBundle extends libp2p {
+  constructor (peerInfo) {
+    const modules = {
+      transport: [new WebSockets()]
+    }
+    super(modules, peerInfo)
+  }
+}
+
+test('story 3 - peerB', (t) => {
+  t.plan(4)
+  let node
+
+  waterfall([
+    (cb) => PeerInfo.create(PeerB, cb),
+    (peerInfo, cb) => {
+      peerInfo.multiaddrs.add('/ip4/127.0.0.1/tcp/10000/ws')
+      node = new MyBundle(peerInfo)
+      node.start(cb)
+    }
+  ], (err) => {
+    t.ifErr(err, 'created Node')
+    t.ok(node.isStarted(), 'PeerA is running')
+
+    const PeerAAddr = `/ip4/127.0.0.1/tcp/10000/ws/p2p/${PeerA.id}`
+
+    setTimeout(() => node.dial(PeerAAddr, '/echo/1.0.0', (err, conn) => {
+      t.ok(err, 'dial failed')
+      node.stop((err) => t.ifErr(err, 'PeerA has stopped'))
+    }), 1000)
+  })
+})
--- a/src/circuit/index.js
+++ b/src/circuit/index.js
@ -10,13 +10,13 @@ const { CircuitRelay: CircuitPB } = require('./protocol')
 const debug = require('debug')
 const log = debug('libp2p:circuit')
 log.error = debug('libp2p:circuit:error')
-const toConnection = require('libp2p-utils/src/stream-to-ma-conn')

 const { relay: multicodec } = require('./multicodec')
 const createListener = require('./listener')
 const { handleCanHop, handleHop, hop } = require('./circuit/hop')
 const { handleStop } = require('./circuit/stop')
 const StreamHandler = require('./circuit/stream-handler')
+const toConnection = require('./stream-to-conn')

 class Circuit {
  /**
--- a/src/circuit/listener.js
+++ b/src/circuit/listener.js
@ -22,7 +22,7 @@ module.exports = (circuit) => {
   * @return {void}
   */
  listener.listen = async (addr) => {
-    const addrString = String(addr).split('/p2p-circuit').find(a => a !== '')
+    const [addrString] = String(addr).split('/p2p-circuit').slice(-1)

    const relayConn = await circuit._dialer.connectToPeer(multiaddr(addrString))
    const relayedAddr = relayConn.remoteAddr.encapsulate('/p2p-circuit')
--- a/src/circuit/stream-to-conn.js
+++ b/src/circuit/stream-to-conn.js
@ -0,0 +1,49 @@
+'use strict'
+
+const abortable = require('abortable-iterator')
+const log = require('debug')('libp2p:circuit:stream')
+
+// Convert a duplex iterable into a MultiaddrConnection
+// https://github.com/libp2p/interface-transport#multiaddrconnection
+module.exports = ({ stream, remoteAddr, localAddr }, options = {}) => {
+  const { sink, source } = stream
+  const maConn = {
+    async sink (source) {
+      if (options.signal) {
+        source = abortable(source, options.signal)
+      }
+
+      try {
+        await sink(source)
+      } catch (err) {
+        // If aborted we can safely ignore
+        if (err.type !== 'aborted') {
+          // If the source errored the socket will already have been destroyed by
+          // toIterable.duplex(). If the socket errored it will already be
+          // destroyed. There's nothing to do here except log the error & return.
+          log(err)
+        }
+      }
+      close()
+    },
+
+    source: options.signal ? abortable(source, options.signal) : source,
+    conn: stream,
+    localAddr,
+    remoteAddr,
+    timeline: { open: Date.now() },
+
+    close () {
+      sink([])
+      close()
+    }
+  }
+
+  function close () {
+    if (!maConn.timeline.close) {
+      maConn.timeline.close = Date.now()
+    }
+  }
+
+  return maConn
+}
--- a/src/connection-manager/index.js
+++ b/src/connection-manager/index.js
@ -1,15 +1,11 @@
 'use strict'

-const errcode = require('err-code')
+const assert = require('assert')
 const mergeOptions = require('merge-options')
-const LatencyMonitor = require('./latency-monitor')
+const LatencyMonitor = require('latency-monitor').default
 const debug = require('debug')('libp2p:connection-manager')
 const retimer = require('retimer')

-const {
-  ERR_INVALID_PARAMETERS
-} = require('../errors')
-
 const defaultOptions = {
  maxConnections: Infinity,
  minConnections: 0,
@ -42,9 +38,10 @@ class ConnectionManager {
    this._registrar = libp2p.registrar
    this._peerId = libp2p.peerInfo.id.toB58String()
    this._options = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, options)
-    if (this._options.maxConnections < this._options.minConnections) {
-      throw errcode(new Error('Connection Manager maxConnections must be greater than minConnections'), ERR_INVALID_PARAMETERS)
-    }
+    assert(
+      this._options.maxConnections > this._options.minConnections,
+      'Connection Manager maxConnections must be greater than minConnections'
+    )

    debug('options: %j', this._options)

--- a/src/connection-manager/latency-monitor.js
+++ b/src/connection-manager/latency-monitor.js
@ -1,246 +0,0 @@
-'use strict'
-
-/**
- * This code is based on `latency-monitor` (https://github.com/mlucool/latency-monitor) by `mlucool` (https://github.com/mlucool), available under Apache License 2.0 (https://github.com/mlucool/latency-monitor/blob/master/LICENSE)
- */
-
-/* global window */
-const globalThis = require('ipfs-utils/src/globalthis')
-const EventEmitter = require('events')
-const VisibilityChangeEmitter = require('./visibility-change-emitter')
-const debug = require('debug')('latency-monitor:LatencyMonitor')
-
-/**
- * @typedef {Object} SummaryObject
- * @property {Number} events How many events were called
- * @property {Number} minMS What was the min time for a cb to be called
- * @property {Number} maxMS What was the max time for a cb to be called
- * @property {Number} avgMs What was the average time for a cb to be called
- * @property {Number} lengthMs How long this interval was in ms
- */
-
-/**
- * A class to monitor latency of any async function which works in a browser or node. This works by periodically calling
- * the asyncTestFn and timing how long it takes the callback to be called. It can also periodically emit stats about this.
- * This can be disabled and stats can be pulled via setting dataEmitIntervalMs = 0.
- *
- * The default implementation is an event loop latency monitor. This works by firing periodic events into the event loop
- * and timing how long it takes to get back.
- *
- * @example
- * const monitor = new LatencyMonitor();
- * monitor.on('data', (summary) => console.log('Event Loop Latency: %O', summary));
- *
- * @example
- * const monitor = new LatencyMonitor({latencyCheckIntervalMs: 1000, dataEmitIntervalMs: 60000, asyncTestFn:ping});
- * monitor.on('data', (summary) => console.log('Ping Pong Latency: %O', summary));
- */
-class LatencyMonitor extends EventEmitter {
-  /**
-     * @param {Number} [latencyCheckIntervalMs=500] How often to add a latency check event (ms)
-     * @param {Number} [dataEmitIntervalMs=5000] How often to summarize latency check events. null or 0 disables event firing
-     * @param {function} [asyncTestFn] What cb-style async function to use
-     * @param {Number} [latencyRandomPercentage=5] What percent (+/-) of latencyCheckIntervalMs should we randomly use? This helps avoid alignment to other events.
-     */
-  constructor ({ latencyCheckIntervalMs, dataEmitIntervalMs, asyncTestFn, latencyRandomPercentage } = {}) {
-    super()
-    const that = this
-
-    // 0 isn't valid here, so its ok to use ||
-    that.latencyCheckIntervalMs = latencyCheckIntervalMs || 500 // 0.5s
-    that.latencyRandomPercentage = latencyRandomPercentage || 10
-    that._latecyCheckMultiply = 2 * (that.latencyRandomPercentage / 100.0) * that.latencyCheckIntervalMs
-    that._latecyCheckSubtract = that._latecyCheckMultiply / 2
-
-    that.dataEmitIntervalMs = (dataEmitIntervalMs === null || dataEmitIntervalMs === 0) ? undefined
-      : dataEmitIntervalMs || 5 * 1000 // 5s
-    debug('latencyCheckIntervalMs: %s dataEmitIntervalMs: %s',
-      that.latencyCheckIntervalMs, that.dataEmitIntervalMs)
-    if (that.dataEmitIntervalMs) {
-      debug('Expecting ~%s events per summary', that.latencyCheckIntervalMs / that.dataEmitIntervalMs)
-    } else {
-      debug('Not emitting summaries')
-    }
-
-    that.asyncTestFn = asyncTestFn // If there is no asyncFn, we measure latency
-
-    // If process: use high resolution timer
-    if (globalThis.process && globalThis.process.hrtime) {
-      debug('Using process.hrtime for timing')
-      that.now = globalThis.process.hrtime
-      that.getDeltaMS = (startTime) => {
-        const hrtime = that.now(startTime)
-        return (hrtime[0] * 1000) + (hrtime[1] / 1000000)
-      }
-      // Let's try for a timer that only monotonically increases
-    } else if (typeof window !== 'undefined' && window.performance && window.performance.now) {
-      debug('Using performance.now for timing')
-      that.now = window.performance.now.bind(window.performance)
-      that.getDeltaMS = (startTime) => Math.round(that.now() - startTime)
-    } else {
-      debug('Using Date.now for timing')
-      that.now = Date.now
-      that.getDeltaMS = (startTime) => that.now() - startTime
-    }
-
-    that._latencyData = that._initLatencyData()
-
-    // We check for isBrowser because of browsers set max rates of timeouts when a page is hidden,
-    // so we fall back to another library
-    // See: http://stackoverflow.com/questions/6032429/chrome-timeouts-interval-suspended-in-background-tabs
-    if (isBrowser()) {
-      that._visibilityChangeEmitter = new VisibilityChangeEmitter()
-      that._visibilityChangeEmitter.on('visibilityChange', (pageInFocus) => {
-        if (pageInFocus) {
-          that._startTimers()
-        } else {
-          that._emitSummary()
-          that._stopTimers()
-        }
-      })
-    }
-
-    if (!that._visibilityChangeEmitter || that._visibilityChangeEmitter.isVisible()) {
-      that._startTimers()
-    }
-  }
-
-  /**
-     * Start internal timers
-     * @private
-     */
-  _startTimers () {
-    // Timer already started, ignore this
-    if (this._checkLatencyID) {
-      return
-    }
-    this._checkLatency()
-    if (this.dataEmitIntervalMs) {
-      this._emitIntervalID = setInterval(() => this._emitSummary(), this.dataEmitIntervalMs)
-      if (typeof this._emitIntervalID.unref === 'function') {
-        this._emitIntervalID.unref() // Doesn't block exit
-      }
-    }
-  }
-
-  /**
-     * Stop internal timers
-     * @private
-     */
-  _stopTimers () {
-    if (this._checkLatencyID) {
-      clearTimeout(this._checkLatencyID)
-      this._checkLatencyID = undefined
-    }
-    if (this._emitIntervalID) {
-      clearInterval(this._emitIntervalID)
-      this._emitIntervalID = undefined
-    }
-  }
-
-  /**
-     * Emit summary only if there were events. It might not have any events if it was forced via a page hidden/show
-     * @private
-     */
-  _emitSummary () {
-    const summary = this.getSummary()
-    if (summary.events > 0) {
-      this.emit('data', summary)
-    }
-  }
-
-  /**
-     * Calling this function will end the collection period. If a timing event was already fired and somewhere in the queue,
-     * it will not count for this time period
-     * @returns {SummaryObject}
-     */
-  getSummary () {
-    // We might want to adjust for the number of expected events
-    // Example: first 1 event it comes back, then such a long blocker that the next emit check comes
-    // Then this fires - looks like no latency!!
-    const latency = {
-      events: this._latencyData.events,
-      minMs: this._latencyData.minMs,
-      maxMs: this._latencyData.maxMs,
-      avgMs: this._latencyData.events ? this._latencyData.totalMs / this._latencyData.events
-        : Number.POSITIVE_INFINITY,
-      lengthMs: this.getDeltaMS(this._latencyData.startTime)
-    }
-    this._latencyData = this._initLatencyData() // Clear
-
-    debug('Summary: %O', latency)
-    return latency
-  }
-
-  /**
-     * Randomly calls an async fn every roughly latencyCheckIntervalMs (plus some randomness). If no async fn is found,
-     * it will simply report on event loop latency.
-     *
-     * @private
-     */
-  _checkLatency () {
-    const that = this
-    // Randomness is needed to avoid alignment by accident to regular things in the event loop
-    const randomness = (Math.random() * that._latecyCheckMultiply) - that._latecyCheckSubtract
-
-    // We use this to ensure that in case some overlap somehow, we don't take the wrong startTime/offset
-    const localData = {
-      deltaOffset: Math.ceil(that.latencyCheckIntervalMs + randomness),
-      startTime: that.now()
-    }
-
-    const cb = () => {
-      // We are already stopped, ignore this datapoint
-      if (!this._checkLatencyID) {
-        return
-      }
-      const deltaMS = that.getDeltaMS(localData.startTime) - localData.deltaOffset
-      that._checkLatency() // Start again ASAP
-
-      // Add the data point. If this gets complex, refactor it
-      that._latencyData.events++
-      that._latencyData.minMs = Math.min(that._latencyData.minMs, deltaMS)
-      that._latencyData.maxMs = Math.max(that._latencyData.maxMs, deltaMS)
-      that._latencyData.totalMs += deltaMS
-      debug('MS: %s Data: %O', deltaMS, that._latencyData)
-    }
-    debug('localData: %O', localData)
-
-    this._checkLatencyID = setTimeout(() => {
-      // This gets rid of including event loop
-      if (that.asyncTestFn) {
-        // Clear timing related things
-        localData.deltaOffset = 0
-        localData.startTime = that.now()
-        that.asyncTestFn(cb)
-      } else {
-        // setTimeout is not more accurate than 1ms, so this will ensure positive numbers. Add 1 to emitted data to remove.
-        // This is not the best, but for now it'll be just fine. This isn't meant to be sub ms accurate.
-        localData.deltaOffset -= 1
-        // If there is no function to test, we mean check latency which is a special case that is really cb => cb()
-        // We avoid that for the few extra function all overheads. Also, we want to keep the timers different
-        cb()
-      }
-    }, localData.deltaOffset)
-
-    if (typeof this._checkLatencyID.unref === 'function') {
-      this._checkLatencyID.unref() // Doesn't block exit
-    }
-  }
-
-  _initLatencyData () {
-    return {
-      startTime: this.now(),
-      minMs: Number.POSITIVE_INFINITY,
-      maxMs: Number.NEGATIVE_INFINITY,
-      events: 0,
-      totalMs: 0
-    }
-  }
-}
-
-function isBrowser () {
-  return typeof window !== 'undefined'
-}
-
-module.exports = LatencyMonitor
--- a/src/connection-manager/visibility-change-emitter.js
+++ b/src/connection-manager/visibility-change-emitter.js
@ -1,118 +0,0 @@
-/* global document */
-
-/**
- * This code is based on `latency-monitor` (https://github.com/mlucool/latency-monitor) by `mlucool` (https://github.com/mlucool), available under Apache License 2.0 (https://github.com/mlucool/latency-monitor/blob/master/LICENSE)
- */
-'use strict'
-const EventEmitter = require('events')
-
-const debug = require('debug')('latency-monitor:VisibilityChangeEmitter')
-
-/**
- * Listen to page visibility change events (i.e. when the page is focused / blurred) by an event emitter.
- *
- * Warning: This does not work on all browsers, but should work on all modern browsers
- *
- * @example
- *
- *     const myVisibilityEmitter = new VisibilityChangeEmitter();
- *
- *     myVisibilityEmitter.on('visibilityChange', (pageInFocus) => {
- *        if ( pageInFocus ){
- *            // Page is in focus
- *            console.log('In focus');
- *        }
- *        else {
- *            // Page is blurred
- *            console.log('Out of focus');
- *        }
- *     });
- *     // To access the visibility state directly, call:
- *     console.log('Am I focused now? ' + myVisibilityEmitter.isVisible());
- *
- * @class VisibilityChangeEmitter
- */
-module.exports = class VisibilityChangeEmitter extends EventEmitter {
-  /**
-     * Creates a VisibilityChangeEmitter
-     */
-  constructor () {
-    super()
-    if (typeof document === 'undefined') {
-      debug('This is not a browser, no "document" found. Stopping.')
-      return
-    }
-    this._initializeVisibilityVarNames()
-    this._addVisibilityChangeListener()
-  }
-
-  /**
-     * document.hidden and document.visibilityChange are the two variables we need to check for;
-     * Since these variables are named differently in different browsers, this function sets
-     * the appropriate name based on the browser being used. Once executed, tha actual names of
-     * document.hidden and document.visibilityChange are found in this._hidden and this._visibilityChange
-     * respectively
-     * @private
-     */
-  _initializeVisibilityVarNames () {
-    let hidden
-    let visibilityChange
-    if (typeof document.hidden !== 'undefined') { // Opera 12.10 and Firefox 18 and later support
-      hidden = 'hidden'
-      visibilityChange = 'visibilitychange'
-    } else if (typeof document.mozHidden !== 'undefined') {
-      hidden = 'mozHidden'
-      visibilityChange = 'mozvisibilitychange'
-    } else if (typeof document.msHidden !== 'undefined') {
-      hidden = 'msHidden'
-      visibilityChange = 'msvisibilitychange'
-    } else if (typeof document.webkitHidden !== 'undefined') {
-      hidden = 'webkitHidden'
-      visibilityChange = 'webkitvisibilitychange'
-    }
-    this._hidden = hidden
-    this._visibilityChange = visibilityChange
-  }
-
-  /**
-     * Adds an event listener on the document that listens to changes in document.visibilityChange
-     * (or whatever name by which the visibilityChange variable is known in the browser)
-     * @private
-     */
-  _addVisibilityChangeListener () {
-    if (typeof document.addEventListener === 'undefined' ||
-            typeof document[this._hidden] === 'undefined') {
-      debug('Checking page visibility requires a browser that supports the Page Visibility API.')
-    } else {
-      // Handle page visibility change
-      document.addEventListener(this._visibilityChange, this._handleVisibilityChange.bind(this), false)
-    }
-  }
-
-  /**
-     * The function returns ```true``` if the page is visible or ```false``` if the page is not visible and
-     * ```undefined``` if the page visibility API is not supported by the browser.
-     * @returns {Boolean|void} whether the page is now visible or not (undefined is unknown)
-     */
-  isVisible () {
-    if (this._hidden === undefined || document[this._hidden] === undefined) {
-      return undefined
-    }
-
-    return !document[this._hidden]
-  }
-
-  /**
-     * The function that is called when document.visibilityChange has changed
-     * It emits an event called visibilityChange and sends the value of document.hidden as a
-     * parameter
-     *
-     * @private
-     */
-  _handleVisibilityChange () {
-    const visible = !document[this._hidden]
-    debug(visible ? 'Page Visible' : 'Page Hidden')
-    // Emit the event
-    this.emit('visibilityChange', visible)
-  }
-}
--- a/src/dialer/index.js
+++ b/src/dialer/index.js
@ -70,7 +70,7 @@ class Dialer {
  async connectToPeer (peer, options = {}) {
    const dialTarget = this._createDialTarget(peer)
    if (dialTarget.addrs.length === 0) {
-      throw errCode(new Error('The dial request has no addresses'), codes.ERR_NO_VALID_ADDRESSES)
+      throw errCode(new Error('The dial request has no addresses'), 'ERR_NO_DIAL_MULTIADDRS')
    }
    const pendingDial = this._pendingDials.get(dialTarget.id) || this._createPendingDial(dialTarget, options)

@ -136,7 +136,7 @@ class Dialer {
   */
  _createPendingDial (dialTarget, options) {
    const dialAction = (addr, options) => {
-      if (options.signal.aborted) throw errCode(new Error('already aborted'), codes.ERR_ALREADY_ABORTED)
+      if (options.signal.aborted) throw errCode(new Error('already aborted'), 'ERR_ALREADY_ABORTED')
      return this.transportManager.dial(addr, options)
    }

@ -197,7 +197,8 @@ class Dialer {
      try {
        peer = PeerId.createFromCID(peer.getPeerId())
      } catch (err) {
-        throw errCode(new Error('The multiaddr did not contain a valid peer id'), codes.ERR_INVALID_PEER)
+        // Couldn't get the PeerId, just use the address
+        return peer
      }
    }

--- a/src/errors.js
+++ b/src/errors.js
@ -12,7 +12,6 @@ exports.codes = {
  ERR_CONNECTION_ENDED: 'ERR_CONNECTION_ENDED',
  ERR_CONNECTION_FAILED: 'ERR_CONNECTION_FAILED',
  ERR_NODE_NOT_STARTED: 'ERR_NODE_NOT_STARTED',
-  ERR_ALREADY_ABORTED: 'ERR_ALREADY_ABORTED',
  ERR_NO_VALID_ADDRESSES: 'ERR_NO_VALID_ADDRESSES',
  ERR_DISCOVERED_SELF: 'ERR_DISCOVERED_SELF',
  ERR_DUPLICATE_TRANSPORT: 'ERR_DUPLICATE_TRANSPORT',
@ -20,7 +19,6 @@ exports.codes = {
  ERR_HOP_REQUEST_FAILED: 'ERR_HOP_REQUEST_FAILED',
  ERR_INVALID_KEY: 'ERR_INVALID_KEY',
  ERR_INVALID_MESSAGE: 'ERR_INVALID_MESSAGE',
-  ERR_INVALID_PARAMETERS: 'ERR_INVALID_PARAMETERS',
  ERR_INVALID_PEER: 'ERR_INVALID_PEER',
  ERR_MUXER_UNAVAILABLE: 'ERR_MUXER_UNAVAILABLE',
  ERR_TIMEOUT: 'ERR_TIMEOUT',
--- a/src/identify/index.js
+++ b/src/identify/index.js
@ -1,11 +1,10 @@
 'use strict'

-const { Buffer } = require('buffer')
 const debug = require('debug')
 const pb = require('it-protocol-buffers')
 const lp = require('it-length-prefixed')
 const pipe = require('it-pipe')
-const { collect, take, consume } = require('streaming-iterables')
+const { collect, take } = require('streaming-iterables')

 const PeerInfo = require('peer-info')
 const PeerId = require('peer-id')
@ -115,8 +114,7 @@ class IdentifyService {
            protocols: Array.from(this._protocols.keys())
          }],
          pb.encode(Message),
-          stream,
-          consume
+          stream
        )
      } catch (err) {
        // Just log errors
@ -155,7 +153,6 @@ class IdentifyService {
  async identify (connection) {
    const { stream } = await connection.newStream(MULTICODEC_IDENTIFY)
    const [data] = await pipe(
-      [],
      stream,
      lp.decode(),
      take(1),
@ -245,8 +242,7 @@ class IdentifyService {
    pipe(
      [message],
      lp.encode(),
-      stream,
-      consume
+      stream
    )
  }

@ -259,7 +255,6 @@ class IdentifyService {
   */
  async _handlePush ({ connection, stream }) {
    const [data] = await pipe(
-      [],
      stream,
      lp.decode(),
      take(1),
--- a/src/index.js
+++ b/src/index.js
@ -2,7 +2,6 @@

 const { EventEmitter } = require('events')
 const debug = require('debug')
-const globalThis = require('ipfs-utils/src/globalthis')
 const log = debug('libp2p')
 log.error = debug('libp2p:error')

@ -143,7 +142,7 @@ class Libp2p extends EventEmitter {
    // Attach private network protector
    if (this._modules.connProtector) {
      this.upgrader.protector = this._modules.connProtector
-    } else if (globalThis.process !== undefined && globalThis.process.env && globalThis.process.env.LIBP2P_FORCE_PNET) {
+    } else if (process.env.LIBP2P_FORCE_PNET) {
      throw new Error('Private network is enforced, but no protector was provided')
    }

@ -312,17 +311,10 @@ class Libp2p extends EventEmitter {
   * @param {PeerInfo|PeerId|multiaddr|string} peer the peer to close connections to
   * @returns {Promise<void>}
   */
-  async hangUp (peer) {
+  hangUp (peer) {
    const peerInfo = getPeerInfo(peer, this.peerStore)
-
-    const connections = this.registrar.connections.get(peerInfo.id.toB58String())
-
-    if (!connections) {
-      return
-    }
-
-    await Promise.all(
-      connections.map(connection => {
+    return Promise.all(
+      this.registrar.connections.get(peerInfo.id.toB58String()).map(connection => {
        return connection.close()
      })
    )
@ -407,7 +399,7 @@ class Libp2p extends EventEmitter {
   * Called when libp2p has started and before it returns
   * @private
   */
-  async _onDidStart () {
+  _onDidStart () {
    this._isStarted = true

    this.connectionManager.start()
@ -418,7 +410,7 @@ class Libp2p extends EventEmitter {
    })

    // Peer discovery
-    await this._setupPeerDiscovery()
+    this._setupPeerDiscovery()

    // Once we start, emit and dial any peers we may have already discovered
    for (const peerInfo of this.peerStore.peers.values()) {
@ -466,10 +458,10 @@ class Libp2p extends EventEmitter {
  /**
   * Initializes and starts peer discovery services
   *
-   * @async
   * @private
+   * @returns {Promise<void>}
   */
-  async _setupPeerDiscovery () {
+  _setupPeerDiscovery () {
    const setupService = (DiscoveryService) => {
      let config = {
        enabled: true // on by default
@ -486,7 +478,7 @@ class Libp2p extends EventEmitter {
        let discoveryService

        if (typeof DiscoveryService === 'function') {
-          discoveryService = new DiscoveryService(Object.assign({}, config, { peerInfo: this.peerInfo, libp2p: this }))
+          discoveryService = new DiscoveryService(Object.assign({}, config, { peerInfo: this.peerInfo }))
        } else {
          discoveryService = DiscoveryService
        }
@ -508,17 +500,18 @@ class Libp2p extends EventEmitter {
      }
    }

-    await Promise.all(Array.from(this._discovery.values(), d => d.start()))
+    return Promise.all(Array.from(this._discovery.values(), d => d.start()))
  }
 }

+module.exports = Libp2p
 /**
 * Like `new Libp2p(options)` except it will create a `PeerInfo`
 * instance if one is not provided in options.
 * @param {object} options Libp2p configuration options
 * @returns {Libp2p}
 */
-Libp2p.create = async function create (options = {}) {
+module.exports.create = async (options = {}) => {
  if (options.peerInfo) {
    return new Libp2p(options)
  }
@ -528,5 +521,3 @@ Libp2p.create = async function create (options = {}) {
  options.peerInfo = peerInfo
  return new Libp2p(options)
 }
-
-module.exports = Libp2p
--- a/src/peer-store/index.js
+++ b/src/peer-store/index.js
@ -1,6 +1,6 @@
 'use strict'

-const errcode = require('err-code')
+const assert = require('assert')
 const debug = require('debug')
 const log = debug('libp2p:peer-store')
 log.error = debug('libp2p:peer-store:error')
@ -9,9 +9,6 @@ const { EventEmitter } = require('events')

 const PeerId = require('peer-id')
 const PeerInfo = require('peer-info')
-const {
-  ERR_INVALID_PARAMETERS
-} = require('../errors')

 /**
 * Responsible for managing known peers, as well as their addresses and metadata
@ -49,9 +46,7 @@ class PeerStore extends EventEmitter {
   * @return {PeerInfo}
   */
  put (peerInfo, options = { silent: false }) {
-    if (!PeerInfo.isPeerInfo(peerInfo)) {
-      throw errcode(new Error('peerInfo must be an instance of peer-info'), ERR_INVALID_PARAMETERS)
-    }
+    assert(PeerInfo.isPeerInfo(peerInfo), 'peerInfo must be an instance of peer-info')

    let peer
    // Already know the peer?
@ -72,9 +67,7 @@ class PeerStore extends EventEmitter {
   * @return {PeerInfo}
   */
  add (peerInfo) {
-    if (!PeerInfo.isPeerInfo(peerInfo)) {
-      throw errcode(new Error('peerInfo must be an instance of peer-info'), ERR_INVALID_PARAMETERS)
-    }
+    assert(PeerInfo.isPeerInfo(peerInfo), 'peerInfo must be an instance of peer-info')

    // Create new instance and add values to it
    const newPeerInfo = new PeerInfo(peerInfo.id)
@ -112,10 +105,7 @@ class PeerStore extends EventEmitter {
   * @return {PeerInfo}
   */
  update (peerInfo) {
-    if (!PeerInfo.isPeerInfo(peerInfo)) {
-      throw errcode(new Error('peerInfo must be an instance of peer-info'), ERR_INVALID_PARAMETERS)
-    }
-
+    assert(PeerInfo.isPeerInfo(peerInfo), 'peerInfo must be an instance of peer-info')
    const id = peerInfo.id.toB58String()
    const recorded = this.peers.get(id)

@ -217,9 +207,7 @@ class PeerStore extends EventEmitter {
   * @returns {void}
   */
  replace (peerInfo) {
-    if (!PeerInfo.isPeerInfo(peerInfo)) {
-      throw errcode(new Error('peerInfo must be an instance of peer-info'), ERR_INVALID_PARAMETERS)
-    }
+    assert(PeerInfo.isPeerInfo(peerInfo), 'peerInfo must be an instance of peer-info')

    this.remove(peerInfo.id.toB58String())
    this.add(peerInfo)
@ -236,17 +224,12 @@ class PeerStore extends EventEmitter {
  }

  /**
-   * Returns the known multiaddrs for a given `PeerInfo`. All returned multiaddrs
-   * will include the encapsulated `PeerId` of the peer.
+   * Returns the known multiaddrs for a given `PeerInfo`
   * @param {PeerInfo} peer
   * @returns {Array<Multiaddr>}
   */
  multiaddrsForPeer (peer) {
-    return this.put(peer, true).multiaddrs.toArray().map(addr => {
-      const idString = addr.getPeerId()
-      if (idString && idString === peer.id.toB58String()) return addr
-      return addr.encapsulate(`/p2p/${peer.id.toB58String()}`)
-    })
+    return this.put(peer, true).multiaddrs.toArray()
  }
 }

--- a/src/ping/index.js
+++ b/src/ping/index.js
@ -8,7 +8,7 @@ const errCode = require('err-code')
 const crypto = require('libp2p-crypto')
 const pipe = require('it-pipe')
 const { toBuffer } = require('it-buffer')
-const { collect, take } = require('streaming-iterables')
+const { collect } = require('streaming-iterables')

 const { PROTOCOL, PING_LENGTH } = require('./constants')

@ -29,7 +29,6 @@ async function ping (node, peer) {
  const [result] = await pipe(
    [data],
    stream,
-    stream => take(1, stream),
    toBuffer,
    collect
  )
--- a/src/pnet/crypto.js
+++ b/src/pnet/crypto.js
@ -1,6 +1,5 @@
 'use strict'

-const { Buffer } = require('buffer')
 const debug = require('debug')
 const Errors = require('./errors')
 const xsalsa20 = require('xsalsa20')
--- a/src/pnet/index.js
+++ b/src/pnet/index.js
@ -1,13 +1,10 @@
 'use strict'

 const pipe = require('it-pipe')
-const errcode = require('err-code')
+const assert = require('assert')
 const duplexPair = require('it-pair/duplex')
 const crypto = require('libp2p-crypto')
 const Errors = require('./errors')
-const {
-  ERR_INVALID_PARAMETERS
-} = require('../errors')
 const {
  createBoxStream,
  createUnboxStream,
@ -43,9 +40,7 @@ class Protector {
   * @returns {*} A protected duplex iterable
   */
  async protect (connection) {
-    if (!connection) {
-      throw errcode(new Error(Errors.NO_HANDSHAKE_CONNECTION), ERR_INVALID_PARAMETERS)
-    }
+    assert(connection, Errors.NO_HANDSHAKE_CONNECTION)

    // Exchange nonces
    log('protecting the connection')
--- a/src/pnet/key-generator.js
+++ b/src/pnet/key-generator.js
@ -1,6 +1,6 @@
 'use strict'

-const crypto = require('libp2p-crypto')
+const crypto = require('crypto')
 const KEY_LENGTH = 32

 /**
--- a/src/pubsub.js
+++ b/src/pubsub.js
@ -1,6 +1,5 @@
 'use strict'

-const { Buffer } = require('buffer')
 const errCode = require('err-code')
 const { messages, codes } = require('./errors')

--- a/src/registrar.js
+++ b/src/registrar.js
@ -1,13 +1,10 @@
 'use strict'

+const assert = require('assert')
 const debug = require('debug')
-const errcode = require('err-code')
 const log = debug('libp2p:peer-store')
 log.error = debug('libp2p:peer-store:error')

-const {
-  ERR_INVALID_PARAMETERS
-} = require('./errors')
 const Topology = require('libp2p-interfaces/src/topology')
 const { Connection } = require('libp2p-interfaces/src/connection')
 const PeerInfo = require('peer-info')
@ -74,13 +71,8 @@ class Registrar {
   * @returns {void}
   */
  onConnect (peerInfo, conn) {
-    if (!PeerInfo.isPeerInfo(peerInfo)) {
-      throw errcode(new Error('peerInfo must be an instance of peer-info'), ERR_INVALID_PARAMETERS)
-    }
-
-    if (!Connection.isConnection(conn)) {
-      throw errcode(new Error('conn must be an instance of interface-connection'), ERR_INVALID_PARAMETERS)
-    }
+    assert(PeerInfo.isPeerInfo(peerInfo), 'peerInfo must be an instance of peer-info')
+    assert(Connection.isConnection(conn), 'conn must be an instance of interface-connection')

    const id = peerInfo.id.toB58String()
    const storedConn = this.connections.get(id)
@ -101,9 +93,7 @@ class Registrar {
   * @returns {void}
   */
  onDisconnect (peerInfo, connection, error) {
-    if (!PeerInfo.isPeerInfo(peerInfo)) {
-      throw errcode(new Error('peerInfo must be an instance of peer-info'), ERR_INVALID_PARAMETERS)
-    }
+    assert(PeerInfo.isPeerInfo(peerInfo), 'peerInfo must be an instance of peer-info')

    const id = peerInfo.id.toB58String()
    let storedConn = this.connections.get(id)
@ -126,9 +116,7 @@ class Registrar {
   * @returns {Connection}
   */
  getConnection (peerInfo) {
-    if (!PeerInfo.isPeerInfo(peerInfo)) {
-      throw errcode(new Error('peerInfo must be an instance of peer-info'), ERR_INVALID_PARAMETERS)
-    }
+    assert(PeerInfo.isPeerInfo(peerInfo), 'peerInfo must be an instance of peer-info')

    const connections = this.connections.get(peerInfo.id.toB58String())
    // Return the first, open connection
@ -144,9 +132,9 @@ class Registrar {
   * @return {string} registrar identifier
   */
  register (topology) {
-    if (!Topology.isTopology(topology)) {
-      throw errcode(new Error('topology must be an instance of interfaces/topology'), ERR_INVALID_PARAMETERS)
-    }
+    assert(
+      Topology.isTopology(topology),
+      'topology must be an instance of interfaces/topology')

    // Create topology
    const id = (parseInt(Math.random() * 1e9)).toString(36) + Date.now()
--- a/src/upgrader.js
+++ b/src/upgrader.js
@ -231,7 +231,7 @@ class Upgrader {
            const { stream, protocol } = await mss.handle(Array.from(this.protocols.keys()))
            log('%s: incoming stream opened on %s', direction, protocol)
            if (this.metrics) this.metrics.trackStream({ stream, remotePeer, protocol })
-            connection.addStream(muxedStream, { protocol })
+            connection.addStream(stream, protocol)
            this._onStream({ connection, stream, protocol })
          } catch (err) {
            log.error(err)
--- a/test/content-routing/content-routing.node.js
+++ b/test/content-routing/content-routing.node.js
@ -155,7 +155,10 @@ describe('content-routing', () => {
      const mockApi = nock('http://0.0.0.0:60197')
        // mock the refs call
        .post('/api/v0/refs')
-        .query(true)
+        .query({
+          recursive: false,
+          arg: cid.toBaseEncodedString()
+        })
        .reply(200, null, [
          'Content-Type', 'application/json',
          'X-Chunked-Output', '1'
@ -171,7 +174,10 @@ describe('content-routing', () => {
      const mockApi = nock('http://0.0.0.0:60197')
        // mock the refs call
        .post('/api/v0/refs')
-        .query(true)
+        .query({
+          recursive: false,
+          arg: cid.toBaseEncodedString()
+        })
        .reply(502, 'Bad Gateway', ['Content-Type', 'application/json'])

      await expect(node.contentRouting.provide(cid))
@ -186,7 +192,9 @@ describe('content-routing', () => {

      const mockApi = nock('http://0.0.0.0:60197')
        .post('/api/v0/dht/findprovs')
-        .query(true)
+        .query({
+          arg: cid.toBaseEncodedString()
+        })
        .reply(200, `{"Extra":"","ID":"QmWKqWXCtRXEeCQTo3FoZ7g4AfnGiauYYiczvNxFCHicbB","Responses":[{"Addrs":["/ip4/0.0.0.0/tcp/0"],"ID":"${provider}"}],"Type":4}\n`, [
          'Content-Type', 'application/json',
          'X-Chunked-Output', '1'
@ -206,7 +214,9 @@ describe('content-routing', () => {
      const cid = new CID('QmU621oD8AhHw6t25vVyfYKmL9VV3PTgc52FngEhTGACFB')
      const mockApi = nock('http://0.0.0.0:60197')
        .post('/api/v0/dht/findprovs')
-        .query(true)
+        .query({
+          arg: cid.toBaseEncodedString()
+        })
        .reply(502, 'Bad Gateway', [
          'X-Chunked-Output', '1'
        ])
--- a/test/content-routing/dht/operation.node.js
+++ b/test/content-routing/dht/operation.node.js
@ -1,7 +1,6 @@
 'use strict'
 /* eslint-env mocha */

-const { Buffer } = require('buffer')
 const chai = require('chai')
 chai.use(require('dirty-chai'))
 const { expect } = chai
@ -44,7 +43,7 @@ describe('DHT subsystem operates correctly', () => {
        remoteLibp2p.start()
      ])

-      remAddr = libp2p.peerStore.multiaddrsForPeer(remotePeerInfo)[0]
+      remAddr = remoteLibp2p.transportManager.getAddrs()[0]
    })

    afterEach(() => Promise.all([
@ -99,7 +98,7 @@ describe('DHT subsystem operates correctly', () => {
      await libp2p.start()
      await remoteLibp2p.start()

-      remAddr = libp2p.peerStore.multiaddrsForPeer(remotePeerInfo)[0]
+      remAddr = remoteLibp2p.transportManager.getAddrs()[0]
    })

    afterEach(() => Promise.all([
--- a/test/core/ping.node.js
+++ b/test/core/ping.node.js
@ -6,11 +6,9 @@ chai.use(require('dirty-chai'))
 const { expect } = chai

 const pTimes = require('p-times')
-const pipe = require('it-pipe')

 const peerUtils = require('../utils/creators/peer')
 const baseOptions = require('../utils/base-options')
-const { PROTOCOL } = require('../../src/ping/constants')

 describe('ping', () => {
  let nodes
@ -34,40 +32,4 @@ describe('ping', () => {
    const averageLatency = latencies.reduce((p, c) => p + c, 0) / latencies.length
    expect(averageLatency).to.be.a('Number')
  })
-
-  it('only waits for the first response to arrive', async () => {
-    nodes[1].handle(PROTOCOL, async ({ connection, stream }) => {
-      let firstInvocation = true
-
-      await pipe(
-        stream,
-        function (stream) {
-          const output = {
-            [Symbol.asyncIterator]: () => output,
-            next: async () => {
-              if (firstInvocation) {
-                firstInvocation = false
-
-                for await (const data of stream) {
-                  return {
-                    value: data,
-                    done: false
-                  }
-                }
-              } else {
-                return new Promise() // never resolve
-              }
-            }
-          }
-
-          return output
-        },
-        stream
-      )
-    })
-
-    const latency = await nodes[0].ping(nodes[1].peerInfo)
-
-    expect(latency).to.be.a('Number')
-  })
 })
--- a/test/dialing/direct.node.js
+++ b/test/dialing/direct.node.js
@ -1,7 +1,6 @@
 'use strict'
 /* eslint-env mocha */

-const { Buffer } = require('buffer')
 const chai = require('chai')
 chai.use(require('dirty-chai'))
 chai.use(require('chai-as-promised'))
@ -35,25 +34,20 @@ const Peers = require('../fixtures/peers')
 const { createPeerInfo } = require('../utils/creators/peer')

 const listenAddr = multiaddr('/ip4/127.0.0.1/tcp/0')
-const unsupportedAddr = multiaddr('/ip4/127.0.0.1/tcp/9999/ws/p2p/QmckxVrJw1Yo8LqvmDJNUmdAsKtSbiKWmrXJFyKmUraBoN')
+const unsupportedAddr = multiaddr('/ip4/127.0.0.1/tcp/9999/ws')

 describe('Dialing (direct, TCP)', () => {
  let remoteTM
  let localTM
-  let peerStore
  let remoteAddr

  before(async () => {
-    const [remotePeerId] = await Promise.all([
-      PeerId.createFromJSON(Peers[0])
-    ])
    remoteTM = new TransportManager({
      libp2p: {},
      upgrader: mockUpgrader
    })
    remoteTM.add(Transport.prototype[Symbol.toStringTag], Transport)

-    peerStore = new PeerStore()
    localTM = new TransportManager({
      libp2p: {},
      upgrader: mockUpgrader
@ -62,7 +56,7 @@ describe('Dialing (direct, TCP)', () => {

    await remoteTM.listen([listenAddr])

-    remoteAddr = remoteTM.getAddrs()[0].encapsulate(`/p2p/${remotePeerId.toB58String()}`)
+    remoteAddr = remoteTM.getAddrs()[0]
  })

  after(() => remoteTM.close())
@ -72,7 +66,7 @@ describe('Dialing (direct, TCP)', () => {
  })

  it('should be able to connect to a remote node via its multiaddr', async () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({ transportManager: localTM })

    const connection = await dialer.connectToPeer(remoteAddr)
    expect(connection).to.exist()
@ -80,7 +74,7 @@ describe('Dialing (direct, TCP)', () => {
  })

  it('should be able to connect to a remote node via its stringified multiaddr', async () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({ transportManager: localTM })

    const dialable = Dialer.getDialable(remoteAddr.toString())
    const connection = await dialer.connectToPeer(dialable)
@ -89,7 +83,7 @@ describe('Dialing (direct, TCP)', () => {
  })

  it('should fail to connect to an unsupported multiaddr', async () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({ transportManager: localTM })

    await expect(dialer.connectToPeer(unsupportedAddr))
      .to.eventually.be.rejectedWith(AggregateError)
@ -146,7 +140,6 @@ describe('Dialing (direct, TCP)', () => {
  it('should abort dials on queue task timeout', async () => {
    const dialer = new Dialer({
      transportManager: localTM,
-      peerStore,
      timeout: 50
    })
    sinon.stub(localTM, 'dial').callsFake(async (addr, options) => {
@ -231,7 +224,7 @@ describe('Dialing (direct, TCP)', () => {
      remoteLibp2p.handle('/echo/1.0.0', ({ stream }) => pipe(stream, stream))

      await remoteLibp2p.start()
-      remoteAddr = remoteLibp2p.transportManager.getAddrs()[0].encapsulate(`/p2p/${remotePeerId.toB58String()}`)
+      remoteAddr = remoteLibp2p.transportManager.getAddrs()[0]
    })

    afterEach(async () => {
@ -242,28 +235,6 @@ describe('Dialing (direct, TCP)', () => {

    after(() => remoteLibp2p.stop())

-    it('should fail if no peer id is provided', async () => {
-      libp2p = new Libp2p({
-        peerInfo,
-        modules: {
-          transport: [Transport],
-          streamMuxer: [Muxer],
-          connEncryption: [Crypto]
-        }
-      })
-
-      sinon.spy(libp2p.dialer, 'connectToPeer')
-
-      try {
-        await libp2p.dial(remoteLibp2p.transportManager.getAddrs()[0])
-      } catch (err) {
-        expect(err).to.have.property('code', ErrorCodes.ERR_INVALID_PEER)
-        return
-      }
-
-      expect.fail('dial should have failed')
-    })
-
    it('should use the dialer for connecting to a multiaddr', async () => {
      libp2p = new Libp2p({
        peerInfo,
@ -296,8 +267,10 @@ describe('Dialing (direct, TCP)', () => {
      })

      sinon.spy(libp2p.dialer, 'connectToPeer')
+      const remotePeer = new PeerInfo(remoteLibp2p.peerInfo.id)
+      remotePeer.multiaddrs.add(remoteAddr)

-      const connection = await libp2p.dial(remotePeerInfo)
+      const connection = await libp2p.dial(remotePeer)
      expect(connection).to.exist()
      const { stream, protocol } = await connection.newStream('/echo/1.0.0')
      expect(stream).to.exist()
@ -333,7 +306,7 @@ describe('Dialing (direct, TCP)', () => {
        }
      })

-      const connection = await libp2p.dial(`${remoteAddr.toString()}`)
+      const connection = await libp2p.dial(`${remoteAddr.toString()}/p2p/${remotePeerInfo.id.toB58String()}`)
      expect(connection).to.exist()
      expect(connection.stat.timeline.close).to.not.exist()
      await libp2p.hangUp(connection.remotePeer)
@ -364,6 +337,33 @@ describe('Dialing (direct, TCP)', () => {
      expect(libp2p.upgrader.protector.protect.callCount).to.equal(1)
    })

+    it('should coalesce parallel dials to the same peer (no id in multiaddr)', async () => {
+      libp2p = new Libp2p({
+        peerInfo,
+        modules: {
+          transport: [Transport],
+          streamMuxer: [Muxer],
+          connEncryption: [Crypto]
+        }
+      })
+      const dials = 10
+
+      const dialResults = await Promise.all([...new Array(dials)].map((_, index) => {
+        if (index % 2 === 0) return libp2p.dial(remoteLibp2p.peerInfo)
+        return libp2p.dial(remoteLibp2p.peerInfo.multiaddrs.toArray()[0])
+      }))
+
+      // All should succeed and we should have ten results
+      expect(dialResults).to.have.length(10)
+      for (const connection of dialResults) {
+        expect(Connection.isConnection(connection)).to.equal(true)
+      }
+
+      // We will have two connections, since the multiaddr dial doesn't have a peer id
+      expect(libp2p.connectionManager._connections.size).to.equal(2)
+      expect(remoteLibp2p.connectionManager._connections.size).to.equal(2)
+    })
+
    it('should coalesce parallel dials to the same peer (id in multiaddr)', async () => {
      libp2p = new Libp2p({
        peerInfo,
@ -405,9 +405,10 @@ describe('Dialing (direct, TCP)', () => {
      const error = new Error('Boom')
      sinon.stub(libp2p.transportManager, 'dial').callsFake(() => Promise.reject(error))

+      const fullAddress = remoteAddr.encapsulate(`/p2p/${remoteLibp2p.peerInfo.id.toB58String()}`)
      const dialResults = await pSettle([...new Array(dials)].map((_, index) => {
        if (index % 2 === 0) return libp2p.dial(remoteLibp2p.peerInfo)
-        return libp2p.dial(remoteAddr)
+        return libp2p.dial(fullAddress)
      }))

      // All should succeed and we should have ten results
--- a/test/dialing/direct.spec.js
+++ b/test/dialing/direct.spec.js
@ -21,7 +21,6 @@ const { AbortError } = require('libp2p-interfaces/src/transport/errors')
 const { codes: ErrorCodes } = require('../../src/errors')
 const Constants = require('../../src/constants')
 const Dialer = require('../../src/dialer')
-const PeerStore = require('../../src/peer-store')
 const TransportManager = require('../../src/transport-manager')
 const Libp2p = require('../../src')

@ -30,15 +29,13 @@ const { MULTIADDRS_WEBSOCKETS } = require('../fixtures/browser')
 const mockUpgrader = require('../utils/mockUpgrader')
 const createMockConnection = require('../utils/mockConnection')
 const { createPeerId } = require('../utils/creators/peer')
-const unsupportedAddr = multiaddr('/ip4/127.0.0.1/tcp/9999/ws/p2p/QmckxVrJw1Yo8LqvmDJNUmdAsKtSbiKWmrXJFyKmUraBoN')
+const unsupportedAddr = multiaddr('/ip4/127.0.0.1/tcp/9999/ws')
 const remoteAddr = MULTIADDRS_WEBSOCKETS[0]

 describe('Dialing (direct, WebSockets)', () => {
  let localTM
-  let peerStore

  before(() => {
-    peerStore = new PeerStore()
    localTM = new TransportManager({
      libp2p: {},
      upgrader: mockUpgrader,
@ -52,13 +49,13 @@ describe('Dialing (direct, WebSockets)', () => {
  })

  it('should have appropriate defaults', () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({ transportManager: localTM })
    expect(dialer.concurrency).to.equal(Constants.MAX_PARALLEL_DIALS)
    expect(dialer.timeout).to.equal(Constants.DIAL_TIMEOUT)
  })

  it('should limit the number of tokens it provides', () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({ transportManager: localTM })
    const maxPerPeer = Constants.MAX_PER_PEER_DIALS
    expect(dialer.tokens).to.have.length(Constants.MAX_PARALLEL_DIALS)
    const tokens = dialer.getTokens(maxPerPeer + 1)
@ -67,14 +64,14 @@ describe('Dialing (direct, WebSockets)', () => {
  })

  it('should not return tokens if non are left', () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({ transportManager: localTM })
    sinon.stub(dialer, 'tokens').value([])
    const tokens = dialer.getTokens(1)
    expect(tokens.length).to.equal(0)
  })

  it('should NOT be able to return a token twice', () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({ transportManager: localTM })
    const tokens = dialer.getTokens(1)
    expect(tokens).to.have.length(1)
    expect(dialer.tokens).to.have.length(Constants.MAX_PARALLEL_DIALS - 1)
@ -110,7 +107,7 @@ describe('Dialing (direct, WebSockets)', () => {
  })

  it('should fail to connect to an unsupported multiaddr', async () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({ transportManager: localTM })

    await expect(dialer.connectToPeer(unsupportedAddr))
      .to.eventually.be.rejectedWith(AggregateError)
@ -371,19 +368,6 @@ describe('Dialing (direct, WebSockets)', () => {
      expect(connection.stat.timeline.close).to.exist()
    })

-    it('should be able to use hangup when no connection exists', async () => {
-      libp2p = new Libp2p({
-        peerInfo,
-        modules: {
-          transport: [Transport],
-          streamMuxer: [Muxer],
-          connEncryption: [Crypto]
-        }
-      })
-
-      await libp2p.hangUp(remoteAddr)
-    })
-
    it('should abort pending dials on stop', async () => {
      libp2p = new Libp2p({
        peerInfo,
--- a/test/dialing/relay.node.js
+++ b/test/dialing/relay.node.js
@ -1,7 +1,6 @@
 'use strict'
 /* eslint-env mocha */

-const { Buffer } = require('buffer')
 const chai = require('chai')
 chai.use(require('dirty-chai'))
 chai.use(require('chai-as-promised'))
@ -124,10 +123,11 @@ describe('Dialing (via relay, TCP)', () => {
  })

  it('dialer should stay connected to an already connected relay on hop failure', async () => {
+    const relayAddr = relayLibp2p.transportManager.getAddrs()[0]
    const relayIdString = relayLibp2p.peerInfo.id.toB58String()
-    const relayAddr = relayLibp2p.transportManager.getAddrs()[0].encapsulate(`/p2p/${relayIdString}`)

    const dialAddr = relayAddr
+      .encapsulate(`/p2p/${relayIdString}`)
      .encapsulate(`/p2p-circuit/p2p/${dstLibp2p.peerInfo.id.toB58String()}`)

    await srcLibp2p.dial(relayAddr)
@ -142,15 +142,16 @@ describe('Dialing (via relay, TCP)', () => {
  })

  it('destination peer should stay connected to an already connected relay on hop failure', async () => {
+    const relayAddr = relayLibp2p.transportManager.getAddrs()[0]
    const relayIdString = relayLibp2p.peerInfo.id.toB58String()
-    const relayAddr = relayLibp2p.transportManager.getAddrs()[0].encapsulate(`/p2p/${relayIdString}`)

    const dialAddr = relayAddr
+      .encapsulate(`/p2p/${relayIdString}`)
      .encapsulate(`/p2p-circuit/p2p/${dstLibp2p.peerInfo.id.toB58String()}`)

    // Connect the destination peer and the relay
    const tcpAddrs = dstLibp2p.transportManager.getAddrs()
-    await dstLibp2p.transportManager.listen([multiaddr(`${relayAddr}/p2p-circuit`)])
+    await dstLibp2p.transportManager.listen([multiaddr(`/p2p-circuit${relayAddr}/p2p/${relayIdString}`)])
    expect(dstLibp2p.transportManager.getAddrs()).to.have.deep.members([...tcpAddrs, dialAddr.decapsulate('p2p')])

    // Tamper with the our multiaddrs for the circuit message
--- a/test/identify/index.spec.js
+++ b/test/identify/index.spec.js
@ -12,7 +12,6 @@ const PeerId = require('peer-id')
 const PeerInfo = require('peer-info')
 const duplexPair = require('it-pair/duplex')
 const multiaddr = require('multiaddr')
-const pWaitFor = require('p-wait-for')

 const { codes: Errors } = require('../../src/errors')
 const { IdentifyService, multicodecs } = require('../../src/identify')
@ -204,17 +203,16 @@ describe('Identify', () => {
      })

      sinon.spy(libp2p.identifyService, 'identify')
-      const peerStoreSpy = sinon.spy(libp2p.peerStore, 'replace')
+      sinon.spy(libp2p.peerStore, 'replace')

      const connection = await libp2p.dialer.connectToPeer(remoteAddr)
      expect(connection).to.exist()
-
-      // Wait for peer store to be updated
-      await pWaitFor(() => peerStoreSpy.callCount === 1)
+      // Wait for nextTick to trigger the identify call
+      await delay(1)
      expect(libp2p.identifyService.identify.callCount).to.equal(1)
+      await libp2p.identifyService.identify.firstCall.returnValue

-      // The connection should have no open streams
-      expect(connection.streams).to.have.length(0)
+      expect(libp2p.peerStore.replace.callCount).to.equal(1)
      await connection.close()
    })

@ -249,9 +247,6 @@ describe('Identify', () => {
        const results = await call.returnValue
        expect(results.length).to.equal(1)
      }
-
-      // Verify the streams close
-      await pWaitFor(() => connection.streams.length === 0)
    })
  })
 })
--- a/test/insecure/plaintext.spec.js
+++ b/test/insecure/plaintext.spec.js
@ -1,7 +1,6 @@
 'use strict'
 /* eslint-env mocha */

-const { Buffer } = require('buffer')
 const chai = require('chai')
 chai.use(require('dirty-chai'))
 const { expect } = chai
--- a/test/peer-discovery/index.node.js
+++ b/test/peer-discovery/index.node.js
@ -3,8 +3,7 @@

 const chai = require('chai')
 chai.use(require('dirty-chai'))
-const { expect } = chai
-const sinon = require('sinon')
+
 const defer = require('p-defer')
 const mergeOptions = require('merge-options')

@ -33,21 +32,6 @@ describe('peer discovery scenarios', () => {
  afterEach(async () => {
    libp2p && await libp2p.stop()
  })
-  it('should ignore self on discovery', async () => {
-    libp2p = new Libp2p(mergeOptions(baseOptions, {
-      peerInfo,
-      modules: {
-        peerDiscovery: [MulticastDNS]
-      }
-    }))
-
-    await libp2p.start()
-    const discoverySpy = sinon.spy()
-    libp2p.on('peer:discovery', discoverySpy)
-    libp2p._discovery.get('mdns').emit('peer', libp2p.peerInfo)
-
-    expect(discoverySpy.called).to.eql(false)
-  })

  it('bootstrap should discover all peers in the list', async () => {
    const deferred = defer()
@ -155,21 +139,17 @@ describe('peer discovery scenarios', () => {
        },
        dht: {
          randomWalk: {
-            enabled: false,
+            enabled: true,
            delay: 1000, // start the first query quickly
            interval: 10000,
-            timeout: 5000
+            timeout: 1000
          },
          enabled: true
        }
      }
    })

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

@ -181,7 +161,6 @@ describe('peer discovery scenarios', () => {
    })

    await Promise.all([
-      libp2p.start(),
      remoteLibp2p1.start(),
      remoteLibp2p2.start()
    ])
@ -194,6 +173,8 @@ describe('peer discovery scenarios', () => {
      remoteLibp2p2.dial(remotePeerInfo1)
    ])

+    libp2p.start()
+
    await deferred.promise
    return Promise.all([
      remoteLibp2p1.stop(),
--- a/test/peer-discovery/index.spec.js
+++ b/test/peer-discovery/index.spec.js
@ -9,6 +9,7 @@ const sinon = require('sinon')
 const defer = require('p-defer')
 const mergeOptions = require('merge-options')

+const MulticastDNS = require('libp2p-mdns')
 const WebRTCStar = require('libp2p-webrtc-star')

 const Libp2p = require('../../src')
@ -49,6 +50,22 @@ describe('peer discovery', () => {
      expect(spy.getCall(0).args).to.eql([remotePeerInfo])
    })

+    it('should ignore self on discovery', async () => {
+      libp2p = new Libp2p(mergeOptions(baseOptions, {
+        peerInfo,
+        modules: {
+          peerDiscovery: [MulticastDNS]
+        }
+      }))
+
+      await libp2p.start()
+      const discoverySpy = sinon.spy()
+      libp2p.on('peer:discovery', discoverySpy)
+      libp2p._discovery.get('mdns').emit('peer', libp2p.peerInfo)
+
+      expect(discoverySpy.called).to.eql(false)
+    })
+
    it('should stop discovery on libp2p start/stop', async () => {
      const mockDiscovery = {
        tag: 'mock',
--- a/test/peer-routing/peer-routing.node.js
+++ b/test/peer-routing/peer-routing.node.js
@ -115,7 +115,9 @@ describe('peer-routing', () => {
      const peerKey = 'QmTp9VkYvnHyrqKQuFPiuZkiX9gPcqj6x5LJ1rmWuSySnL'
      const mockApi = nock('http://0.0.0.0:60197')
        .post('/api/v0/dht/findpeer')
-        .query(true)
+        .query({
+          arg: peerKey
+        })
        .reply(200, `{"Extra":"","ID":"some other id","Responses":null,"Type":0}\n{"Extra":"","ID":"","Responses":[{"Addrs":["/ip4/127.0.0.1/tcp/4001"],"ID":"${peerKey}"}],"Type":2}\n`, [
          'Content-Type', 'application/json',
          'X-Chunked-Output', '1'
@ -131,7 +133,9 @@ describe('peer-routing', () => {
      const peerKey = 'key of a peer not on the network'
      const mockApi = nock('http://0.0.0.0:60197')
        .post('/api/v0/dht/findpeer')
-        .query(true)
+        .query({
+          arg: peerKey
+        })
        .reply(200, '{"Extra":"","ID":"some other id","Responses":null,"Type":6}\n{"Extra":"","ID":"yet another id","Responses":null,"Type":0}\n{"Extra":"routing:not found","ID":"","Responses":null,"Type":3}\n', [
          'Content-Type', 'application/json',
          'X-Chunked-Output', '1'
@ -147,7 +151,9 @@ describe('peer-routing', () => {
      const peerKey = 'key of a peer not on the network'
      const mockApi = nock('http://0.0.0.0:60197')
        .post('/api/v0/dht/findpeer')
-        .query(true)
+        .query({
+          arg: peerKey
+        })
        .reply(502)

      await expect(node.peerRouting.findPeer(peerKey))
--- a/test/peer-store/peer-store.spec.js
+++ b/test/peer-store/peer-store.spec.js
@ -160,27 +160,6 @@ describe('peer-store', () => {
    expect(removed).to.eql(true)
    expect(peerStore.peers.size).to.equal(0)
  })
-
-  it('should be able to get the multiaddrs for a peer', async () => {
-    const [peerInfo, relayInfo] = await peerUtils.createPeerInfo({ number: 2 })
-    const id = peerInfo.id
-    const ma1 = multiaddr('/ip4/127.0.0.1/tcp/4001')
-    const ma2 = multiaddr('/ip4/127.0.0.1/tcp/4002/ws')
-    const ma3 = multiaddr(`/ip4/127.0.0.1/tcp/4003/ws/p2p/${relayInfo.id.toB58String()}/p2p-circuit`)
-
-    peerInfo.multiaddrs.add(ma1)
-    peerInfo.multiaddrs.add(ma2)
-    peerInfo.multiaddrs.add(ma3)
-
-    const multiaddrs = peerStore.multiaddrsForPeer(peerInfo)
-    const expectedAddrs = [
-      ma1.encapsulate(`/p2p/${id.toB58String()}`),
-      ma2.encapsulate(`/p2p/${id.toB58String()}`),
-      ma3.encapsulate(`/p2p/${id.toB58String()}`)
-    ]
-
-    expect(multiaddrs).to.eql(expectedAddrs)
-  })
 })

 describe('peer-store on discovery', () => {
--- a/test/pnet/index.spec.js
+++ b/test/pnet/index.spec.js
@ -1,7 +1,6 @@
 /* eslint-env mocha */
 'use strict'

-const { Buffer } = require('buffer')
 const chai = require('chai')
 const dirtyChai = require('dirty-chai')
 chai.use(dirtyChai)
--- a/test/pubsub/implementations.node.js
+++ b/test/pubsub/implementations.node.js
@ -26,6 +26,7 @@ const remoteListenAddr = multiaddr('/ip4/127.0.0.1/tcp/0')
 describe('Pubsub subsystem is able to use different implementations', () => {
  let peerInfo, remotePeerInfo
  let libp2p, remoteLibp2p
+  let remAddr

  beforeEach(async () => {
    [peerInfo, remotePeerInfo] = await peerUtils.createPeerInfo({ number: 2 })
@ -72,8 +73,9 @@ describe('Pubsub subsystem is able to use different implementations', () => {
    ])

    const libp2pId = libp2p.peerInfo.id.toB58String()
+    remAddr = remoteLibp2p.transportManager.getAddrs()[0]

-    const connection = await libp2p.dialProtocol(remotePeerInfo, multicodec)
+    const connection = await libp2p.dialProtocol(remAddr, multicodec)
    expect(connection).to.exist()

    libp2p.pubsub.subscribe(topic, (msg) => {
--- a/test/pubsub/operation.node.js
+++ b/test/pubsub/operation.node.js
@ -21,6 +21,7 @@ const remoteListenAddr = multiaddr('/ip4/127.0.0.1/tcp/0')
 describe('Pubsub subsystem operates correctly', () => {
  let peerInfo, remotePeerInfo
  let libp2p, remoteLibp2p
+  let remAddr

  beforeEach(async () => {
    [peerInfo, remotePeerInfo] = await peerUtils.createPeerInfo({ number: 2 })
@ -43,6 +44,8 @@ describe('Pubsub subsystem operates correctly', () => {
        libp2p.start(),
        remoteLibp2p.start()
      ])
+
+      remAddr = remoteLibp2p.transportManager.getAddrs()[0]
    })

    afterEach(() => Promise.all([
@ -55,7 +58,7 @@ describe('Pubsub subsystem operates correctly', () => {
    })

    it('should get notified of connected peers on dial', async () => {
-      const connection = await libp2p.dialProtocol(remotePeerInfo, subsystemMulticodecs)
+      const connection = await libp2p.dialProtocol(remAddr, subsystemMulticodecs)

      expect(connection).to.exist()

@ -71,7 +74,7 @@ describe('Pubsub subsystem operates correctly', () => {
      const data = 'hey!'
      const libp2pId = libp2p.peerInfo.id.toB58String()

-      await libp2p.dialProtocol(remotePeerInfo, subsystemMulticodecs)
+      await libp2p.dialProtocol(remAddr, subsystemMulticodecs)

      let subscribedTopics = libp2p.pubsub.getTopics()
      expect(subscribedTopics).to.not.include(topic)
@ -112,6 +115,8 @@ describe('Pubsub subsystem operates correctly', () => {

      await libp2p.start()
      await remoteLibp2p.start()
+
+      remAddr = remoteLibp2p.transportManager.getAddrs()[0]
    })

    afterEach(() => Promise.all([
@ -124,7 +129,7 @@ describe('Pubsub subsystem operates correctly', () => {
    })

    it('should get notified of connected peers after starting', async () => {
-      const connection = await libp2p.dial(remotePeerInfo)
+      const connection = await libp2p.dial(remAddr)

      expect(connection).to.exist()
      expect(libp2p.pubsub._pubsub.peers.size).to.be.eql(0)
@ -145,7 +150,7 @@ describe('Pubsub subsystem operates correctly', () => {
      const topic = 'test-topic'
      const data = 'hey!'

-      await libp2p.dial(remotePeerInfo)
+      await libp2p.dial(remAddr)

      remoteLibp2p.pubsub.start()

--- a/test/registrar/registrar.node.js
+++ b/test/registrar/registrar.node.js
@ -29,7 +29,7 @@ describe('registrar on dial', () => {
    }))

    await remoteLibp2p.transportManager.listen([listenAddr])
-    remoteAddr = remoteLibp2p.transportManager.getAddrs()[0].encapsulate(`/p2p/${remotePeerInfo.id.toB58String()}`)
+    remoteAddr = remoteLibp2p.transportManager.getAddrs()[0]
  })

  after(async () => {
--- a/test/upgrading/upgrader.spec.js
+++ b/test/upgrading/upgrader.spec.js
@ -1,7 +1,6 @@
 'use strict'
 /* eslint-env mocha */

-const { Buffer } = require('buffer')
 const chai = require('chai')
 chai.use(require('dirty-chai'))
 const { expect } = chai