chore: add rendezvous example

feat: rendezvous client
chore: add discovery example with relay and pubsub
2025-07-24 04:51:56 +00:00 · 2021-01-19 11:51:31 +01:00 · 2021-01-19 11:08:51 +01:00 · 2021-01-19 11:08:51 +01:00
259 changed files with 5943 additions and 13352 deletions
--- a/.aegir.js
+++ b/.aegir.js
@@ -1,13 +1,12 @@
 'use strict'

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

@@ -32,9 +31,6 @@ const before = async () => {
          enabled: true,
          active: false
        }
-      },
-      nat: {
-        enabled: false
      }
    }
  })
@@ -48,23 +44,16 @@ const after = async () => {
  await libp2p.stop()
 }

-/** @type {import('aegir').Options["build"]["config"]} */
-const esbuild = {
-  inject: [path.join(__dirname, './scripts/node-globals.js')]
-}
-
-/** @type {import('aegir').PartialOptions} */
 module.exports = {
-  build: {
-    bundlesizeMax: '253kB'
+  bundlesize: { maxSize: '225kB' },
+  hooks: {
+    pre: before,
+    post: after
  },
-  test: {
-    before,
-    after,
-    browser: {
-      config: {
-        buildConfig: esbuild
-      }
+  webpack: {
+    node: {
+      // needed by bcrypto
+      Buffer: true
    }
  }
 }
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,5 +0,0 @@
-blank_issues_enabled: false
-contact_links:
- - name: libp2p Official Forum
-   url: https://discuss.libp2p.io
-   about: For general questions, support requests and discussions
--- a/.github/ISSUE_TEMPLATE/open_an_issue.md
+++ b/.github/ISSUE_TEMPLATE/open_an_issue.md
@@ -1,55 +0,0 @@
---
-name: Open an issue
-about: For reporting bugs or errors in the JavaScript libp2p implementation
-title: ''
-labels: need/triage
-assignees: ''
---
-
-<!--
-Thank you for reporting an issue.
-
-This issue tracker is for bugs found within the JavaScript implementation of libp2p.
-
-If you are asking a question about how to use libp2p, please ask on https://discuss.libp2p.io
-
-Otherwise please fill in as much of the template below as possible.
-->
-
- **Version**:
-<!--
-Check package.json version
-->
-
- **Platform**:
-<!--
-Output of `uname -a` (UNIX), or version and 32 or 64-bit (Windows). If using in a Browser, please share the browser version as well
-->
-
- **Subsystem**:
-<!--
-If known, please specify affected core module name (e.g Dialer, Pubsub, Relay etc)
-->
-
-#### Severity:
-<!--
-One of following:
-  Critical - System crash, application panic.
-  High - The main functionality of the application does not work, API breakage, repo format breakage, etc.
-  Medium - A non-essential functionality does not work, performance issues, etc.
-  Low - An optional functionality does not work.
-  Very Low - Translation or documentation mistake. Something that won't give anyone a bad day.
-->
-
-#### Description:
-<!--
- What you did
- What happened
- What you expected to happen
-->
-
-#### Steps to reproduce the error:
-<!--
-If possible, please provide code that demonstrates the problem, keeping it as simple and free of external dependencies as you are able
-->
-
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -1,8 +0,0 @@
-version: 2
-updates:
- package-ecosystem: npm
-  directory: "/"
-  schedule:
-    interval: daily
-    time: "11:00"
-  open-pull-requests-limit: 10
--- a/.github/workflows/examples.yml
+++ b/.github/workflows/examples.yml
@@ -1,66 +0,0 @@
-name: examples
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - '**'
-
-jobs:
-
-  build:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - uses: actions/setup-node@v2
-      with:
-        node-version: lts/*
-    - uses: ipfs/aegir/actions/cache-node-modules@master
-      with:
-        directories: |
-          ./examples/node_modules
-          ~/.cache
-        build: |
-          cd examples
-          npm i
-          npx playwright install
-        cache_name: cache-examples
-
-  test-example:
-    needs: build
-    runs-on: ubuntu-latest
-    strategy:
-      matrix:
-        example: [
-          chat,
-          connection-encryption,
-          discovery-mechanisms,
-          echo,
-          libp2p-in-the-browser,
-          peer-and-content-routing,
-          pnet,
-          protocol-and-stream-muxing,
-          pubsub,
-          transports,
-          webrtc-direct
-        ]
-      fail-fast: true
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: lts/*
-      - uses: ipfs/aegir/actions/cache-node-modules@master
-        with:
-          directories: |
-            ./examples/node_modules
-            ~/.cache
-          build: |
-            cd examples
-            npm i
-            npx playwright install
-          cache_name: cache-examples
-      - run: |
-          cd examples
-          npm run test -- ${{ matrix.example }}
--- a/.github/workflows/main.yml
+++ b/.github/workflows/main.yml
@@ -8,163 +8,81 @@ on:
      - '**'

 jobs:
-  build:
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest]
-        node: [16]
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: 16
-      - uses: ipfs/aegir/actions/cache-node-modules@master
-
  check:
-    needs: build
    runs-on: ubuntu-latest
    steps:
    - uses: actions/checkout@v2
-    - uses: actions/setup-node@v2
-      with:
-        node-version: lts/*
-    - uses: ipfs/aegir/actions/cache-node-modules@master
-    - run: npx aegir lint
-    - run: npx aegir dep-check
+    - run: yarn
+    - run: yarn lint
+    - uses: gozala/typescript-error-reporter-action@v1.0.8
+    - run: yarn build
+    - run: yarn aegir dep-check
    - uses: ipfs/aegir/actions/bundle-size@master
      name: size
      with:
        github_token: ${{ secrets.GITHUB_TOKEN }}
-
  test-node:
-    needs: build
+    needs: check
    runs-on: ${{ matrix.os }}
    strategy:
      matrix:
        os: [windows-latest, ubuntu-latest, macos-latest]
-        node: [16]
+        node: [12, 14]
      fail-fast: true
    steps:
      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
+      - uses: actions/setup-node@v1
        with:
          node-version: ${{ matrix.node }}
-      - uses: ipfs/aegir/actions/cache-node-modules@master
-      - run: npm run test:node -- --cov --bail
-      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
-        with:
-          directory: ./.nyc_output
-          flags: node
-
+      - run: yarn
+      - run: npx nyc --reporter=lcov aegir test -t node -- --bail
+      - uses: codecov/codecov-action@v1
  test-chrome:
-    needs: build
+    needs: check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: lts/*
-      - uses: ipfs/aegir/actions/cache-node-modules@master
-      - run: npm run test:browser -- -t browser --cov --bail
-      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
-        with:
-          directory: ./.nyc_output
-          flags: chrome
-
-  test-chrome-webworker:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: lts/*
-      - uses: ipfs/aegir/actions/cache-node-modules@master
-      - run: npm run test:browser -- -t webworker --bail
-      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
-        with:
-          directory: ./.nyc_output
-          flags: chrome-webworker
-
+      - run: yarn
+      - run: npx aegir test -t browser -t webworker --bail
  test-firefox:
-    needs: build
+    needs: check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: lts/*
-      - uses: ipfs/aegir/actions/cache-node-modules@master
-      - run: npm run test:browser -- -t browser --bail -- --browser firefox
-      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
-        with:
-          directory: ./.nyc_output
-          flags: firefox
-
-  test-firefox-webworker:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: lts/*
-      - uses: ipfs/aegir/actions/cache-node-modules@master
-      - run: npm run test:browser -- -t webworker --bail -- --browser firefox
-      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
-        with:
-          directory: ./.nyc_output
-          flags: firefox-webworker
-
-  test-ts:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: lts/*
-      - uses: ipfs/aegir/actions/cache-node-modules@master
-      - run: npm run test:ts
-
+      - run: yarn
+      - run: npx aegir test -t browser -t webworker --bail -- --browsers FirefoxHeadless
  test-interop:
-    needs: build
+    needs: check
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: lts/*
-      - uses: ipfs/aegir/actions/cache-node-modules@master
-      - run: npm run test:interop -- --bail -- --exit
-
-  release:
+      - run: yarn
+      - run: cd node_modules/interop-libp2p && yarn && LIBP2P_JS=${GITHUB_WORKSPACE}/src/index.js npx aegir test -t node --bail
+  test-auto-relay-example:
+    needs: check
    runs-on: ubuntu-latest
-    needs: [test-node, test-chrome, test-chrome-webworker, test-firefox, test-firefox-webworker, test-ts, test-interop]
-    if: github.event_name == 'push' && github.ref == 'refs/heads/master'
    steps:
-      - uses: GoogleCloudPlatform/release-please-action@v2
-        id: release
-        with:
-          token: ${{ secrets.GITHUB_TOKEN }}
-          release-type: node
-          bump-minor-pre-major: true
      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
-        with:
-          node-version: lts/*
-          registry-url: 'https://registry.npmjs.org'
-      - uses: ipfs/aegir/actions/cache-node-modules@master
-      - if: ${{ steps.release.outputs.release_created }}
-        name: Run release version
-        run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
-      - if: ${{ !steps.release.outputs.release_created }}
-        name: Run release rc
-        run: |
-            npm version `node -p -e "require('./package.json').version"`-`git rev-parse --short HEAD` --no-git-tag-version
-            npm publish --tag next
-        env:
-          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- auto-relay
+  test-chat-example:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- chat
+  test-libp2p-in-the-browser-example:
+    needs: check
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- libp2p-in-the-browser
+  test-discovery-mechanisms-example:
+    needs: check
+    runs-on: macos-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- discovery-mechanisms
--- a/.gitignore
+++ b/.gitignore
@@ -4,7 +4,6 @@ docs
 test/repo-tests*
 **/bundle.js
 .cache
-.parcel-cache

 # Logs
 logs
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,497 +1,3 @@
-## [0.35.8](https://github.com/libp2p/js-libp2p/compare/v0.35.7...v0.35.8) (2021-12-29)
-
-
-### Bug Fixes
-
-* do not wait for autodial start ([#1089](https://github.com/libp2p/js-libp2p/issues/1089)) ([79b3cfc](https://github.com/libp2p/js-libp2p/commit/79b3cfc6ad02ecc76fe23a3c3ff2d0b32a0ae4a8))
-* increase listeners on any-signal ([#1084](https://github.com/libp2p/js-libp2p/issues/1084)) ([f18fc80](https://github.com/libp2p/js-libp2p/commit/f18fc80b70bf7b6b26fffa70b0a8d0502a6c4801))
-* look for final peer event instead of peer response ([#1092](https://github.com/libp2p/js-libp2p/issues/1092)) ([d2b7ec0](https://github.com/libp2p/js-libp2p/commit/d2b7ec0f6be0ee80f2c963279a8ec2385059a889))
-* record tracked map clears ([#1085](https://github.com/libp2p/js-libp2p/issues/1085)) ([b4b4324](https://github.com/libp2p/js-libp2p/commit/b4b432406ebc08ef2fc3a1922c64cde7c9060cae))
-
-
-
-### [0.36.1](https://www.github.com/libp2p/js-libp2p/compare/v0.36.0...v0.36.1) (2022-01-25)
-
-
-### Bug Fixes
-
-* await unhandle of protocols ([#1144](https://www.github.com/libp2p/js-libp2p/issues/1144)) ([d44bd90](https://www.github.com/libp2p/js-libp2p/commit/d44bd9094fe9545054eb8eff68f81bc52ece03e7))
-
-## [0.36.0](https://www.github.com/libp2p/js-libp2p/compare/v0.35.8...v0.36.0) (2022-01-25)
-
-
-### ⚠ BREAKING CHANGES
-
-* abort-controller dep is gone from dependency tree
-* `libp2p.handle`, `libp2p.registrar.register` and the peerstore methods have become async
-
-### Features
-
-* add fetch protocol ([#1036](https://www.github.com/libp2p/js-libp2p/issues/1036)) ([d8ceb0b](https://www.github.com/libp2p/js-libp2p/commit/d8ceb0bc66fe225d1335d3f05b9a3a30983c2a57))
-* async peerstore backed by datastores ([#1058](https://www.github.com/libp2p/js-libp2p/issues/1058)) ([978eb36](https://www.github.com/libp2p/js-libp2p/commit/978eb3676fad5d5d50ddb28d1a7868f448cbb20b))
-* connection gater ([#1142](https://www.github.com/libp2p/js-libp2p/issues/1142)) ([ff32eba](https://www.github.com/libp2p/js-libp2p/commit/ff32eba6a0fa222af1a7a46775d5e0346ad6ebdf))
-
-
-### Bug Fixes
-
-* cache build artefacts ([#1091](https://www.github.com/libp2p/js-libp2p/issues/1091)) ([5043cd5](https://www.github.com/libp2p/js-libp2p/commit/5043cd56435a264e83db4fb8388d33e9a0442fff))
-* catch errors during identify ([#1138](https://www.github.com/libp2p/js-libp2p/issues/1138)) ([12f1bb0](https://www.github.com/libp2p/js-libp2p/commit/12f1bb0aeec4b639bd2af05807215f3b4284e379))
-* import uint8arrays package in example ([#1083](https://www.github.com/libp2p/js-libp2p/issues/1083)) ([c3700f5](https://www.github.com/libp2p/js-libp2p/commit/c3700f55d5a0b62182d683ca37258887b24065b9))
-* make tests more reliable ([#1139](https://www.github.com/libp2p/js-libp2p/issues/1139)) ([b7e8706](https://www.github.com/libp2p/js-libp2p/commit/b7e87066a69970f1adca4ba552c7fdf624916a7e))
-* prevent auto-dialer from dialing self ([#1104](https://www.github.com/libp2p/js-libp2p/issues/1104)) ([9b22c6e](https://www.github.com/libp2p/js-libp2p/commit/9b22c6e2f987a20c6639cd07f31fe9c824e24923))
-* remove abort-controller dep ([#1095](https://www.github.com/libp2p/js-libp2p/issues/1095)) ([0a4dc54](https://www.github.com/libp2p/js-libp2p/commit/0a4dc54d084c901df47cce1788bd5922090ee037))
-* try all peer addresses when dialing a relay ([#1140](https://www.github.com/libp2p/js-libp2p/issues/1140)) ([63aa480](https://www.github.com/libp2p/js-libp2p/commit/63aa480800974515f44d3b7e013da9c8ccaae8ad))
-* update any-signal and timeout-abort-controller ([#1128](https://www.github.com/libp2p/js-libp2p/issues/1128)) ([e0354b4](https://www.github.com/libp2p/js-libp2p/commit/e0354b4c6b95bb90656b868849182eb3efddf096))
-* update multistream select ([#1136](https://www.github.com/libp2p/js-libp2p/issues/1136)) ([00e4959](https://www.github.com/libp2p/js-libp2p/commit/00e49592a356e39b20c889d5f40b9bb37d4bf293))
-* update node-forge ([#1133](https://www.github.com/libp2p/js-libp2p/issues/1133)) ([a4bba35](https://www.github.com/libp2p/js-libp2p/commit/a4bba35948e1cd8dbe5147f2c8d6385b1fbb6fae))
-
-## [0.35.7](https://github.com/libp2p/js-libp2p/compare/v0.35.2...v0.35.7) (2021-12-24)
-
-
-### Bug Fixes
-
-* add tracked map ([#1069](https://github.com/libp2p/js-libp2p/issues/1069)) ([b425fa1](https://github.com/libp2p/js-libp2p/commit/b425fa12304def2a007d43a0aa445c28b766ed02))
-* clean up pending dial targets ([#1059](https://github.com/libp2p/js-libp2p/issues/1059)) ([bdc9f16](https://github.com/libp2p/js-libp2p/commit/bdc9f16d0cbe56ccf26822f11068e7795bcef046))
-* fix uncaught promise rejection when finding peers ([#1044](https://github.com/libp2p/js-libp2p/issues/1044)) ([3b683e7](https://github.com/libp2p/js-libp2p/commit/3b683e715686163e229b7b5c3a892327dfd4fc63))
-* increase the maxlisteners for timeout controllers ([#1065](https://github.com/libp2p/js-libp2p/issues/1065)) ([09a0f94](https://github.com/libp2p/js-libp2p/commit/09a0f940df7fdb4ece34604e85693709df5c213e))
-* main ci ([#1079](https://github.com/libp2p/js-libp2p/issues/1079)) ([d1c48dc](https://github.com/libp2p/js-libp2p/commit/d1c48dcbeded828f2dd3044cc9aed3f17f02846d))
-* make error codes consistent ([#1054](https://github.com/libp2p/js-libp2p/issues/1054)) ([b25e0fe](https://github.com/libp2p/js-libp2p/commit/b25e0fe5312db58a06c39500ae84c50fed3a93bd))
-* type definitions for big dialrequest and persistent peerstore ([#1078](https://github.com/libp2p/js-libp2p/issues/1078)) ([cb0d7d6](https://github.com/libp2p/js-libp2p/commit/cb0d7d6c99d179498f04e76df76e70e4f7d41c4c))
-
-
-### Features
-
-* allow per-component metrics to be collected ([#1061](https://github.com/libp2p/js-libp2p/issues/1061)) ([2f0b311](https://github.com/libp2p/js-libp2p/commit/2f0b311df7127aa44512c2008142d4ca30268986)), closes [#1060](https://github.com/libp2p/js-libp2p/issues/1060)
-
-
-
-## [0.35.6](https://github.com/libp2p/js-libp2p/compare/v0.35.5...v0.35.6) (2021-12-18)
-
-
-### Bug Fixes
-
-* increase the maxlisteners for timeout controllers ([#1065](https://github.com/libp2p/js-libp2p/issues/1065)) ([09a0f94](https://github.com/libp2p/js-libp2p/commit/09a0f940df7fdb4ece34604e85693709df5c213e))
-
-
-
-## [0.35.5](https://github.com/libp2p/js-libp2p/compare/v0.35.4...v0.35.5) (2021-12-15)
-
-
-
-## [0.35.4](https://github.com/libp2p/js-libp2p/compare/v0.35.3...v0.35.4) (2021-12-15)
-
-
-### Features
-
-* allow per-component metrics to be collected ([#1061](https://github.com/libp2p/js-libp2p/issues/1061)) ([2f0b311](https://github.com/libp2p/js-libp2p/commit/2f0b311df7127aa44512c2008142d4ca30268986)), closes [#1060](https://github.com/libp2p/js-libp2p/issues/1060)
-
-
-
-## [0.35.3](https://github.com/libp2p/js-libp2p/compare/v0.35.2...v0.35.3) (2021-12-13)
-
-
-### Bug Fixes
-
-* clean up pending dial targets ([#1059](https://github.com/libp2p/js-libp2p/issues/1059)) ([bdc9f16](https://github.com/libp2p/js-libp2p/commit/bdc9f16d0cbe56ccf26822f11068e7795bcef046))
-* fix uncaught promise rejection when finding peers ([#1044](https://github.com/libp2p/js-libp2p/issues/1044)) ([3b683e7](https://github.com/libp2p/js-libp2p/commit/3b683e715686163e229b7b5c3a892327dfd4fc63))
-* make error codes consistent ([#1054](https://github.com/libp2p/js-libp2p/issues/1054)) ([b25e0fe](https://github.com/libp2p/js-libp2p/commit/b25e0fe5312db58a06c39500ae84c50fed3a93bd))
-
-
-
-## [0.35.2](https://github.com/libp2p/js-libp2p/compare/v0.33.0...v0.35.2) (2021-12-06)
-
-
-### Bug Fixes
-
-* do not let closest peers run forever ([#1047](https://github.com/libp2p/js-libp2p/issues/1047)) ([91c2ec9](https://github.com/libp2p/js-libp2p/commit/91c2ec9856a3e972b7b2c9c4d9a4eda1d431c7ef))
-* increase maxlisteners on event target ([#1050](https://github.com/libp2p/js-libp2p/issues/1050)) ([b70fb43](https://github.com/libp2p/js-libp2p/commit/b70fb43427b47df079b55929ec8956f69cbda966)), closes [#900](https://github.com/libp2p/js-libp2p/issues/900)
-* private ip ts compile has no call signatures ([#1020](https://github.com/libp2p/js-libp2p/issues/1020)) ([77d7cb8](https://github.com/libp2p/js-libp2p/commit/77d7cb8f0815f2cdd3bfdfa8b641a7a186fe9520))
-* stop dht before connection manager ([#1041](https://github.com/libp2p/js-libp2p/issues/1041)) ([3a9d5f6](https://github.com/libp2p/js-libp2p/commit/3a9d5f64d96719ebb4d3b083c4f5832db4fa0816)), closes [#1039](https://github.com/libp2p/js-libp2p/issues/1039)
-
-
-### chore
-
-* update peer id and libp2p crypto ([#1042](https://github.com/libp2p/js-libp2p/issues/1042)) ([9cbf36f](https://github.com/libp2p/js-libp2p/commit/9cbf36fcb54099e6fed35ceccc4a2376f0926c1f))
-
-
-### Features
-
-* update dht ([#1009](https://github.com/libp2p/js-libp2p/issues/1009)) ([2f598eb](https://github.com/libp2p/js-libp2p/commit/2f598eba09cff4301474af08196158065e3602d8))
-
-
-### BREAKING CHANGES
-
-* requires node 15+
-* libp2p-kad-dht has a new event-based API which is exposed as `_dht`
-
-
-
-## [0.35.1](https://github.com/libp2p/js-libp2p/compare/v0.35.0...v0.35.1) (2021-12-03)
-
-
-### Bug Fixes
-
-* do not let closest peers run forever ([#1047](https://github.com/libp2p/js-libp2p/issues/1047)) ([91c2ec9](https://github.com/libp2p/js-libp2p/commit/91c2ec9856a3e972b7b2c9c4d9a4eda1d431c7ef))
-
-
-
-# [0.35.0](https://github.com/libp2p/js-libp2p/compare/v0.34.0...v0.35.0) (2021-12-02)
-
-
-### Bug Fixes
-
-* stop dht before connection manager ([#1041](https://github.com/libp2p/js-libp2p/issues/1041)) ([3a9d5f6](https://github.com/libp2p/js-libp2p/commit/3a9d5f64d96719ebb4d3b083c4f5832db4fa0816)), closes [#1039](https://github.com/libp2p/js-libp2p/issues/1039)
-
-
-### chore
-
-* update peer id and libp2p crypto ([#1042](https://github.com/libp2p/js-libp2p/issues/1042)) ([9cbf36f](https://github.com/libp2p/js-libp2p/commit/9cbf36fcb54099e6fed35ceccc4a2376f0926c1f))
-
-
-### BREAKING CHANGES
-
-* requires node 15+
-
-
-
-# [0.34.0](https://github.com/libp2p/js-libp2p/compare/v0.33.0...v0.34.0) (2021-11-25)
-
-
-### Bug Fixes
-
-* private ip ts compile has no call signatures ([#1020](https://github.com/libp2p/js-libp2p/issues/1020)) ([77d7cb8](https://github.com/libp2p/js-libp2p/commit/77d7cb8f0815f2cdd3bfdfa8b641a7a186fe9520))
-
-
-### Features
-
-* update dht ([#1009](https://github.com/libp2p/js-libp2p/issues/1009)) ([2f598eb](https://github.com/libp2p/js-libp2p/commit/2f598eba09cff4301474af08196158065e3602d8))
-
-
-### BREAKING CHANGES
-
-* libp2p-kad-dht has a new event-based API which is exposed as `_dht`
-
-
-
-# [0.33.0](https://github.com/libp2p/js-libp2p/compare/v0.32.5...v0.33.0) (2021-09-24)
-
-
-### chore
-
-* update datastore ([#990](https://github.com/libp2p/js-libp2p/issues/990)) ([83734ef](https://github.com/libp2p/js-libp2p/commit/83734ef52061ad61ddb5ca49aae27e3a8b937058))
-
-
-### BREAKING CHANGES
-
-* datastore implementations provided to libp2p must be compliant with interface-datastore@6.0.0
-
-
-
-## [0.32.5](https://github.com/libp2p/js-libp2p/compare/v0.32.4...v0.32.5) (2021-09-21)
-
-
-### Bug Fixes
-
-* move abortable-iterator to dependencies ([#992](https://github.com/libp2p/js-libp2p/issues/992)) ([122c89d](https://github.com/libp2p/js-libp2p/commit/122c89dd0df55a59edaae078e3dc7c31b5603715)), closes [#986](https://github.com/libp2p/js-libp2p/issues/986)
-
-
-
-## [0.32.4](https://github.com/libp2p/js-libp2p/compare/v0.32.3...v0.32.4) (2021-08-20)
-
-
-
-## [0.32.3](https://github.com/libp2p/js-libp2p/compare/v0.32.2...v0.32.3) (2021-08-16)
-
-
-### Bug Fixes
-
-* uint8arrays is a dep ([#964](https://github.com/libp2p/js-libp2p/issues/964)) ([ba2b4d4](https://github.com/libp2p/js-libp2p/commit/ba2b4d4b28f1d9940b457de344aed44537f9eabd))
-
-
-
-## [0.32.2](https://github.com/libp2p/js-libp2p/compare/v0.32.1...v0.32.2) (2021-08-13)
-
-
-### Bug Fixes
-
-* browser example ci ([3b33fb4](https://github.com/libp2p/js-libp2p/commit/3b33fb4b73ba8065e432fb59f758fe138fd23d9e))
-
-
-### Features
-
-* custom protocol name ([#962](https://github.com/libp2p/js-libp2p/issues/962)) ([ef24fab](https://github.com/libp2p/js-libp2p/commit/ef24fabf0269fd079888e92eedb458e23ef1c733))
-
-
-
-## [0.32.1](https://github.com/libp2p/js-libp2p/compare/v0.32.0...v0.32.1) (2021-07-22)
-
-
-### Bug Fixes
-
-* turn compliance tests into devDependency ([#960](https://github.com/libp2p/js-libp2p/issues/960)) ([0701de4](https://github.com/libp2p/js-libp2p/commit/0701de40b1ebdf319959846d8c4fdd30b3cf34a4))
-
-
-
-# [0.32.0](https://github.com/libp2p/js-libp2p/compare/v0.32.0-rc.0...v0.32.0) (2021-07-15)
-
-
-
-# [0.32.0-rc.0](https://github.com/libp2p/js-libp2p/compare/v0.31.7...v0.32.0-rc.0) (2021-07-09)
-
-
-### Bug Fixes
-
-* do not allow dial to large number of multiaddrs ([#954](https://github.com/libp2p/js-libp2p/issues/954)) ([af723b3](https://github.com/libp2p/js-libp2p/commit/af723b355e1ddf4aecf439f81c3aa67613d45fa4))
-
-
-### chore
-
-* update to new multiformats ([#948](https://github.com/libp2p/js-libp2p/issues/948)) ([13cf476](https://github.com/libp2p/js-libp2p/commit/13cf4761489d59b22924bb8ec2ec6dbe207b280c))
-
-
-### BREAKING CHANGES
-
-* uses the CID class from the new multiformats module
-
-Co-authored-by: Vasco Santos <vasco.santos@moxy.studio>
-
-
-
-## [0.31.7](https://github.com/libp2p/js-libp2p/compare/v0.31.6...v0.31.7) (2021-06-14)
-
-
-### Bug Fixes
-
-* chat example with new multiaddr ([#946](https://github.com/libp2p/js-libp2p/issues/946)) ([d8ba284](https://github.com/libp2p/js-libp2p/commit/d8ba2848833d9fb8a963d1b7c8d27062c6f829da))
-* dialer leaking resources after stopping ([#947](https://github.com/libp2p/js-libp2p/issues/947)) ([b291bc0](https://github.com/libp2p/js-libp2p/commit/b291bc06ec13feeb6e010730edfad754a3b2dc1b))
-
-
-
-## [0.31.6](https://github.com/libp2p/js-libp2p/compare/v0.31.5...v0.31.6) (2021-05-27)
-
-
-### Features
-
-* keychain rotate passphrase ([#944](https://github.com/libp2p/js-libp2p/issues/944)) ([478963a](https://github.com/libp2p/js-libp2p/commit/478963ad2d195444494c0acc54cb3847a29e117c))
-
-
-
-## [0.31.5](https://github.com/libp2p/js-libp2p/compare/v0.31.4...v0.31.5) (2021-05-12)
-
-
-### Bug Fixes
-
-* store remote agent and protocol version during identify ([#943](https://github.com/libp2p/js-libp2p/issues/943)) ([818d2b2](https://github.com/libp2p/js-libp2p/commit/818d2b2a98736f4242694479089396f6070cdad5))
-
-
-
-## [0.31.4](https://github.com/libp2p/js-libp2p/compare/v0.31.3...v0.31.4) (2021-05-12)
-
-
-### Bug Fixes
-
-* peerRouting.findPeer() trying to find self ([#941](https://github.com/libp2p/js-libp2p/issues/941)) ([a79c6b5](https://github.com/libp2p/js-libp2p/commit/a79c6b50d7fddbcdb1af53efae922cecad4c9a83))
-
-
-
-## [0.31.3](https://github.com/libp2p/js-libp2p/compare/v0.31.2...v0.31.3) (2021-05-04)
-
-
-
-## [0.31.2](https://github.com/libp2p/js-libp2p/compare/v0.31.1...v0.31.2) (2021-04-30)
-
-
-### Bug Fixes
-
-* moving averages record types ([#935](https://github.com/libp2p/js-libp2p/issues/935)) ([b5a9eb2](https://github.com/libp2p/js-libp2p/commit/b5a9eb208763efa027d0b4caae87c515b6f5869b))
-
-
-
-## [0.31.1](https://github.com/libp2p/js-libp2p/compare/v0.31.0...v0.31.1) (2021-04-30)
-
-
-### Bug Fixes
-
-* event emitter and interfaces types for discovery and routing ([#934](https://github.com/libp2p/js-libp2p/issues/934)) ([302bb90](https://github.com/libp2p/js-libp2p/commit/302bb9005891aa06b70a5f354bfac6b2d5a3c3b8))
-
-
-
-# [0.31.0](https://github.com/libp2p/js-libp2p/compare/v0.31.0-rc.7...v0.31.0) (2021-04-28)
-
-
-
-# [0.31.0-rc.7](https://github.com/libp2p/js-libp2p/compare/v0.31.0-rc.6...v0.31.0-rc.7) (2021-04-27)
-
-
-### Bug Fixes
-
-* address book guarantees no replicated entries are added ([#927](https://github.com/libp2p/js-libp2p/issues/927)) ([ac370fc](https://github.com/libp2p/js-libp2p/commit/ac370fc9679b51da8cee3791b6dd268d0695d136))
-
-
-
-# [0.31.0-rc.6](https://github.com/libp2p/js-libp2p/compare/v0.31.0-rc.5...v0.31.0-rc.6) (2021-04-22)
-
-
-### Bug Fixes
-
-* keychain optional pw and use interfaces for validators and selectors instead ([#924](https://github.com/libp2p/js-libp2p/issues/924)) ([88b0415](https://github.com/libp2p/js-libp2p/commit/88b04156bf614650c2b14d49b12e969c5eecf04d))
-
-
-
-# [0.31.0-rc.5](https://github.com/libp2p/js-libp2p/compare/v0.31.0-rc.4...v0.31.0-rc.5) (2021-04-21)
-
-
-### Bug Fixes
-
-* address book should not emit peer event if no addresses are known ([b4fb9b7](https://github.com/libp2p/js-libp2p/commit/b4fb9b7bf266ba03c4462c0a41b1c2691e4e88d4))
-* demand pubsub subclass instead of pubsub instance ([#922](https://github.com/libp2p/js-libp2p/issues/922)) ([086b0ec](https://github.com/libp2p/js-libp2p/commit/086b0ec0df2fac93845d0a0a6b2e2464e869afcd))
-* dht configuration selectors and validators ([#919](https://github.com/libp2p/js-libp2p/issues/919)) ([cc1f4af](https://github.com/libp2p/js-libp2p/commit/cc1f4af879a58e94538591851d0085ff98cd2641))
-
-
-
-# [0.31.0-rc.4](https://github.com/libp2p/js-libp2p/compare/v0.31.0-rc.3...v0.31.0-rc.4) (2021-04-20)
-
-
-### Bug Fixes
-
-* add clientMode dht arg and upgrade interface-datastore ([#918](https://github.com/libp2p/js-libp2p/issues/918)) ([975e779](https://github.com/libp2p/js-libp2p/commit/975e77991e67dd9bff790b83df7bd6fa5ddcfc67))
-* do not add abort signals to useless addresses ([#913](https://github.com/libp2p/js-libp2p/issues/913)) ([06e8f3d](https://github.com/libp2p/js-libp2p/commit/06e8f3dd42432e4b37ab7904b02abde7d1cadda3))
-* specify pbjs root ([#917](https://github.com/libp2p/js-libp2p/issues/917)) ([b043bca](https://github.com/libp2p/js-libp2p/commit/b043bca607565cf534771e6cf975288a8ff3030b))
-
-
-
-# [0.31.0-rc.3](https://github.com/libp2p/js-libp2p/compare/v0.31.0-rc.2...v0.31.0-rc.3) (2021-04-19)
-
-
-### Bug Fixes
-
-* remove inline arg types from function definitions ([#916](https://github.com/libp2p/js-libp2p/issues/916)) ([2af692f](https://github.com/libp2p/js-libp2p/commit/2af692fb4de572168524ae684608fc6526de4ef7))
-
-
-
-# [0.31.0-rc.2](https://github.com/libp2p/js-libp2p/compare/v0.31.0-rc.1...v0.31.0-rc.2) (2021-04-16)
-
-
-### Bug Fixes
-
-* metrics stats and moving averages types ([#915](https://github.com/libp2p/js-libp2p/issues/915)) ([3d0a79e](https://github.com/libp2p/js-libp2p/commit/3d0a79eff3bc34a5bdc8ffa31e9b09345a02ad9d))
-
-
-
-# [0.31.0-rc.1](https://github.com/libp2p/js-libp2p/compare/v0.31.0-rc.0...v0.31.0-rc.1) (2021-04-16)
-
-
-### Bug Fixes
-
-* dial protocol should throw if no protocol is provided ([#914](https://github.com/libp2p/js-libp2p/issues/914)) ([21c9aee](https://github.com/libp2p/js-libp2p/commit/21c9aeecb13440238aa6b0fb5a6731d2f87d4938))
-
-
-### BREAKING CHANGES
-
-* dialProtocol does not return connection when no protocols are provided
-
-
-
-# [0.31.0-rc.0](https://github.com/libp2p/js-libp2p/compare/v0.30.12...v0.31.0-rc.0) (2021-04-15)
-
-
-
-## [0.30.12](https://github.com/libp2p/js-libp2p/compare/v0.30.11...v0.30.12) (2021-03-27)
-
-
-### Bug Fixes
-
-* the API of es6-promisify is not the same as promisify-es6 ([#905](https://github.com/libp2p/js-libp2p/issues/905)) ([a7128f0](https://github.com/libp2p/js-libp2p/commit/a7128f07ec8d4b729145ecfc6ad1d585ffddea46))
-
-
-
-## [0.30.11](https://github.com/libp2p/js-libp2p/compare/v0.30.10...v0.30.11) (2021-03-23)
-
-
-### Bug Fixes
-
-* connection direction should be only inbound or outbound ([9504f19](https://github.com/libp2p/js-libp2p/commit/9504f1951a3cca55bb7b4e25e4934e4024034ee8))
-* interface-datastore update ([f5c1cd1](https://github.com/libp2p/js-libp2p/commit/f5c1cd1fb07bc73cf9d9da3c2eb4327bed4279a4))
-
-
-
-## [0.30.10](https://github.com/libp2p/js-libp2p/compare/v0.30.9...v0.30.10) (2021-03-09)
-
-
-### Bug Fixes
-
-* conn mgr access to moving averages record object ([#897](https://github.com/libp2p/js-libp2p/issues/897)) ([5f702f3](https://github.com/libp2p/js-libp2p/commit/5f702f3481afd4ad4fbc89f0e9b75a6d56b03520))
-
-
-
-## [0.30.9](https://github.com/libp2p/js-libp2p/compare/v0.30.8...v0.30.9) (2021-02-25)
-
-
-### Bug Fixes
-
-* transport manager fault tolerance should include tolerance to transport listen fail ([#893](https://github.com/libp2p/js-libp2p/issues/893)) ([3f314d5](https://github.com/libp2p/js-libp2p/commit/3f314d5e90f74583b721386d0c9c5d8363cd4de7))
-
-
-
-## [0.30.8](https://github.com/libp2p/js-libp2p/compare/v0.30.7...v0.30.8) (2021-02-11)
-
-
-### Bug Fixes
-
-* routers should only use dht if enabled ([#885](https://github.com/libp2p/js-libp2p/issues/885)) ([a34d2bb](https://github.com/libp2p/js-libp2p/commit/a34d2bbcc3d69ec3006137a909a7e8c53b9d378e))
-
-
-
-## [0.30.7](https://github.com/libp2p/js-libp2p/compare/v0.30.6...v0.30.7) (2021-02-01)
-
-
-### Bug Fixes
-
-* do not add observed address received from peers ([#882](https://github.com/libp2p/js-libp2p/issues/882)) ([a36b211](https://github.com/libp2p/js-libp2p/commit/a36b2112aafcee309a02de0cff5440cf69cd53a7))
-
-
-
-## [0.30.6](https://github.com/libp2p/js-libp2p/compare/v0.30.5...v0.30.6) (2021-01-29)
-
-
-### Bug Fixes
-
-* peer discovery type in config ([#878](https://github.com/libp2p/js-libp2p/issues/878)) ([3e7594f](https://github.com/libp2p/js-libp2p/commit/3e7594f69733bf374b374a6065458fa6cae81c5f))
-* unref nat manager retries ([#877](https://github.com/libp2p/js-libp2p/issues/877)) ([ce2a624](https://github.com/libp2p/js-libp2p/commit/ce2a624a09b3107c0b2b4752e666804ecea54fb5))
-
-
-
-## [0.30.5](https://github.com/libp2p/js-libp2p/compare/v0.30.4...v0.30.5) (2021-01-28)
-
-
-### Bug Fixes
-
-* create has optional peer id type ([#875](https://github.com/libp2p/js-libp2p/issues/875)) ([eeda056](https://github.com/libp2p/js-libp2p/commit/eeda05688330c17b810bf47544ef977386623317))
-
-
-
-## [0.30.4](https://github.com/libp2p/js-libp2p/compare/v0.30.3...v0.30.4) (2021-01-27)
-
-
-### Features
-
-* add UPnP NAT manager ([#810](https://github.com/libp2p/js-libp2p/issues/810)) ([0a6bc0d](https://github.com/libp2p/js-libp2p/commit/0a6bc0d1013dfd80ab600e8f74c1544b433ece29))
-
-
-
-## [0.30.3](https://github.com/libp2p/js-libp2p/compare/v0.30.2...v0.30.3) (2021-01-27)
-
-
-
-## [0.30.2](https://github.com/libp2p/js-libp2p/compare/v0.30.1...v0.30.2) (2021-01-21)
-
-
-### Bug Fixes
-
-* store multiaddrs during content and peer routing queries ([#865](https://github.com/libp2p/js-libp2p/issues/865)) ([45c3367](https://github.com/libp2p/js-libp2p/commit/45c33675a7412c66d0fd4e113ef8506077b6f492))
-
-
-
 ## [0.30.1](https://github.com/libp2p/js-libp2p/compare/v0.30.0...v0.30.1) (2021-01-18)


@@ -1796,3 +1302,6 @@ for subscribe to see how it should be used.

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

@@ -161,11 +161,13 @@ List of packages currently in existence for libp2p
 | **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) |
+| **service discovery** |
+| [`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/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) |
 | **utilities** |
 | [`libp2p-crypto`](//github.com/libp2p/js-libp2p-crypto) | [![npm](https://img.shields.io/npm/v/libp2p-crypto.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-crypto/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-crypto.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-crypto) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-crypto/master)](https://travis-ci.com/libp2p/js-libp2p-crypto) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-crypto/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-crypto) | [Jacob Heun](mailto:jacobheun@gmail.com) |
+| [`libp2p-crypto-secp256k1`](//github.com/libp2p/js-libp2p-crypto-secp256k1) | [![npm](https://img.shields.io/npm/v/libp2p-crypto-secp256k1.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-crypto-secp256k1/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-crypto-secp256k1.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-crypto-secp256k1) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-crypto-secp256k1/master)](https://travis-ci.com/libp2p/js-libp2p-crypto-secp256k1) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-crypto-secp256k1/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-crypto-secp256k1) | [Friedel Ziegelmayer](mailto:dignifiedquire@gmail.com) |
 | **data types** |
 | [`peer-id`](//github.com/libp2p/js-peer-id) | [![npm](https://img.shields.io/npm/v/peer-id.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-peer-id/releases) | [![Deps](https://david-dm.org/libp2p/js-peer-id.svg?style=flat-square)](https://david-dm.org/libp2p/js-peer-id) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-peer-id/master)](https://travis-ci.com/libp2p/js-peer-id) | [![codecov](https://codecov.io/gh/libp2p/js-peer-id/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-peer-id) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
-| [`libp2p-record`](//github.com/libp2p/js-libp2p-record) | [![npm](https://img.shields.io/npm/v/libp2p-record.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-record/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-record.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-record) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-record/master)](https://travis-ci.com/libp2p/js-libp2p-record) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-record/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-record) | [Jacob Heun](mailto:santos.vasco10@gmail.com) |
 | **pubsub** |
 | [`libp2p-floodsub`](//github.com/libp2p/js-libp2p-floodsub) | [![npm](https://img.shields.io/npm/v/libp2p-floodsub.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-floodsub/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-floodsub.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-floodsub) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-floodsub/master)](https://travis-ci.com/libp2p/js-libp2p-floodsub) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-floodsub/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-floodsub) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
 | [`libp2p-gossipsub`](//github.com/ChainSafe/js-libp2p-gossipsub) | [![npm](https://img.shields.io/npm/v/libp2p-gossipsub.svg?maxAge=86400&style=flat-square)](//github.com/ChainSafe/js-libp2p-gossipsub/releases) | [![Deps](https://david-dm.org/ChainSafe/js-libp2p-gossipsub.svg?style=flat-square)](https://david-dm.org/ChainSafe/js-libp2p-gossipsub) | [![Travis CI](https://flat.badgen.net/travis/ChainSafe/js-libp2p-gossipsub/master)](https://travis-ci.com/ChainSafe/js-libp2p-gossipsub) | [![codecov](https://codecov.io/gh/ChainSafe/js-libp2p-gossipsub/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/ChainSafe/js-libp2p-gossipsub) | [Cayman Nava](mailto:caymannava@gmail.com) |
--- a/.github/ISSUE_TEMPLATE/release.md
+++ b/.github/ISSUE_TEMPLATE/release.md
@@ -25,6 +25,8 @@
    - [ ] [js-ipfs](https://github.com/ipfs/js-ipfs)
 - Documentation
  - [ ] Ensure that README.md is up to date
+  - [ ] Ensure that all the examples run
+  - [ ] Ensure [libp2p/js-libp2p-examples](https://github.com/libp2p/js-libp2p-examples) is updated
  - [ ] Ensure that [libp2p/docs](https://github.com/libp2p/docs) is updated
 - Communication
  - [ ] Create the release issue
--- a/doc/API.md
+++ b/doc/API.md
@@ -3,7 +3,6 @@
 * [Static Functions](#static-functions)
  * [`create`](#create)
 * [Instance Methods](#libp2p-instance-methods)
-  * [`loadkeychain`](#loadkeychain)
  * [`start`](#start)
  * [`stop`](#stop)
  * [`dial`](#dial)
@@ -12,9 +11,6 @@
  * [`handle`](#handle)
  * [`unhandle`](#unhandle)
  * [`ping`](#ping)
-  * [`fetch`](#fetch)
-  * [`fetchService.registerLookupFunction`](#fetchserviceregisterlookupfunction)
-  * [`fetchService.unRegisterLookupFunction`](#fetchserviceunregisterlookupfunction)
  * [`multiaddrs`](#multiaddrs)
  * [`addressManager.getListenAddrs`](#addressmanagergetlistenaddrs)
  * [`addressManager.getAnnounceAddrs`](#addressmanagergetannounceaddrs)
@@ -55,6 +51,9 @@
  * [`pubsub.removeListener`](#pubsubremovelistener)
  * [`pubsub.topicValidators.set`](#pubsubtopicvalidatorsset)
  * [`pubsub.topicValidators.delete`](#pubsubtopicvalidatorsdelete)
+  * [`rendezvous.discover`](#rendezvousdiscover)
+  * [`rendezvous.register`](#rendezvousregister)
+  * [`rendezvous.unregister`](#rendezvousunregister)
  * [`connectionManager.get`](#connectionmanagerget)
  * [`connectionManager.setPeerValue`](#connectionmanagersetpeervalue)
  * [`connectionManager.size`](#connectionmanagersize)
@@ -458,72 +457,6 @@ Pings a given peer and get the operation's latency.
 const latency = await libp2p.ping(otherPeerId)
 ```

-## fetch
-
-Fetch a value from a remote node
-
-`libp2p.fetch(peer, key)`
-
-#### Parameters
-
-| Name | Type | Description |
-|------|------|-------------|
-| peer | [`PeerId`][peer-id]\|[`Multiaddr`][multiaddr]\|`string` | peer to ping |
-| key | `string` | A key that corresponds to a value on the remote node |
-
-#### Returns
-
-| Type | Description |
-|------|-------------|
-| `Promise<Uint8Array | null>` | The value for the key or null if it cannot be found |
-
-#### Example
-
-```js
-// ...
-const value = await libp2p.fetch(otherPeerId, '/some/key')
-```
-
-## fetchService.registerLookupFunction
-
-Register a function to look up values requested by remote nodes
-
-`libp2p.fetchService.registerLookupFunction(prefix, lookup)`
-
-#### Parameters
-
-| Name | Type | Description |
-|------|------|-------------|
-| prefix | `string` | All queries below this prefix will be passed to the lookup function |
-| lookup | `(key: string) => Promise<Uint8Array | null>` | A function that takes a key and returns a Uint8Array or null |
-
-#### Example
-
-```js
-// ...
-const value = await libp2p.fetchService.registerLookupFunction('/prefix', (key) => { ... })
-```
-
-## fetchService.unregisterLookupFunction
-
-Removes the passed lookup function or any function registered for the passed prefix
-
-`libp2p.fetchService.unregisterLookupFunction(prefix, lookup)`
-
-#### Parameters
-
-| Name | Type | Description |
-|------|------|-------------|
-| prefix | `string` | All queries below this prefix will be passed to the lookup function |
-| lookup | `(key: string) => Promise<Uint8Array | null>` | Optional: A function that takes a key and returns a Uint8Array or null |
-
-#### Example
-
-```js
-// ...
-libp2p.fetchService.unregisterLookupFunction('/prefix')
-```
-
 ## multiaddrs

 Gets the multiaddrs the libp2p node announces to the network. This computes the advertising multiaddrs
@@ -1670,6 +1603,88 @@ Get a connection with a given peer, if it exists.
 libp2p.connectionManager.get(peerId)
 ```

+### rendezvous.register
+
+Registers the peer in a given namespace.
+
+`rendezvous.register(namespace, [options])`
+
+#### Parameters
+
+| Name | Type | Description |
+|------|------|-------------|
+| namespace | `string` | namespace to register |
+| [options] | `Object` | rendezvous registrations options |
+| [options.ttl=7.2e6] | `number` | registration ttl in ms |
+
+#### Returns
+
+| Type | Description |
+|------|-------------|
+| `Promise<number>` | Remaining ttl value |
+
+#### Example
+
+```js
+// ...
+const ttl = await rendezvous.register(namespace)
+```
+
+### rendezvous.unregister
+
+Unregisters the peer from a given namespace.
+
+`rendezvous.unregister(namespace)`
+
+#### Parameters
+
+| Name | Type | Description |
+|------|------|-------------|
+| namespace | `string` | namespace to unregister |
+
+#### Returns
+
+| Type | Description |
+|------|-------------|
+| `Promise<void>` | Operation resolved |
+
+#### Example
+
+```js
+// ...
+await rendezvous.register(namespace)
+await rendezvous.unregister(namespace)
+```
+
+### rendezvous.discover
+
+Discovers peers registered under a given namespace.
+
+`rendezvous.discover(namespace, [limit])`
+
+#### Parameters
+
+| Name | Type | Description |
+|------|------|-------------|
+| namespace | `string` | namespace to discover |
+| limit | `number` | limit of peers to discover |
+
+#### Returns
+
+| Type | Description |
+|------|-------------|
+| `AsyncIterable<{ signedPeerRecord: Uint8Array, ns: string, ttl: number }>` | Async Iterable with registrations |
+
+#### Example
+
+```js
+// ...
+await rendezvous.register(namespace)
+for await (const reg of rendezvous.discover(namespace)) {
+  console.log(reg.signedPeerRecord, reg.ns, reg.ttl)
+}
+```
+
 ### connectionManager.setPeerValue

 Enables users to change the value of certain peers in a range of 0 to 1. Peers with the lowest values will have their Connections pruned first, if any Connection Manager limits are exceeded. See [./CONFIGURATION.md#configuring-connection-manager](./CONFIGURATION.md#configuring-connection-manager) for details on how to configure these limits.
@@ -2125,15 +2140,6 @@ This event will be triggered anytime we are disconnected from another peer, rega
 - `peerId`: instance of [`PeerId`][peer-id]
 - `protocols`: array of known, supported protocols for the peer (string identifiers)

-### libp2p.addressManager
-
-#### Our addresses have changed
-
-This could be in response to a peer telling us about addresses they have observed, or
-the NatManager performing NAT hole punching.
-
-`libp2p.addressManager.on('change:addresses', () => {})`
-
 ## Types

 ### Stats
@@ -2156,7 +2162,7 @@ the NatManager performing NAT hole punching.

 [address]: https://github.com/libp2p/js-libp2p/tree/master/src/peer-store/address-book.js
 [cid]: https://github.com/multiformats/js-cid
-[connection]: https://github.com/libp2p/js-libp2p-interfaces/tree/master/packages/interfaces/src/connection
+[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
 [keys]: https://github.com/libp2p/js-libp2p-crypto/tree/master/src/keys
--- a/doc/CONFIGURATION.md
+++ b/doc/CONFIGURATION.md
@@ -1,40 +1,35 @@
-#
+# Configuration

- [Overview](#overview)
- [Modules](#modules)
-  - [Transport](#transport)
-  - [Stream Multiplexing](#stream-multiplexing)
-  - [Connection Encryption](#connection-encryption)
-  - [Peer Discovery](#peer-discovery)
-  - [Content Routing](#content-routing)
-  - [Peer Routing](#peer-routing)
-  - [DHT](#dht)
-  - [Pubsub](#pubsub)
- [Customizing libp2p](#customizing-libp2p)
-  - [Examples](#examples)
-    - [Basic setup](#basic-setup)
-    - [Customizing Peer Discovery](#customizing-peer-discovery)
-    - [Setup webrtc transport and discovery](#setup-webrtc-transport-and-discovery)
-    - [Customizing Pubsub](#customizing-pubsub)
-    - [Customizing DHT](#customizing-dht)
-    - [Setup with Content and Peer Routing](#setup-with-content-and-peer-routing)
-    - [Setup with Relay](#setup-with-relay)
-    - [Setup with Auto Relay](#setup-with-auto-relay)
-    - [Setup with Keychain](#setup-with-keychain)
-    - [Configuring Dialing](#configuring-dialing)
-    - [Configuring Connection Manager](#configuring-connection-manager)
-    - [Configuring Connection Gater](#configuring-connection-gater)
-      - [Outgoing connections](#outgoing-connections)
-      - [Incoming connections](#incoming-connections)
-    - [Configuring Transport Manager](#configuring-transport-manager)
-    - [Configuring Metrics](#configuring-metrics)
-    - [Configuring PeerStore](#configuring-peerstore)
-    - [Customizing Transports](#customizing-transports)
-    - [Configuring the NAT Manager](#configuring-the-nat-manager)
-      - [Browser support](#browser-support)
-      - [UPnP and NAT-PMP](#upnp-and-nat-pmp)
-    - [Configuring protocol name](#configuring-protocol-name)
- [Configuration examples](#configuration-examples)
+- [Configuration](#configuration)
+  - [Overview](#overview)
+  - [Modules](#modules)
+    - [Transport](#transport)
+    - [Stream Multiplexing](#stream-multiplexing)
+    - [Connection Encryption](#connection-encryption)
+    - [Peer Discovery](#peer-discovery)
+    - [Content Routing](#content-routing)
+    - [Peer Routing](#peer-routing)
+    - [DHT](#dht)
+    - [Pubsub](#pubsub)
+  - [Customizing libp2p](#customizing-libp2p)
+    - [Examples](#examples)
+      - [Basic setup](#basic-setup)
+      - [Customizing Peer Discovery](#customizing-peer-discovery)
+      - [Setup webrtc transport and discovery](#setup-webrtc-transport-and-discovery)
+      - [Customizing Pubsub](#customizing-pubsub)
+      - [Customizing DHT](#customizing-dht)
+      - [Setup with Content and Peer Routing](#setup-with-content-and-peer-routing)
+      - [Setup with Relay](#setup-with-relay)
+      - [Setup with Auto Relay](#setup-with-auto-relay)
+      - [Setup with Rendezvous](#setup-with-rendezvous)
+      - [Setup with Keychain](#setup-with-keychain)
+      - [Configuring Dialing](#configuring-dialing)
+      - [Configuring Connection Manager](#configuring-connection-manager)
+      - [Configuring Transport Manager](#configuring-transport-manager)
+      - [Configuring Metrics](#configuring-metrics)
+      - [Configuring PeerStore](#configuring-peerstore)
+      - [Customizing Transports](#customizing-transports)
+  - [Configuration examples](#configuration-examples)

 ## Overview

@@ -213,7 +208,7 @@ const modules = {
 Moreover, the majority of the modules can be customized via option parameters. This way, it is also possible to provide this options through a `config` object. This config object should have the property name of each building block to configure, the same way as the modules specification.

 Besides the `modules` and `config`, libp2p allows other internal options and configurations:
- `datastore`: an instance of [ipfs/interface-datastore](https://github.com/ipfs/js-ipfs-interfaces/tree/master/packages/interface-datastore) modules.
+- `datastore`: an instance of [ipfs/interface-datastore](https://github.com/ipfs/interface-datastore/) modules.
  - This is used in modules such as the DHT. If it is not provided, `js-libp2p` will use an in memory datastore.
 - `peerId`: the identity of the node, an instance of [libp2p/js-peer-id](https://github.com/libp2p/js-peer-id).
  - This is particularly useful if you want to reuse the same `peer-id`, as well as for modules like `libp2p-delegated-content-routing`, which need a `peer-id` in their instantiation.
@@ -285,7 +280,7 @@ const node = await Libp2p.create({
        interval: 1000,
        enabled: true
      },
-      [Bootstrap.tag]: {
+      [Bootstrap.tag:] {
        list: [ // A list of bootstrap peers to connect to starting up the node
          "/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
          "/dnsaddr/bootstrap.libp2p.io/ipfs/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN",
@@ -376,8 +371,12 @@ const node = await Libp2p.create({
  config: {
    dht: {                        // The DHT options (and defaults) can be found in its documentation
      kBucketSize: 20,
-      enabled: true,              // This flag is required for DHT to run (disabled by default)
-      clientMode: false           // Whether to run the WAN DHT in client or server mode (default: client mode)
+      enabled: true,
+      randomWalk: {
+        enabled: true,            // Allows to disable discovery (enabled by default)
+        interval: 300e3,
+        timeout: 10e3
+      }
    }
  }
 })
@@ -390,7 +389,6 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
-const ipfsHttpClient = require('ipfs-http-client')
 const DelegatedPeerRouter = require('libp2p-delegated-peer-routing')
 const DelegatedContentRouter = require('libp2p-delegated-content-routing')
 const PeerId = require('peer-id')
@@ -398,25 +396,17 @@ const PeerId = require('peer-id')
 // create a peerId
 const peerId = await PeerId.create()

-const delegatedPeerRouting = new DelegatedPeerRouter(ipfsHttpClient.create({
-  host: 'node0.delegate.ipfs.io', // In production you should setup your own delegates
-  protocol: 'https',
-  port: 443
-}))
-
-const delegatedContentRouting = new DelegatedContentRouter(peerId, ipfsHttpClient.create({
-  host: 'node0.delegate.ipfs.io', // In production you should setup your own delegates
-  protocol: 'https',
-  port: 443
-}))
-
 const node = await Libp2p.create({
  modules: {
    transport: [TCP],
    streamMuxer: [MPLEX],
    connEncryption: [NOISE],
-    contentRouting: [delegatedContentRouting],
-    peerRouting: [delegatedPeerRouting],
+    contentRouting: [
+      new DelegatedContentRouter(peerId)
+    ],
+    peerRouting: [
+      new DelegatedPeerRouter()
+    ],
  },
  peerId,
  peerRouting: { // Peer routing configuration
@@ -486,6 +476,34 @@ const node = await Libp2p.create({
 })
 ```

+#### Setup with Rendezvous
+
+You will need to setup a rendezvous server, which will be used by rendezvous client nodes. You can see how to setup a rendezvous server in [libp2p/js-libp2p-rendezvous](https://github.com/libp2p/js-libp2p-rendezvous)
+
+For setting up libp2p with a rendezvous client, you should configure libp2p as follows:
+
+```js
+const Libp2p = require('libp2p')
+const TCP = require('libp2p-tcp')
+const MPLEX = require('libp2p-mplex')
+const { NOISE } = require('libp2p-noise')
+const Rendezvous = require('libp2p-rendezvous')
+const Bootstrap = require('libp2p-bootstrap')
+const node = await Libp2p.create({
+  modules: {
+    transport: [TCP],
+    streamMuxer: [MPLEX],
+    connEncryption: [NOISE],
+    peerDiscovery: [Bootstrap]
+  },
+  rendezvous: {
+    enabled: true,
+    // Insert your rendezvous servers multiaddrs
+    rendezvousPoints: ['/dnsaddr/rendezvous.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJP']
+  }
+})
+```
+
 #### Setup with Keychain

 Libp2p allows you to setup a secure keychain to manage your keys. The keychain configuration object should have the following properties:
@@ -500,10 +518,7 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
-const { LevelDatastore } = require('datastore-level')
-
-const datastore = new LevelDatastore('path/to/store')
-await datastore.open()
+const LevelStore = require('datastore-level')

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

-await node.loadKeychain()
+await libp2p.loadKeychain()
 ```

 #### Configuring Dialing
@@ -527,7 +542,6 @@ Dialing in libp2p can be configured to limit the rate of dialing, and how long d
 | Name | Type | Description |
 |------|------|-------------|
 | maxParallelDials | `number` | How many multiaddrs we can dial in parallel. |
-| maxAddrsToDial | `number` | How many multiaddrs is the dial allowed to dial for a single peer. |
 | maxDialsPerPeer | `number` | How many multiaddrs we can dial per peer, in parallel. |
 | dialTimeout | `number` | Second dial timeout per peer in ms. |
 | resolvers | `object` | Dial [Resolvers](https://github.com/multiformats/js-multiaddr/blob/master/src/resolvers/index.js) for resolving multiaddrs |
@@ -552,7 +566,6 @@ const node = await Libp2p.create({
  },
  dialer: {
    maxParallelDials: 100,
-    maxAddrsToDial: 25,
    maxDialsPerPeer: 4,
    dialTimeout: 30e3,
    resolvers: {
@@ -593,130 +606,9 @@ const node = await Libp2p.create({
 })
 ```

-#### Configuring Connection Gater
-
-The Connection Gater allows us to prevent making incoming and outgoing connections to peers and storing
-multiaddrs in the address book.
-
-The order in which methods are called is as follows:
-
-##### Outgoing connections
-
-1. `connectionGater.denyDialPeer(...)`
-2. `connectionGater.denyDialMultiaddr(...)`
-3. `connectionGater.denyOutboundConnection(...)`
-4. `connectionGater.denyOutboundEncryptedConnection(...)`
-5. `connectionGater.denyOutboundUpgradedConnection(...)`
-
-##### Incoming connections
-
-1. `connectionGater.denyInboundConnection(...)`
-2. `connectionGater.denyInboundEncryptedConnection(...)`
-3. `connectionGater.denyInboundUpgradedConnection(...)`
-
-```js
-const node = await Libp2p.create({
-  // .. other config
-  connectionGater: {
-    /**
-     * denyDialMultiaddr tests whether we're permitted to Dial the
-     * specified peer.
-     *
-     * This is called by the dialer.connectToPeer implementation before
-     * dialling a peer.
-     *
-     * Return true to prevent dialing the passed peer.
-     */
-    denyDialPeer: (peerId: PeerId) => Promise<boolean>
-
-    /**
-     * denyDialMultiaddr tests whether we're permitted to dial the specified
-     * multiaddr for the given peer.
-     *
-     * This is called by the dialer.connectToPeer implementation after it has
-     * resolved the peer's addrs, and prior to dialling each.
-     *
-     * Return true to prevent dialing the passed peer on the passed multiaddr.
-     */
-    denyDialMultiaddr: (peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>
-
-    /**
-     * denyInboundConnection tests whether an incipient inbound connection is allowed.
-     *
-     * This is called by the upgrader, or by the transport directly (e.g. QUIC,
-     * Bluetooth), straight after it has accepted a connection from its socket.
-     *
-     * Return true to deny the incoming passed connection.
-     */
-    denyInboundConnection: (maConn: MultiaddrConnection) => Promise<boolean>
-
-    /**
-     * denyOutboundConnection tests whether an incipient outbound connection is allowed.
-     *
-     * This is called by the upgrader, or by the transport directly (e.g. QUIC,
-     * Bluetooth), straight after it has created a connection with its socket.
-     *
-     * Return true to deny the incoming passed connection.
-     */
-    denyOutboundConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>
-
-    /**
-     * denyInboundEncryptedConnection tests whether a given connection, now encrypted,
-     * is allowed.
-     *
-     * This is called by the upgrader, after it has performed the security
-     * handshake, and before it negotiates the muxer, or by the directly by the
-     * transport, at the exact same checkpoint.
-     *
-     * Return true to deny the passed secured connection.
-     */
-    denyInboundEncryptedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>
-
-    /**
-     * denyOutboundEncryptedConnection tests whether a given connection, now encrypted,
-     * is allowed.
-     *
-     * This is called by the upgrader, after it has performed the security
-     * handshake, and before it negotiates the muxer, or by the directly by the
-     * transport, at the exact same checkpoint.
-     *
-     * Return true to deny the passed secured connection.
-     */
-    denyOutboundEncryptedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>
-
-    /**
-     * denyInboundUpgradedConnection tests whether a fully capable connection is allowed.
-     *
-     * This is called after encryption has been negotiated and the connection has been
-     * multiplexed, if a multiplexer is configured.
-     *
-     * Return true to deny the passed upgraded connection.
-     */
-    denyInboundUpgradedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>
-
-    /**
-     * denyOutboundUpgradedConnection tests whether a fully capable connection is allowed.
-     *
-     * This is called after encryption has been negotiated and the connection has been
-     * multiplexed, if a multiplexer is configured.
-     *
-     * Return true to deny the passed upgraded connection.
-     */
-    denyOutboundUpgradedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>
-
-    /**
-     * Used by the address book to filter passed addresses.
-     *
-     * Return true to allow storing the passed multiaddr for the passed peer.
-     */
-    filterMultiaddrForPeer: (peer: PeerId, multiaddr: Multiaddr) => Promise<boolean>
-  }
-})
-```
-
 #### Configuring Transport Manager

-The Transport Manager is responsible for managing the libp2p transports life cycle. This includes starting listeners for the provided listen addresses, closing these listeners and dialing using the provided transports. By default, if a libp2p node has a list of multiaddrs for listening on and there are no valid transports for those multiaddrs, libp2p will throw an error on startup and shutdown. However, for some applications it is perfectly acceptable for libp2p nodes to start in dial only mode if all the listen multiaddrs failed. This error tolerance can be enabled as follows:
+The Transport Manager is responsible for managing the libp2p transports life cycle. This includes starting listeners for the provided listen addresses, closing these listeners and dialing using the provided transports. By default, if a libp2p node has a list of multiaddrs for listenning on and there are no valid transports for those multiaddrs, libp2p will throw an error on startup and shutdown. However, for some applications it is perfectly acceptable for libp2p nodes to start in dial only mode if all the listen multiaddrs failed. This error tolerance can be enabled as follows:

 ```js
 const Libp2p = require('libp2p')
@@ -724,7 +616,7 @@ const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')

-const { FaultTolerance } = require('libp2p/src/transport-manager')
+const { FaultTolerance } = require('libp2p/src/transport-manager')}

 const node = await Libp2p.create({
  modules: {
@@ -796,18 +688,16 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
-const LevelDatastore = require('datastore-level')

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

 const node = await Libp2p.create({
-  datastore, // pass the opened datastore
  modules: {
    transport: [TCP],
    streamMuxer: [MPLEX],
    connEncryption: [NOISE]
  },
+  datastore: new LevelStore('path/to/store'),
  peerStore: {
    persistence: true,
    threshold: 5
@@ -872,66 +762,12 @@ const node = await Libp2p.create({
 })
 ```

-#### Configuring the NAT Manager
-
-Network Address Translation (NAT) is a function performed by your router to enable multiple devices on your local network to share a single IPv4 address. It's done transparently for outgoing connections, ensuring the correct response traffic is routed to your computer, but if you wish to accept incoming connections some configuration is necessary.
-
-The NAT manager can be configured as follows:
-
-```js
-const node = await Libp2p.create({
-  config: {
-    nat: {
-      description: 'my-node', // set as the port mapping description on the router, defaults the current libp2p version and your peer id
-      enabled: true, // defaults to true
-      gateway: '192.168.1.1', // leave unset to auto-discover
-      externalIp: '80.1.1.1', // leave unset to auto-discover
-      ttl: 7200, // TTL for port mappings (min 20 minutes)
-      keepAlive: true, // Refresh port mapping after TTL expires
-      pmp: {
-        enabled: false, // defaults to false
-      }
-    }
-  }
-})
-```
-
-##### Browser support
-
-Browsers cannot open TCP ports or send the UDP datagrams necessary to configure external port mapping - to accept incoming connections in the browser please use a WebRTC transport.
-
-##### UPnP and NAT-PMP
-
-By default under nodejs libp2p will attempt to use [UPnP](https://en.wikipedia.org/wiki/Universal_Plug_and_Play) to configure your router to allow incoming connections to any TCP transports that have been configured.
-
-[NAT-PMP](http://miniupnp.free.fr/nat-pmp.html) is a feature of some modern routers which performs a similar job to UPnP. NAT-PMP is disabled by default, if enabled libp2p will try to use NAT-PMP and will fall back to UPnP if it fails.
-
-#### Configuring protocol name
-
-Changing the protocol name prefix can isolate default public network (IPFS) for custom purposes.
-
-```js
-const node = await Libp2p.create({
-  config: {
-    protocolPrefix: 'ipfs' // default
-  }
-})
-/*
-protocols: [
-  "/ipfs/id/1.0.0", // identify service protocol (if we have multiplexers)
-  "/ipfs/id/push/1.0.0", // identify service push protocol (if we have multiplexers)
-  "/ipfs/ping/1.0.0", // built-in ping protocol
-]
-*/
-```
-
-
 ## Configuration examples

 As libp2p is designed to be a modular networking library, its usage will vary based on individual project needs. We've included links to some existing project configurations for your reference, in case you wish to replicate their configuration:

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

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

--- a/doc/migrations/v0.30-v0.31.md
+++ b/doc/migrations/v0.30-v0.31.md
@@ -1,123 +0,0 @@
-<!--Specify versions for migration below-->
-# Migrating to libp2p@31
-
-A migration guide for refactoring your application code from libp2p v0.30.x to v0.31.0.
-
-## Table of Contents
-
- [Types](#types)
- [API](#api)
- [Module Updates](#module-updates)
-
-## Types
-
-Most of the type definitions in the libp2p configuration were `any` or were not included before this release. This might cause breaking changes on upstream projects relying on the previous provided types, as well as to libp2p modules implemented by the libp2p community.
-
-## API
-
-### Core API
-
-`libp2p.dialProtocol` does not accept empty or null protocols returning a connection anymore and `dial` must be used instead.
-
-```js
-const connection = await libp2p.dialProtocol(peerId)
-```
-
-**After**
-
-```js
-const connection = await libp2p.dial(peerId)
-```
-
-### Connection Manager Options
-
-We updated the connection manager options naming in `libp2p@0.29` but kept it backward compatible until now.
-
-**Before**
-
-```js
-const node = await Libp2p.create({
-  connectionManager: {
-    minPeers: 0
-  }
-})
-```
-
-**After**
-
-```js
-const node = await Libp2p.create({
-  connectionManager: {
-    minConnections: 0
-  }
-})
-```
-
-You can see full details on how to configure the connection manager [here](https://github.com/libp2p/js-libp2p/blob/master/doc/CONFIGURATION.md#configuring-connection-manager).
-
-### Dialer and Keychain components
-
-Internal property names to create a libp2p `Dialer` and `Keychain` were updated to reflect the properties naming in the libp2p configuration. These are internal modules of libp2p core and should not impact most of the users, but as it is possible to use them separately here follow the changes:
-
-***Before**
-
-```js
-const dialer = new Dialer({
-  transportManager,
-  peerStore,
-  concurrency,
-  perPeerLimit,
-  timeout,
-  resolvers,
-  addressSorter
-})
-
-const keychain = new Keychain(datastore, {
-  passPhrase
-})
-```
-
-**After**
-
-```js
-this.dialer = new Dialer({
-  transportManager,
-  peerStore,
-  maxParallelDials,
-  maxDialsPerPeer,
-  dialTimeout,
-  resolvers,
-  addressSorter
-})
-
-const keychain = new Keychain(datastore, {
-  pass
-})
-```
-
-## Module Updates
-
-With this release you should update the following libp2p modules if you are relying on them:
-
-<!--Specify module versions in JSON for migration below.
-It's recommended to check package.json changes for this: 
-`git diff <release> <prev> -- package.json`
-->
-
-```json
-"libp2p-bootstrap": "^0.12.3",
-"libp2p-crypto": "^0.19.4",
-"libp2p-interfaces": "^0.10.0",
-"libp2p-delegated-content-routing": "^0.10.0",
-"libp2p-delegated-peer-routing": "^0.9.0",
-"libp2p-floodsub": "^0.25.1",
-"libp2p-gossipsub": "^0.9.0",
-"libp2p-kad-dht": "^0.22.0",
-"libp2p-mdns": "^0.16.0",
-"libp2p-noise": "^3.0.0",
-"libp2p-tcp": "^0.15.4",
-"libp2p-webrtc-star": "^0.22.2",
-"libp2p-websockets": "^0.15.6"
-```
-
-One of the main changes in this new release is the update to `multiaddr@9.0.0`. This should also be updated in upstream projects to avoid several multiaddr versions in the bundle and to avoid potential problems when libp2p interacts with provided outdated multiaddr instances.
--- a/doc/migrations/v0.31-v0.32.md
+++ b/doc/migrations/v0.31-v0.32.md
@@ -1,36 +0,0 @@
-<!--Specify versions for migration below-->
-# Migrating to libp2p@32
-
-A migration guide for refactoring your application code from libp2p v0.31.x to v0.32.0.
-
-## Table of Contents
-
- [Module Updates](#module-updates)
-
-## Module Updates
-
-With this release you should update the following libp2p modules if you are relying on them:
-
-<!--Specify module versions in JSON for migration below.
-It's recommended to check package.json changes for this: 
-`git diff <release> <prev> -- package.json`
-->
-
-```json
-"libp2p-bootstrap": "^0.13.0",
-"libp2p-crypto": "^0.19.4",
-"libp2p-interfaces": "^1.0.0",
-"libp2p-delegated-content-routing": "^0.11.0",
-"libp2p-delegated-peer-routing": "^0.10.0",
-"libp2p-floodsub": "^0.27.0",
-"libp2p-gossipsub": "^0.11.0",
-"libp2p-kad-dht": "^0.23.0",
-"libp2p-mdns": "^0.17.0",
-"libp2p-noise": "^4.0.0",
-"libp2p-tcp": "^0.17.0",
-"libp2p-webrtc-direct": "^0.7.0",
-"libp2p-webrtc-star": "^0.23.0",
-"libp2p-websockets": "^0.16.0"
-```
-
-One of the main changes in this new release is the update to `multiaddr@10.0.0`. This should also be updated in upstream projects to avoid several multiaddr versions in the bundle and to avoid potential problems when libp2p interacts with provided outdated multiaddr instances.
--- a/doc/migrations/v0.32-v0.33.md
+++ b/doc/migrations/v0.32-v0.33.md
@@ -1,14 +0,0 @@
-<!--Specify versions for migration below-->
-# Migrating to libp2p@33
-
-A migration guide for refactoring your application code from libp2p v0.32.x to v0.33.0.
-
-## Table of Contents
-
- [Module Updates](#module-updates)
-
-## Module Updates
-
-Libp2p uses a datastore implementation for Peerstore persistence and for the DHT state. While libp2p defaults to a datastore implementation, it can receive any implementation of a datastore compliant with the [interface-datastore](https://github.com/ipfs/js-ipfs-interfaces/tree/master/packages/interface-datastore) via its configuration.
-
-In this release, we updated to `interface-datastore@6.0.0`. As a result, libp2p users relying on a configured datastore should update it to a compliant implementation for updating libp2p.
--- a/examples/README.md
+++ b/examples/README.md
@@ -8,7 +8,7 @@ Let us know if you find any issues, or if you want to contribute and add a new t

 - [Transports](./transports)
 - [Protocol and Stream Muxing](./protocol-and-stream-muxing)
- [Connection Encryption](./connection-encryption)
+- [Encrypted Communications](./encrypted-communications)
 - [Discovery Mechanisms](./discovery-mechanisms)
 - [Peer and Content Routing](./peer-and-content-routing)
 - [PubSub](./pubsub)
--- a/examples/auto-relay/README.md
+++ b/examples/auto-relay/README.md
@@ -18,7 +18,7 @@ The relay node will need to have its relay subsystem enabled, as well as its HOP
 ```js
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const MPLEX = require('libp2p-mplex')

 const node = await Libp2p.create({
@@ -76,7 +76,7 @@ One of the typical use cases for Auto Relay is nodes behind a NAT or browser nod
 ```js
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const MPLEX = require('libp2p-mplex')

 const relayAddr = process.argv[2]
@@ -125,7 +125,7 @@ As you can see in the code, we need to provide the relay address, `relayAddr`, a
 You should now run the following to start the node running Auto Relay:

 ```sh
-node listener.js /ip4/192.168.1.120/tcp/61592/ws/p2p/QmWDn2LY8nannvSWJzruUYoLZ4vV83vfCBwd8DipvdgQc3
+node listener.js /ip4/192.168.1.120/tcp/58941/ws/p2p/QmQKCBm87HQMbFqy14oqC85pMmnRrj6iD46ggM6reqNpsd
 ```

 This should print out something similar to the following:
@@ -147,7 +147,7 @@ Now that you have a relay node and a node bound to that relay, you can test conn
 ```js
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const MPLEX = require('libp2p-mplex')

 const autoRelayNodeAddr = process.argv[2]
@@ -173,7 +173,7 @@ console.log(`Connected to the auto relay node via ${conn.remoteAddr.toString()}`
 You should now run the following to start the relay node using the listen address from step 2:

 ```sh
-node dialer.js /ip4/192.168.1.120/tcp/61592/ws/p2p/QmWDn2LY8nannvSWJzruUYoLZ4vV83vfCBwd8DipvdgQc3
+node dialer.js /ip4/192.168.1.120/tcp/58941/ws/p2p/QmQKCBm87HQMbFqy14oqC85pMmnRrj6iD46ggM6reqNpsd
 ```

 Once you start your test node, it should print out something similar to the following:
--- a/examples/auto-relay/dialer.js
+++ b/examples/auto-relay/dialer.js
@@ -2,7 +2,7 @@

 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const MPLEX = require('libp2p-mplex')

 async function main () {
--- a/examples/auto-relay/listener.js
+++ b/examples/auto-relay/listener.js
@@ -2,7 +2,7 @@

 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const MPLEX = require('libp2p-mplex')

 async function main () {
--- a/examples/auto-relay/relay.js
+++ b/examples/auto-relay/relay.js
@@ -2,7 +2,7 @@

 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const MPLEX = require('libp2p-mplex')

 async function main () {
--- a/examples/auto-relay/test.js
+++ b/examples/auto-relay/test.js
@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
+const uint8ArrayToString = require('uint8arrays/to-string')

 function startProcess (name, args = []) {
  return execa('node', [path.join(__dirname, name), ...args], {
--- a/examples/chat/src/dialer.js
+++ b/examples/chat/src/dialer.js
@@ -2,11 +2,11 @@
 /* eslint-disable no-console */

 const PeerId = require('peer-id')
-const { Multiaddr } = require('multiaddr')
+const multiaddr = require('multiaddr')
 const createLibp2p = require('./libp2p')
 const { stdinToStream, streamToConsole } = require('./stream')

-async function run () {
+async function run() {
  const [idDialer, idListener] = await Promise.all([
    PeerId.createFromJSON(require('./peer-id-dialer')),
    PeerId.createFromJSON(require('./peer-id-listener'))
@@ -30,7 +30,7 @@ async function run () {
  })

  // Dial to the remote peer (the "listener")
-  const listenerMa = new Multiaddr(`/ip4/127.0.0.1/tcp/10333/p2p/${idListener.toB58String()}`)
+  const listenerMa = multiaddr(`/ip4/127.0.0.1/tcp/10333/p2p/${idListener.toB58String()}`)
  const { stream } = await nodeDialer.dialProtocol(listenerMa, '/chat/1.0.0')

  console.log('Dialer dialed to listener on protocol: /chat/1.0.0')
--- a/examples/chat/src/libp2p.js
+++ b/examples/chat/src/libp2p.js
@@ -3,7 +3,7 @@
 const TCP = require('libp2p-tcp')
 const WS = require('libp2p-websockets')
 const mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const defaultsDeep = require('@nodeutils/defaults-deep')
 const libp2p = require('../../..')

--- a/examples/chat/src/listener.js
+++ b/examples/chat/src/listener.js
@@ -5,7 +5,7 @@ const PeerId = require('peer-id')
 const createLibp2p = require('./libp2p.js')
 const { stdinToStream, streamToConsole } = require('./stream')

-async function run () {
+async function run() {
  // Create a new libp2p node with the given multi-address
  const idListener = await PeerId.createFromJSON(require('./peer-id-listener'))
  const nodeListener = await createLibp2p({
--- a/examples/chat/test.js
+++ b/examples/chat/test.js
@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
+const uint8ArrayToString = require('uint8arrays/to-string')

 function startProcess(name) {
  return execa('node', [path.join(__dirname, name)], {
--- a/examples/connection-encryption/test.js
+++ b/examples/connection-encryption/test.js
@@ -1,14 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { waitForOutput } = require('../utils')
-
-async function test () {
-  process.stdout.write('1.js\n')
-
-  await waitForOutput('This information is sent out encrypted to the other peer', 'node', [path.join(__dirname, '1.js')], {
-    cwd: __dirname
-  })
-}
-
-module.exports = test
--- a/examples/delegated-routing/package.json
+++ b/examples/delegated-routing/package.json
@@ -3,16 +3,16 @@
  "version": "0.1.0",
  "private": true,
  "dependencies": {
-    "@chainsafe/libp2p-noise": "^5.0.2",
-    "ipfs-core": "^0.13.0",
-    "libp2p": "../../",
-    "libp2p-delegated-content-routing": "^0.11.0",
-    "libp2p-delegated-peer-routing": "^0.11.1",
-    "libp2p-kad-dht": "^0.28.6",
-    "libp2p-mplex": "^0.10.4",
-    "libp2p-webrtc-star": "^0.25.0",
-    "libp2p-websocket-star": "^0.10.2",
-    "libp2p-websockets": "^0.16.2",
+    "ipfs": "~0.34.4",
+    "libp2p": "github:libp2p/js-libp2p#master",
+    "libp2p-delegated-content-routing": "~0.2.2",
+    "libp2p-delegated-peer-routing": "~0.2.2",
+    "libp2p-kad-dht": "~0.14.12",
+    "libp2p-mplex": "~0.8.5",
+    "libp2p-secio": "~0.11.1",
+    "libp2p-webrtc-star": "~0.15.8",
+    "libp2p-websocket-star": "~0.10.2",
+    "libp2p-websockets": "~0.12.2",
    "react": "^16.8.6",
    "react-dom": "^16.8.6",
    "react-scripts": "2.1.8"
--- a/examples/delegated-routing/src/App.js
+++ b/examples/delegated-routing/src/App.js
@@ -2,7 +2,7 @@
 'use strict'

 import React from 'react'
-import Ipfs from 'ipfs-core'
+import Ipfs from 'ipfs'
 import libp2pBundle from './libp2p-bundle'
 const Component = React.Component

@@ -70,7 +70,7 @@ class App extends Component {
  }

  componentDidMount () {
-    window.ipfs = this.ipfs = Ipfs.create({
+    window.ipfs = this.ipfs = new Ipfs({
      config: {
        Addresses: {
          Swarm: []
--- a/examples/delegated-routing/src/libp2p-bundle.js
+++ b/examples/delegated-routing/src/libp2p-bundle.js
@@ -6,7 +6,7 @@ const Websockets = require('libp2p-websockets')
 const WebSocketStar = require('libp2p-websocket-star')
 const WebRTCStar = require('libp2p-webrtc-star')
 const MPLEX = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const SECIO = require('libp2p-secio')
 const KadDHT = require('libp2p-kad-dht')
 const DelegatedPeerRouter = require('libp2p-delegated-peer-routing')
 const DelegatedContentRouter = require('libp2p-delegated-content-routing')
@@ -48,7 +48,7 @@ export default function Libp2pBundle ({peerInfo, peerBook}) {
        MPLEX
      ],
      connEncryption: [
-        NOISE
+        SECIO
      ],
      dht: KadDHT
    },
--- a/examples/discovery-mechanisms/1.js
+++ b/examples/discovery-mechanisms/1.js
@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const Bootstrap = require('libp2p-bootstrap')

 const bootstrapers = require('./bootstrapers')
--- a/examples/discovery-mechanisms/2.js
+++ b/examples/discovery-mechanisms/2.js
@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const MulticastDNS = require('libp2p-mdns')

 const createNode = async () => {
--- a/examples/discovery-mechanisms/3.js
+++ b/examples/discovery-mechanisms/3.js
@@ -4,8 +4,8 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
-const Gossipsub = require('@achingbrain/libp2p-gossipsub')
+const { NOISE } = require('libp2p-noise')
+const Gossipsub = require('libp2p-gossipsub')
 const Bootstrap = require('libp2p-bootstrap')
 const PubsubPeerDiscovery = require('libp2p-pubsub-peer-discovery')

--- a/examples/discovery-mechanisms/README.md
+++ b/examples/discovery-mechanisms/README.md
@@ -2,13 +2,13 @@

 A Peer Discovery module enables libp2p to find peers to connect to. Think of these mechanisms as ways to join the rest of the network, as railing points.

-With this system, a libp2p node can both have a set of nodes to always connect on boot (bootstraper nodes), discover nodes through locality (e.g connected in the same LAN) or through serendipity (random walks on a DHT).
+With these system, a libp2p node can both have a set of nodes to always connect on boot (bootstraper nodes), discover nodes through locality (e.g connected in the same LAN) or through serendipity (random walks on a DHT).

 These mechanisms save configuration and enable a node to operate without any explicit dials, it will just work. Once new peers are discovered, their known data is stored in the peer's PeerStore.

 ## 1. Bootstrap list of Peers when booting a node

-For this demo, we will connect to IPFS default bootstrapper nodes and so, we will need to support the same set of features those nodes have, that are: TCP, mplex, and NOISE. You can see the complete example at [1.js](./1.js).
+For this demo, we will connect to IPFS default bootstrapper nodes and so, we will need to support the same set of features those nodes have, that are: TCP, mplex and NOISE. You can see the complete example at [1.js](./1.js).

 First, we create our libp2p node.

@@ -16,7 +16,7 @@ First, we create our libp2p node.
 const Libp2p = require('libp2p')
 const Bootstrap = require('libp2p-bootstrap')

-const node = await Libp2p.create({
+const node = Libp2p.create({
  modules: {
    transport: [ TCP ],
    streamMuxer: [ Mplex ],
@@ -55,7 +55,7 @@ const node = await Libp2p.create({
  peerId,
  addresses: {
    listen: ['/ip4/0.0.0.0/tcp/0']
-  },
+  }
  modules: {
    transport: [ TCP ],
    streamMuxer: [ Mplex ],
@@ -117,7 +117,7 @@ const createNode = () => {
  return Libp2p.create({
    addresses: {
      listen: ['/ip4/0.0.0.0/tcp/0']
-    },
+    }
    modules: {
      transport: [ TCP ],
      streamMuxer: [ Mplex ],
@@ -144,13 +144,8 @@ const [node1, node2] = await Promise.all([
  createNode()
 ])

-node1.on('peer:discovery', (peer) => console.log('Discovered:', peerId.toB58String()))
-node2.on('peer:discovery', (peer) => console.log('Discovered:', peerId.toB58String()))
-
-await Promise.all([
-  node1.start(),
-  node2.start()
-])
+node1.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String()))
+node2.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String()))
 ```

 If you run this example, you will see the other peers being discovered.
@@ -173,7 +168,7 @@ You can create your libp2p nodes as follows:
 const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const Gossipsub = require('libp2p-gossipsub')
 const Bootstrap = require('libp2p-bootstrap')
 const PubsubPeerDiscovery = require('libp2p-pubsub-peer-discovery')
@@ -208,7 +203,7 @@ const createNode = async (bootstrapers) => {
 }
 ```

-We will use the `libp2p-relay-server` as bootstrap nodes for the libp2p nodes, so that they establish a connection with the relay after starting. As a result, after they establish a connection with the relay, the pubsub discovery will kick in and the relay will advertise them.
+We will use the `libp2p-relay-server` as bootstrap nodes for the libp2p nodes, so that they establish a connection with the relay after starting. As a result, after they establish a connection with the relay, the pubsub discovery will kick in an the relay will advertise them.

 ```js
 const relay = await createRelayServer({
@@ -259,5 +254,5 @@ This is really useful when running libp2p in constrained environments like a bro
 There are plenty more Peer Discovery Mechanisms out there, you can:

 - Find one in [libp2p-webrtc-star](https://github.com/libp2p/js-libp2p-webrtc-star). Yes, a transport with discovery capabilities! This happens because WebRTC requires a rendezvous point for peers to exchange [SDP](https://tools.ietf.org/html/rfc4317) offer, which means we have one or more points that can introduce peers to each other. Think of it as MulticastDNS for the Web, as in MulticastDNS only works in LAN.
- Any DHT will offer you a discovery capability. You can simple _random-walk_ the routing tables to find other peers to connect to. For example [libp2p-kad-dht](https://github.com/libp2p/js-libp2p-kad-dht) can be used for peer discovery. An example of how to configure it to enable random walks can be found [here](https://github.com/libp2p/js-libp2p/blob/v0.28.4/doc/CONFIGURATION.md#customizing-dht).
+- Any DHT will offer you a discovery capability. You can simple _random-walk_ the routing tables to find other peers to connect to. For example [libp2p-kad-dht](https://github.com/libp2p/js-libp2p-kad-dht) can be used for peer discovery. An example how to configure it to enable random walks can be found [here](https://github.com/libp2p/js-libp2p/blob/v0.28.4/doc/CONFIGURATION.md#customizing-dht).
 - You can create your own Discovery service, a registry, a list, a radio beacon, you name it!
--- a/examples/discovery-mechanisms/bootstrapers.js
+++ b/examples/discovery-mechanisms/bootstrapers.js
@@ -1,13 +1,13 @@
 'use strict'

-// Find this list at: https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs-core-config/src/config.js
+// Find this list at: https://github.com/ipfs/js-ipfs/blob/master/src/core/runtime/config-nodejs.json
 const bootstrapers = [
  '/ip4/104.131.131.82/tcp/4001/p2p/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ',
  '/dnsaddr/bootstrap.libp2p.io/p2p/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN',
  '/dnsaddr/bootstrap.libp2p.io/p2p/QmbLHAnMoJPWSCR5Zhtx6BHJX9KiKNN6tpvbUcqanj75Nb',
  '/dnsaddr/bootstrap.libp2p.io/p2p/QmZa1sAxajnQjVM8WjWXoMbmPd7NsWhfKsPkErzpm9wGkp',
  '/dnsaddr/bootstrap.libp2p.io/p2p/QmQCU2EcMqAqQPR2i9bChDtGNJchTbq5TbXJJ16u19uLTa',
-  '/dnsaddr/bootstrap.libp2p.io/p2p/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt',
+  '/dnsaddr/bootstrap.libp2p.io/p2p/QmcZf59bWwK5XFi76CZX8cbJ4BhTzzA3gU1ZjYZcYW3dwt'
 ]

 module.exports = bootstrapers
--- a/examples/discovery-mechanisms/rendezvous/README.md
+++ b/examples/discovery-mechanisms/rendezvous/README.md
@@ -0,0 +1,146 @@
+# Rendezvous
+
+During the lifetime of a libp2p node, particularly during its startup, establishing connections with other peers will be crucial to create a network topology able to fulfill the needs of the node.
+
+Each connection to a different peer might have different outcomes. Accordingly, each peer will need to find peers providing a given service or playing a given role over time, so that they can operate more efficiently. These services and roles can range from circuit relays to enable connectivity between restricted nodes, subscribers of a given pubsub topic, or even application specific routing.
+
+One of the possible ways to register and discover certain roles/services is using the [rendezvous protocol](https://github.com/libp2p/specs/tree/master/rendezvous). For using it, the network needs to have well known libp2p nodes acting as rendezvous servers. They will collect and maintain a list of registrations per rendezvous namespace. Other peers in the network will act as rendezvous clients and will register themselves on given namespaces by messaging a rendezvous server node. Taking into account these registrations, a rendezvous client is also able to discover other peers in a given namespace by querying a server. Each registration has a time to live, in order to avoid finding invalid registrations.
+
+## 0. Set up the example
+
+Before moving into the examples, you should run `npm install` on the top level `js-libp2p` folder, in order to install all the dependencies needed for this example. Once the install finishes, you should move into the example folder with `cd examples/discovery-mechanisms/rendezvous`.
+
+You will also need to install and run a `libp2p-rendezvous` server. In the context of this example, we can just install `libp2p-rendezvous` globally and run a server locally with:
+
+```sh
+npm i -g libp2p-rendezvous
+libp2p-rendezvous-server --enableMemoryDatabase
+```
+
+We will be using a memory database for demonstration purposes. For using this in production you should read [libp2p/js-libp2p-rendezvous instructions](https://github.com/libp2p/js-libp2p-rendezvous) and use a database to back it up.
+
+It should print out the addresses the server is listening on as:
+
+```sh
+Rendezvous server listening on:
+/ip4/127.0.0.1/tcp/15003/ws/p2p/QmeSKXKKfkQzE45WTLY7Me1RaC8ZhG9aFfSPVEnGHbFQXM
+/ip4/127.0.0.1/tcp/8000/p2p/QmeSKXKKfkQzE45WTLY7Me1RaC8ZhG9aFfSPVEnGHbFQXM
+```
+
+## 1. Set up a listener node providing a service
+
+One of the typical use cases for Rendezvous is to easily make discoverable nodes that provide services to boost the network. These libp2p nodes should make themselves discoverable by using rendezvous namespaces.
+
+```js
+const Libp2p = require('libp2p')
+const Websockets = require('libp2p-websockets')
+const { NOISE } = require('libp2p-noise')
+const MPLEX = require('libp2p-mplex')
+
+const multiaddr = require('multiaddr')
+
+const rendezvousServerAddr = process.argv[2]
+if (!rendezvousServerAddr) {
+  throw new Error('the relay address needs to be specified as a parameter')
+}
+
+const rendezvousServerMultiaddr = multiaddr(rendezvousServerAddr)
+
+const node = await Libp2p.create({
+  modules: {
+    transport: [Websockets],
+    connEncryption: [NOISE],
+    streamMuxer: [MPLEX]
+  },
+  addresses: {
+    listen: ['/ip4/127.0.0.1/tcp/0/ws']
+  },
+  rendezvous: {
+    enabled: true,
+    rendezvousPoints: [rendezvousServerMultiaddr]
+  }
+})
+
+await node.start()
+console.log(`Node started with id ${node.peerId.toB58String()}`)
+console.log('Node listening on:')
+node.multiaddrs.forEach((m) => console.log(`${m}/p2p/${node.peerId.toB58String()}`))
+
+await node.rendezvous.register('example-namespace')
+console.log('Registered to: ', ns)
+```
+
+As you can see in the code, we need to provide the rendezvous server address, `rendezvousServerAddr`, as a process argument.
+
+You should now run the following to start the node providing the service:
+
+```sh
+node listener.js /ip4/127.0.0.1/tcp/15003/ws/p2p/QmeSKXKKfkQzE45WTLY7Me1RaC8ZhG9aFfSPVEnGHbFQXM
+```
+
+This should print out something similar to the following:
+
+```sh
+Node started with id QmV4sitaJ5ZC2Vpgza8NyjeTSWV4FvHd5cNmyPPPKpoRE7
+Node listening on:
+/ip4/127.0.0.1/tcp/50347/ws/p2p/QmV4sitaJ5ZC2Vpgza8NyjeTSWV4FvHd5cNmyPPPKpoRE7
+Registered to: example-namespace
+```
+
+## 2. Set up a Dialer node discovering the service
+
+Now that you have a node providing a given service, you can discover it via the rendezvous server.
+
+```js
+const rendezvousServerAddr = process.argv[2]
+  if (!rendezvousServerAddr) {
+    throw new Error('the rendezvous server address needs to be specified as a parameter')
+  }
+
+  const rendezvousServerMultiaddr = multiaddr(rendezvousServerAddr)
+  const ns = 'example-namespace'
+
+  const node = await Libp2p.create({
+    modules: {
+      transport: [Websockets],
+      connEncryption: [NOISE],
+      streamMuxer: [MPLEX]
+    },
+    addresses: {
+      listen: ['/ip4/127.0.0.1/tcp/0/ws']
+    },
+    rendezvous: {
+      enabled: true,
+      rendezvousPoints: [rendezvousServerMultiaddr]
+    }
+  })
+
+  await node.start()
+  console.log(`Node started with id ${node.peerId.toB58String()}`)
+
+  for await (const reg of node.rendezvous.discover(ns)) {
+    const e = await Envelope.openAndCertify(reg.signedPeerRecord, PeerRecord.DOMAIN)
+    const rec = PeerRecord.createFromProtobuf(e.payload)
+
+    console.log(`Discovered peer with id: ${rec.peerId.toB58String()} and multiaddrs ${rec.multiaddrs}`)
+  }
+```
+
+You should now run the following to start the node discovering the service:
+
+```sh
+node dialer.js /ip4/127.0.0.1/tcp/15003/ws/p2p/QmeSKXKKfkQzE45WTLY7Me1RaC8ZhG9aFfSPVEnGHbFQXM
+```
+
+This should print out something similar to the following:
+
+```sh
+Node started with id QmanTJphnwpKTeRaoDpEiMoNytvKyFUh61Ri9ifptbvJdb
+Discovered peer with id: QmV4sitaJ5ZC2Vpgza8NyjeTSWV4FvHd5cNmyPPPKpoRE7 and multiaddrs /ip4/127.0.0.1/tcp/50347/ws
+```
+
+As you can see, the dialer discovered the node providing the `example-namespace` service and can now use its multiaddr and id to dial it.
+
+## 3. What's next?
+
+Libp2p does not support re-registering over time. This means that the application layer will need to handle triggering the `rendezvous.register` over time to refresh the registration of the node in the given rendezvous servers. The minimum ttl of a registration is 2 hours.
--- a/examples/discovery-mechanisms/rendezvous/dialer.js
+++ b/examples/discovery-mechanisms/rendezvous/dialer.js
@@ -0,0 +1,47 @@
+'use strict'
+
+const Libp2p = require('../../../src')
+const Envelope = require('../../../src/record/envelope')
+const PeerRecord = require('../../../src/record/peer-record')
+const Websockets = require('libp2p-websockets')
+const { NOISE } = require('libp2p-noise')
+const MPLEX = require('libp2p-mplex')
+
+const multiaddr = require('multiaddr')
+
+async function main () {
+  const rendezvousServerAddr = process.argv[2]
+  if (!rendezvousServerAddr) {
+    throw new Error('the rendezvous server address needs to be specified as a parameter')
+  }
+
+  const rendezvousServerMultiaddr = multiaddr(rendezvousServerAddr)
+  const ns = 'example-namespace'
+
+  const node = await Libp2p.create({
+    modules: {
+      transport: [Websockets],
+      connEncryption: [NOISE],
+      streamMuxer: [MPLEX]
+    },
+    addresses: {
+      listen: ['/ip4/127.0.0.1/tcp/0/ws']
+    },
+    rendezvous: {
+      enabled: true,
+      rendezvousPoints: [rendezvousServerMultiaddr]
+    }
+  })
+
+  await node.start()
+  console.log(`Node started with id ${node.peerId.toB58String()}`)
+
+  for await (const reg of node.rendezvous.discover(ns)) {
+    const e = await Envelope.openAndCertify(reg.signedPeerRecord, PeerRecord.DOMAIN)
+    const rec = PeerRecord.createFromProtobuf(e.payload)
+
+    console.log(`Discovered peer with id: ${rec.peerId.toB58String()} and multiaddrs ${rec.multiaddrs}`)
+  }
+}
+
+main()
--- a/examples/discovery-mechanisms/rendezvous/listener.js
+++ b/examples/discovery-mechanisms/rendezvous/listener.js
@@ -0,0 +1,43 @@
+'use strict'
+
+const Libp2p = require('../../../src')
+const Websockets = require('libp2p-websockets')
+const { NOISE } = require('libp2p-noise')
+const MPLEX = require('libp2p-mplex')
+
+const multiaddr = require('multiaddr')
+
+async function main () {
+  const rendezvousServerAddr = process.argv[2]
+  if (!rendezvousServerAddr) {
+    throw new Error('the rendezvous server address needs to be specified as a parameter')
+  }
+
+  const rendezvousServerMultiaddr = multiaddr(rendezvousServerAddr)
+  const ns = 'example-namespace'
+
+  const node = await Libp2p.create({
+    modules: {
+      transport: [Websockets],
+      connEncryption: [NOISE],
+      streamMuxer: [MPLEX]
+    },
+    addresses: {
+      listen: ['/ip4/127.0.0.1/tcp/0/ws']
+    },
+    rendezvous: {
+      enabled: true,
+      rendezvousPoints: [rendezvousServerMultiaddr]
+    }
+  })
+
+  await node.start()
+  console.log(`Node started with id ${node.peerId.toB58String()}`)
+  console.log('Node listening on:')
+  node.multiaddrs.forEach((m) => console.log(`${m}/p2p/${node.peerId.toB58String()}`))
+
+  await node.rendezvous.register(ns)
+  console.log('Registered to: ', ns)
+}
+
+main()
--- a/examples/discovery-mechanisms/rendezvous/test.js
+++ b/examples/discovery-mechanisms/rendezvous/test.js
@@ -0,0 +1,84 @@
+'use strict'
+
+const path = require('path')
+const execa = require('execa')
+const delay = require('delay')
+const pDefer = require('p-defer')
+const uint8ArrayToString = require('uint8arrays/to-string')
+
+const { createRendezvousServer } = require('../../../test/rendezvous/utils')
+
+function startProcess(name, args = []) {
+  return execa('node', [path.join(__dirname, name), ...args], {
+    cwd: path.resolve(__dirname),
+    all: true
+  })
+}
+
+async function test() {
+  let output1 = ''
+  let output2 = ''
+  const proc1Ready = pDefer()
+  const proc2Ready = pDefer()
+
+  // Start Rendezvous Server
+  const rendezvousServer = await createRendezvousServer({
+    config: {
+      addresses: {
+        listen: ['/ip4/127.0.0.1/tcp/0/ws']
+      }
+    }
+  })
+
+  // Wait for server to be listenning
+  await delay(1000)
+  const rendezvousServerMa = `${rendezvousServer.multiaddrs[0]}/p2p/${rendezvousServer.peerId.toB58String()}`
+
+  // Step 1 process
+  process.stdout.write('listener.js\n')
+
+  const proc1 = startProcess('listener.js', [rendezvousServerMa])
+  proc1.all.on('data', async (data) => {
+    process.stdout.write(data)
+
+    output1 += uint8ArrayToString(data)
+
+    if (output1.includes('Node listening on:') && output1.includes('Registered to:')) {
+      proc1Ready.resolve()
+    }
+  })
+
+  await proc1Ready.promise
+  process.stdout.write('==================================================================\n')
+
+  // Step 2 process
+  process.stdout.write('dialer.js\n')
+
+  const proc2 = startProcess('dialer.js', [rendezvousServerMa])
+  proc2.all.on('data', async (data) => {
+    process.stdout.write(data)
+
+    output2 += uint8ArrayToString(data)
+
+    if (output2.includes('Discovered peer with id:')) {
+      proc2Ready.resolve()
+      proc2.kill()
+      proc1.kill()
+    }
+  })
+
+  await proc2Ready.promise
+
+  await Promise.all([
+    proc1,
+    proc2
+  ]).catch((err) => {
+    if (err.signal !== 'SIGTERM') {
+      throw err
+    }
+  })
+
+  await rendezvousServer.stop()
+}
+
+module.exports = test
--- a/examples/discovery-mechanisms/test-1.js
+++ b/examples/discovery-mechanisms/test-1.js
@@ -1,14 +1,42 @@
 'use strict'

 const path = require('path')
-const { waitForOutput } = require('../utils')
+const execa = require('execa')
+const pWaitFor = require('p-wait-for')
+const uint8ArrayToString = require('uint8arrays/to-string')
+const bootstrapers = require('./bootstrapers')
+
+const discoveredCopy = 'Discovered:'
+const connectedCopy = 'Connection established to:'

 async function test () {
+  const discoveredNodes = []
+  const connectedNodes = []
+
  process.stdout.write('1.js\n')

-  await waitForOutput('Connection established to:', 'node', [path.join(__dirname, '1.js')], {
-    cwd: __dirname
+  const proc = execa('node', [path.join(__dirname, '1.js')], {
+    cwd: path.resolve(__dirname),
+    all: true
  })
+
+  proc.all.on('data', async (data) => {
+    process.stdout.write(data)
+    const line = uint8ArrayToString(data)
+
+    // Discovered or Connected
+    if (line.includes(discoveredCopy)) {
+      const id = line.trim().split(discoveredCopy)[1]
+      discoveredNodes.push(id)
+    } else if (line.includes(connectedCopy)) {
+      const id = line.trim().split(connectedCopy)[1]
+      connectedNodes.push(id)
+    }
+  })
+
+  await pWaitFor(() => discoveredNodes.length === bootstrapers.length && connectedNodes.length === bootstrapers.length)
+
+  proc.kill()
 }

 module.exports = test
--- a/examples/discovery-mechanisms/test-2.js
+++ b/examples/discovery-mechanisms/test-2.js
@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pWaitFor = require('p-wait-for')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
+const uint8ArrayToString = require('uint8arrays/to-string')

 const discoveredCopy = 'Discovered:'

--- a/examples/discovery-mechanisms/test-3.js
+++ b/examples/discovery-mechanisms/test-3.js
@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pWaitFor = require('p-wait-for')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
+const uint8ArrayToString = require('uint8arrays/to-string')

 const discoveredCopy = 'discovered:'

--- a/examples/discovery-mechanisms/test.js
+++ b/examples/discovery-mechanisms/test.js
@@ -3,11 +3,13 @@
 const test1 = require('./test-1')
 const test2 = require('./test-2')
 const test3 = require('./test-3')
+const testRendezvous = require('./rendezvous/test')

 async function test () {
  await test1()
  await test2()
  await test3()
+  await testRendezvous()
 }

 module.exports = test
--- a/examples/echo/src/dialer.js
+++ b/examples/echo/src/dialer.js
@@ -6,7 +6,7 @@
 */

 const PeerId = require('peer-id')
-const createLibp2p = require('./libp2p')
+const createLibp2p = require('./libp2p-bundle')
 const pipe = require('it-pipe')

 async function run() {
--- a/examples/echo/src/libp2p-bundle.js
+++ b/examples/echo/src/libp2p-bundle.js
@@ -3,7 +3,7 @@
 const TCP = require('libp2p-tcp')
 const WS = require('libp2p-websockets')
 const mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')

 const defaultsDeep = require('@nodeutils/defaults-deep')
 const libp2p = require('../../..')
--- a/examples/echo/src/listener.js
+++ b/examples/echo/src/listener.js
@@ -6,7 +6,7 @@
 */

 const PeerId = require('peer-id')
-const createLibp2p = require('./libp2p')
+const createLibp2p = require('./libp2p-bundle')
 const pipe = require('it-pipe')

 async function run() {
--- a/examples/echo/test.js
+++ b/examples/echo/test.js
@@ -1,61 +0,0 @@
-'use strict'
-
-const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-
-function startProcess(name) {
-  return execa('node', [path.join(__dirname, name)], {
-    cwd: path.resolve(__dirname),
-    all: true
-  })
-}
-
-async function test () {
-  const listenerReady = pDefer()
-  const messageReceived = pDefer()
-
-  // Step 1 process
-  process.stdout.write('node listener.js\n')
-  const listenerProc = startProcess('src/listener.js')
-  listenerProc.all.on('data', async (data) => {
-    process.stdout.write(data)
-    const s = uint8ArrayToString(data)
-
-    if (s.includes('Listener ready, listening on:')) {
-      listenerReady.resolve()
-    }
-  })
-
-  await listenerReady.promise
-  process.stdout.write('==================================================================\n')
-
-  // Step 2 process
-  process.stdout.write('node dialer.js\n')
-  const dialerProc = startProcess('src/dialer.js')
-  dialerProc.all.on('data', async (data) => {
-    process.stdout.write(data)
-    const s = uint8ArrayToString(data)
-
-    if (s.includes('received echo:')) {
-      messageReceived.resolve()
-    }
-  })
-
-  await messageReceived.promise
-  process.stdout.write('echo message received\n')
-
-  listenerProc.kill()
-  dialerProc.kill()
-  await Promise.all([
-    listenerProc,
-    dialerProc
-  ]).catch((err) => {
-    if (err.signal !== 'SIGTERM') {
-      throw err
-    }
-  })
-}
-
-module.exports = test
--- a/examples/encrypted-communications/1.js
+++ b/examples/encrypted-communications/1.js
@@ -1,9 +1,9 @@
 'use strict'

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

 const pipe = require('it-pipe')

@@ -30,7 +30,7 @@ const createNode = async () => {
    createNode()
  ])

-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)

  node2.handle('/a-protocol', ({ stream }) => {
    pipe(
--- a/examples/encrypted-communications/README.md
+++ b/examples/encrypted-communications/README.md
@@ -1,4 +1,4 @@
-# Connection Encryption
+# Encrypted Communications

 libp2p can leverage the encrypted communications from the transports it uses (i.e WebRTC). To ensure that every connection is encrypted, independently of how it was set up, libp2p also supports a set of modules that encrypt every communication established.

@@ -8,13 +8,13 @@ A byproduct of having these encrypted communications modules is that we can auth

 # 1. Set up encrypted communications

-We will build this example on top of example for [Protocol and Stream Multiplexing](../protocol-and-stream-multiplexing). You will need the `@chainsafe/libp2p-noise` module to complete it, go ahead and `npm install @chainsafe/libp2p-noise`.
+We will build this example on top of example for [Protocol and Stream Multiplexing](../protocol-and-stream-multiplexing). You will need the `libp2p-noise` module to complete it, go ahead and `npm install libp2p-noise`.

 To add them to your libp2p configuration, all you have to do is:

 ```JavaScript
 const Libp2p = require('libp2p')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')

 const createNode = () => {
  return Libp2p.create({
--- a/examples/libp2p-in-the-browser/.babelrc
+++ b/examples/libp2p-in-the-browser/.babelrc
@@ -1,3 +1,4 @@
 {
+  "presets": ["@babel/preset-env"],
  "plugins": ["syntax-async-functions","transform-regenerator"]
 }
--- a/examples/libp2p-in-the-browser/README.md
+++ b/examples/libp2p-in-the-browser/README.md
@@ -4,13 +4,9 @@ This example leverages the [Parcel.js bundler](https://parceljs.org/) to compile

 ## Setup

-In order to run the example:
-
- Install dependencey at the root of the js-libp2p repository (if not already done), 
- then, install the dependencies from same directory as this README:
+In order to run the example, first install the dependencies from same directory as this README:

 ```
-npm install
 cd ./examples/libp2p-in-the-browser
 npm install
 ```
--- a/examples/libp2p-in-the-browser/index.html
+++ b/examples/libp2p-in-the-browser/index.html
@@ -16,7 +16,7 @@
      <pre id="output"></pre>
    </main>

-    <script type="module" src="./index.js"></script>
+    <script src="./index.js"></script>

  </body>

--- a/examples/libp2p-in-the-browser/index.js
+++ b/examples/libp2p-in-the-browser/index.js
@@ -2,7 +2,7 @@ import 'babel-polyfill'
 import Libp2p from 'libp2p'
 import Websockets from 'libp2p-websockets'
 import WebRTCStar from 'libp2p-webrtc-star'
-import { NOISE } from '@chainsafe/libp2p-noise'
+import { NOISE } from 'libp2p-noise'
 import Mplex from 'libp2p-mplex'
 import Bootstrap from 'libp2p-bootstrap'

--- a/examples/libp2p-in-the-browser/package.json
+++ b/examples/libp2p-in-the-browser/package.json
@@ -2,6 +2,7 @@
  "name": "libp2p-in-browser",
  "version": "1.0.0",
  "description": "A libp2p node running in the browser",
+  "main": "index.js",
  "browserslist": [
    "last 2 Chrome versions"
  ],
@@ -14,19 +15,20 @@
  "author": "",
  "license": "ISC",
  "dependencies": {
-    "@chainsafe/libp2p-noise": "^5.0.2",
+    "@babel/preset-env": "^7.8.3",
    "libp2p": "../../",
-    "libp2p-bootstrap": "^0.14.0",
-    "libp2p-mplex": "^0.10.4",
-    "libp2p-webrtc-star": "^0.25.0",
-    "libp2p-websockets": "^0.16.1"
+    "libp2p-bootstrap": "^0.12.1",
+    "libp2p-mplex": "^0.10.0",
+    "libp2p-noise": "^2.0.0",
+    "libp2p-webrtc-star": "^0.20.0",
+    "libp2p-websockets": "^0.14.0"
  },
  "devDependencies": {
-    "@babel/cli": "^7.13.10",
-    "@babel/core": "^7.13.0",
+    "@babel/cli": "^7.8.3",
+    "@babel/core": "^7.8.3",
    "babel-plugin-syntax-async-functions": "^6.13.0",
    "babel-plugin-transform-regenerator": "^6.26.0",
    "babel-polyfill": "^6.26.0",
-    "parcel": "^2.0.1"
+    "parcel-bundler": "^1.12.4"
  }
 }
--- a/examples/libp2p-in-the-browser/test.js
+++ b/examples/libp2p-in-the-browser/test.js
@@ -17,10 +17,10 @@ async function run() {
    const out = chunk.toString()

    if (out.includes('Server running at')) {
-      url = out.split('Server running at ')[1]
+      url = out.replace('Server running at ', '')
    }

-    if (out.includes('Built in')) {
+    if (out.includes('✨  Built in ')) {
      try {
        const browser = await chromium.launch();
        const page = await browser.newPage();
@@ -38,7 +38,7 @@ async function run() {
        )
        await browser.close();

-      } catch (/** @type {any} */ err) {
+      } catch (err) {
        console.error(err)
        process.exit(1)
      } finally {
--- a/examples/package.json
+++ b/examples/package.json
@@ -8,18 +8,14 @@
  },
  "license": "MIT",
  "dependencies": {
-    "@achingbrain/libp2p-gossipsub": "^0.12.2",
    "execa": "^2.1.0",
    "fs-extra": "^8.1.0",
-    "libp2p": "../src",
-    "libp2p-pubsub-peer-discovery": "^4.0.0",
-    "libp2p-relay-server": "^0.3.0",
+    "libp2p-pubsub-peer-discovery": "^3.0.0",
+    "libp2p-relay-server": "^0.1.2",
    "p-defer": "^3.0.0",
-    "uint8arrays": "^3.0.0",
    "which": "^2.0.1"
  },
  "devDependencies": {
-    "https": "^1.0.0",
    "playwright": "^1.7.1"
  }
 }
--- a/examples/peer-and-content-routing/1.js
+++ b/examples/peer-and-content-routing/1.js
@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const KadDHT = require('libp2p-kad-dht')

 const delay = require('delay')
@@ -38,8 +38,8 @@ const createNode = async () => {
    createNode()
  ])

-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)

  await Promise.all([
    node1.dial(node2.peerId),
--- a/examples/peer-and-content-routing/2.js
+++ b/examples/peer-and-content-routing/2.js
@@ -4,8 +4,8 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
-const { CID } = require('multiformats/cid')
+const { NOISE } = require('libp2p-noise')
+const CID = require('cids')
 const KadDHT = require('libp2p-kad-dht')

 const all = require('it-all')
@@ -40,8 +40,8 @@ const createNode = async () => {
    createNode()
  ])

-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)

  await Promise.all([
    node1.dial(node2.peerId),
@@ -51,10 +51,10 @@ const createNode = async () => {
  // Wait for onConnect handlers in the DHT
  await delay(100)

-  const cid = CID.parse('QmTp9VkYvnHyrqKQuFPiuZkiX9gPcqj6x5LJ1rmWuSySnL')
+  const cid = new CID('QmTp9VkYvnHyrqKQuFPiuZkiX9gPcqj6x5LJ1rmWuSySnL')
  await node1.contentRouting.provide(cid)

-  console.log('Node %s is providing %s', node1.peerId.toB58String(), cid.toString())
+  console.log('Node %s is providing %s', node1.peerId.toB58String(), cid.toBaseEncodedString())

  // wait for propagation
  await delay(300)
--- a/examples/peer-and-content-routing/README.md
+++ b/examples/peer-and-content-routing/README.md
@@ -43,8 +43,8 @@ const node1 = nodes[0]
 const node2 = nodes[1]
 const node3 = nodes[2]

-await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)

 await Promise.all([
  node1.dial(node2.peerId),
@@ -81,7 +81,7 @@ Instead of calling `peerRouting.findPeer`, we will use `contentRouting.provide`

 ```JavaScript
 await node1.contentRouting.provide(cid)
-console.log('Node %s is providing %s', node1.peerId.toB58String(), cid.toString())
+console.log('Node %s is providing %s', node1.peerId.toB58String(), cid.toBaseEncodedString())

 const provs = await all(node3.contentRouting.findProviders(cid, { timeout: 5000 }))

--- a/examples/peer-and-content-routing/test-1.js
+++ b/examples/peer-and-content-routing/test-1.js
@@ -1,14 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { waitForOutput } = require('../utils')
-
-async function test () {
-  process.stdout.write('1.js\n')
-
-  await waitForOutput('Found it, multiaddrs are:', 'node', [path.join(__dirname, '1.js')], {
-    cwd: __dirname
-  })
-}
-
-module.exports = test
--- a/examples/peer-and-content-routing/test-2.js
+++ b/examples/peer-and-content-routing/test-2.js
@@ -1,14 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { waitForOutput } = require('../utils')
-
-async function test () {
-  process.stdout.write('2.js\n')
-
-  await waitForOutput('Found provider:', 'node', [path.join(__dirname, '2.js')], {
-    cwd: __dirname
-  })
-}
-
-module.exports = test
--- a/examples/peer-and-content-routing/test.js
+++ b/examples/peer-and-content-routing/test.js
@@ -1,11 +0,0 @@
-'use strict'
-
-const test1 = require('./test-1')
-const test2 = require('./test-2')
-
-async function test() {
-  await test1()
-  await test2()
-}
-
-module.exports = test
--- a/examples/pnet/index.js
+++ b/examples/pnet/index.js
@@ -29,7 +29,7 @@ generate(otherSwarmKey)
  console.log('nodes started...')

  // Add node 2 data to node1's PeerStore
-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
  await node1.dial(node2.peerId)

  node2.handle('/private', ({ stream }) => {
--- a/examples/pnet/libp2p-node.js
+++ b/examples/pnet/libp2p-node.js
@@ -3,7 +3,7 @@
 const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const Protector = require('libp2p/src/pnet')

 /**
--- a/examples/pnet/test.js
+++ b/examples/pnet/test.js
@@ -1,13 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { waitForOutput } = require('../utils')
-
-async function test () {
-  await waitForOutput('This message is sent on a private network', 'node', [path.join(__dirname, 'index.js')], {
-    cwd: __dirname
-  })
-}
-
-module.exports = test
-
--- a/examples/protocol-and-stream-muxing/1.js
+++ b/examples/protocol-and-stream-muxing/1.js
@@ -3,7 +3,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')

 const pipe = require('it-pipe')

@@ -31,7 +31,7 @@ const createNode = async () => {
  ])

  // Add node's 2 data to the PeerStore
-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)

  // exact matching
  node2.handle('/your-protocol', ({ stream }) => {
--- a/examples/protocol-and-stream-muxing/2.js
+++ b/examples/protocol-and-stream-muxing/2.js
@@ -3,7 +3,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')

 const pipe = require('it-pipe')

@@ -31,7 +31,7 @@ const createNode = async () => {
  ])

  // Add node's 2 data to the PeerStore
-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)

  node2.handle(['/a', '/b'], ({ protocol, stream }) => {
    pipe(
--- a/examples/protocol-and-stream-muxing/3.js
+++ b/examples/protocol-and-stream-muxing/3.js
@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')

 const pipe = require('it-pipe')

@@ -32,8 +32,8 @@ const createNode = async () => {
  ])

  // Add node's 2 data to the PeerStore
-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  
  node1.handle('/node-1', ({ stream }) => {
    pipe(
      stream,
--- a/examples/protocol-and-stream-muxing/README.md
+++ b/examples/protocol-and-stream-muxing/README.md
@@ -20,7 +20,7 @@ const node1 = nodes[0]
 const node2 = nodes[1]

 // Add node's 2 data to the PeerStore
-await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)

 // Here we are telling libp2p that if someone dials this node to talk with the `/your-protocol`
 // multicodec, the protocol identifier, please call this handler and give it the stream
--- a/examples/protocol-and-stream-muxing/test-1.js
+++ b/examples/protocol-and-stream-muxing/test-1.js
@@ -1,14 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { waitForOutput } = require('../utils')
-
-async function test () {
-  process.stdout.write('1.js\n')
-
-  await waitForOutput('my own protocol, wow!', 'node', [path.join(__dirname, '1.js')], {
-    cwd: __dirname
-  })
-}
-
-module.exports = test
--- a/examples/protocol-and-stream-muxing/test-2.js
+++ b/examples/protocol-and-stream-muxing/test-2.js
@@ -1,14 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { waitForOutput } = require('../utils')
-
-async function test () {
-  process.stdout.write('2.js\n')
-
-  await waitForOutput('another stream on protocol (b)', 'node', [path.join(__dirname, '2.js')], {
-    cwd: __dirname
-  })
-}
-
-module.exports = test
--- a/examples/protocol-and-stream-muxing/test-3.js
+++ b/examples/protocol-and-stream-muxing/test-3.js
@@ -1,14 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { waitForOutput } = require('../utils')
-
-async function test () {
-  process.stdout.write('3.js\n')
-
-  await waitForOutput('from 2 to 1', 'node', [path.join(__dirname, '3.js')], {
-    cwd: __dirname
-  })
-}
-
-module.exports = test
--- a/examples/protocol-and-stream-muxing/test.js
+++ b/examples/protocol-and-stream-muxing/test.js
@@ -1,13 +0,0 @@
-'use strict'
-
-const test1 = require('./test-1')
-const test2 = require('./test-2')
-const test3 = require('./test-3')
-
-async function test() {
-  await test1()
-  await test2()
-  await test3()
-}
-
-module.exports = test
--- a/examples/pubsub/1.js
+++ b/examples/pubsub/1.js
@@ -4,10 +4,10 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
-const Gossipsub = require('@achingbrain/libp2p-gossipsub')
-const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
+const { NOISE } = require('libp2p-noise')
+const Gossipsub = require('libp2p-gossipsub')
+const uint8ArrayFromString = require('uint8arrays/from-string')
+const uint8ArrayToString = require('uint8arrays/to-string')

 const createNode = async () => {
  const node = await Libp2p.create({
@@ -35,19 +35,19 @@ const createNode = async () => {
  ])

  // Add node's 2 data to the PeerStore
-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
  await node1.dial(node2.peerId)

  node1.pubsub.on(topic, (msg) => {
    console.log(`node1 received: ${uint8ArrayToString(msg.data)}`)
  })
-  node1.pubsub.subscribe(topic)
+  await node1.pubsub.subscribe(topic)

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

  // node2 publishes "news" every second
  setInterval(() => {
--- a/examples/pubsub/README.md
+++ b/examples/pubsub/README.md
@@ -8,10 +8,6 @@ We've seen many interesting use cases appear with this, here are some highlights
 - [IPFS PubSub (using libp2p-floodsub) for IoT](https://www.youtube.com/watch?v=qLpM5pBDGiE).
 - [Real Time distributed Applications](https://www.youtube.com/watch?v=vQrbxyDPSXg)

-## 0. Set up the example
-
-Before moving into the examples, you should run `npm install` on the top level `js-libp2p` folder, in order to install all the dependencies needed for this example. In addition, you will need to install the example related dependencies by doing `cd examples && npm install`. Once the install finishes, you should move into the example folder with `cd pubsub`.
-
 ## 1. Setting up a simple PubSub network on top of libp2p

 For this example, we will use MulticastDNS for automatic Peer Discovery. This example is based the previous examples found in [Discovery Mechanisms](../discovery-mechanisms). You can find the complete version at [1.js](./1.js).
@@ -41,31 +37,29 @@ const node = await Libp2p.create({
 Once that is done, we only need to create a few libp2p nodes, connect them and everything is ready to start using pubsub.

 ```JavaScript
-const { fromString } = require('uint8arrays/from-string')
-const { toString } = require('uint8arrays/to-string')
 const topic = 'news'

 const node1 = nodes[0]
 const node2 = nodes[1]

 // Add node's 2 data to the PeerStore
-await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
 await node1.dial(node2.peerId)

 node1.pubsub.on(topic, (msg) => {
-  console.log(`node1 received: ${toString(msg.data)}`)
+  console.log(`node1 received: ${uint8ArrayToString(msg.data)}`)
 })
 await node1.pubsub.subscribe(topic)

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

 // node2 publishes "news" every second
 setInterval(() => {
-  node2.pubsub.publish(topic, fromString('Bird bird bird, bird is the word!'))
+  node2.pubsub.publish(topic, uint8ArrayFromString('Bird bird bird, bird is the word!'))
 }, 1000)
 ```

--- a/examples/pubsub/message-filtering/1.js
+++ b/examples/pubsub/message-filtering/1.js
@@ -4,10 +4,10 @@
 const Libp2p = require('../../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
-const Gossipsub = require('@achingbrain/libp2p-gossipsub')
-const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
+const { NOISE } = require('libp2p-noise')
+const Gossipsub = require('libp2p-gossipsub')
+const uint8ArrayFromString = require('uint8arrays/from-string')
+const uint8ArrayToString = require('uint8arrays/to-string')

 const createNode = async () => {
  const node = await Libp2p.create({
@@ -36,10 +36,10 @@ const createNode = async () => {
  ])

  // node1 conect to node2 and node2 conect to node3
-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
  await node1.dial(node2.peerId)

-  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
  await node2.dial(node3.peerId)

  //subscribe
--- a/examples/pubsub/message-filtering/README.md
+++ b/examples/pubsub/message-filtering/README.md
@@ -32,10 +32,10 @@ const [node1, node2, node3] = await Promise.all([
  createNode(),
 ])

-await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
 await node1.dial(node2.peerId)

-await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
 await node2.dial(node3.peerId)
 ```

--- a/examples/pubsub/message-filtering/test.js
+++ b/examples/pubsub/message-filtering/test.js
@@ -1,67 +0,0 @@
-'use strict'
-
-const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-
-const stdout = [
-  {
-    topic: 'banana',
-    messageCount: 2
-  },
-  {
-    topic: 'apple',
-    messageCount: 2
-  },
-  {
-    topic: 'car',
-    messageCount: 0
-  },
-  {
-    topic: 'orange',
-    messageCount: 2
-  },
-]
-
-async function test () {
-  const defer = pDefer()
-  let topicCount = 0
-  let topicMessageCount = 0
-
-  process.stdout.write('message-filtering/1.js\n')
-
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
-  })
-
-  proc.all.on('data', async (data) => {
-    // End
-    if (topicCount === stdout.length) {
-      defer.resolve()
-      proc.all.removeAllListeners('data')
-    }
-
-    process.stdout.write(data)
-    const line = uint8ArrayToString(data)
-
-    if (stdout[topicCount] && line.includes(stdout[topicCount].topic)) {
-      // Validate previous number of messages
-      if (topicCount > 0 && topicMessageCount > stdout[topicCount - 1].messageCount) {
-        defer.reject()
-        throw new Error(`topic ${stdout[topicCount - 1].topic} had ${topicMessageCount} messages instead of ${stdout[topicCount - 1].messageCount}`)
-      }
-
-      topicCount++
-      topicMessageCount = 0
-    } else {
-      topicMessageCount++
-    }
-  })
-
-  await defer.promise
-  proc.kill()
-}
-
-module.exports = test
--- a/examples/pubsub/test-1.js
+++ b/examples/pubsub/test-1.js
@@ -1,30 +0,0 @@
-'use strict'
-
-const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-
-async function test () {
-  const defer = pDefer()
-  process.stdout.write('1.js\n')
-
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
-  })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-    const line = uint8ArrayToString(data)
-
-    if (line.includes('node1 received: Bird bird bird, bird is the word!')) {
-      defer.resolve()
-    }
-  })
-
-  await defer.promise
-  proc.kill()
-}
-
-module.exports = test
--- a/examples/pubsub/test.js
+++ b/examples/pubsub/test.js
@@ -1,11 +0,0 @@
-'use strict'
-
-const test1 = require('./test-1')
-const testMessageFiltering = require('./message-filtering/test')
-
-async function test() {
-  await test1()
-  await testMessageFiltering()
-}
-
-module.exports = test
--- a/examples/transports/1.js
+++ b/examples/transports/1.js
@@ -3,7 +3,7 @@

 const Libp2p = require('../..')
 const TCP = require('libp2p-tcp')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')

 const createNode = async () => {
  const node = await Libp2p.create({
--- a/examples/transports/2.js
+++ b/examples/transports/2.js
@@ -3,7 +3,7 @@

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

 const pipe = require('it-pipe')
@@ -49,7 +49,7 @@ function printAddrs (node, number) {
    console.log(result.toString())
  })

-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
  const { stream } = await node1.dialProtocol(node2.peerId, '/print')

  await pipe(
--- a/examples/transports/3.js
+++ b/examples/transports/3.js
@@ -4,7 +4,7 @@
 const Libp2p = require('../..')
 const TCP = require('libp2p-tcp')
 const WebSockets = require('libp2p-websockets')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')
 const MPLEX = require('libp2p-mplex')

 const pipe = require('it-pipe')
@@ -60,9 +60,9 @@ function print ({ stream }) {
  node2.handle('/print', print)
  node3.handle('/print', print)

-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
-  await node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)

  // node 1 (TCP) dials to node 2 (TCP+WebSockets)
  const { stream } = await node1.dialProtocol(node2.peerId, '/print')
@@ -81,7 +81,7 @@ function print ({ stream }) {
  // node 3 (listening WebSockets) can dial node 1 (TCP)
  try {
    await node3.dialProtocol(node1.peerId, '/print')
-  } catch (/** @type {any} */ err) {
+  } catch (err) {
    console.log('node 3 failed to dial to node 1 with:', err.message)
  }
 })();
--- a/examples/transports/4.js
+++ b/examples/transports/4.js
@@ -1,89 +0,0 @@
-/* eslint-disable no-console */
-'use strict'
-
-const Libp2p = require('../..')
-const TCP = require('libp2p-tcp')
-const WebSockets = require('libp2p-websockets')
-const { NOISE } = require('@chainsafe/libp2p-noise')
-const MPLEX = require('libp2p-mplex')
-
-const fs = require('fs');
-const https = require('https');
-const pipe = require('it-pipe')
-
-const transportKey = WebSockets.prototype[Symbol.toStringTag];
-
-const httpServer = https.createServer({
-  cert: fs.readFileSync('./test_certs/cert.pem'),
-  key: fs.readFileSync('./test_certs/key.pem'),
-});
-
-const createNode = async (addresses = []) => {
-  if (!Array.isArray(addresses)) {
-    addresses = [addresses]
-  }
-
-  const node = await Libp2p.create({
-    addresses: {
-      listen: addresses
-    },
-    modules: {
-      transport: [WebSockets],
-      connEncryption: [NOISE],
-      streamMuxer: [MPLEX]
-    },
-    config: {
-      peerDiscovery: {
-        // Disable autoDial as it would fail because we are using a self-signed cert.
-        // `dialProtocol` does not fail because we pass `rejectUnauthorized: false`.
-        autoDial: false
-      },
-      transport: {
-        [transportKey]: {
-          listenerOptions: { server: httpServer },
-        },
-      },
-    }
-  })
-
-  await node.start()
-  return node
-}
-
-function printAddrs(node, number) {
-  console.log('node %s is listening on:', number)
-  node.multiaddrs.forEach((ma) => console.log(`${ma.toString()}/p2p/${node.peerId.toB58String()}`))
-}
-
-function print ({ stream }) {
-  pipe(
-    stream,
-    async function (source) {
-      for await (const msg of source) {
-        console.log(msg.toString())
-      }
-    }
-  )
-}
-
-;(async () => {
-  const [node1, node2] = await Promise.all([
-    createNode('/ip4/127.0.0.1/tcp/10000/wss'),
-    createNode([])
-  ])
-
-  printAddrs(node1, '1')
-  printAddrs(node2, '2')
-
-  node1.handle('/print', print)
-  node2.handle('/print', print)
-
-  const targetAddr = `${node1.multiaddrs[0]}/p2p/${node1.peerId.toB58String()}`;
-
-  // node 2 (Secure WebSockets) dials to node 1 (Secure Websockets)
-  const { stream } = await node2.dialProtocol(targetAddr, '/print',  { websocket: { rejectUnauthorized: false } })
-  await pipe(
-    ['node 2 dialed to node 1 successfully'],
-    stream
-  )
-})();
--- a/examples/transports/README.md
+++ b/examples/transports/README.md
@@ -13,7 +13,7 @@ When using libp2p, you need properly configure it, that is, pick your set of mod
 You will need 4 dependencies total, so go ahead and install all of them with:

 ```bash
-> npm install libp2p libp2p-tcp @chainsafe/libp2p-noise
+> npm install libp2p libp2p-tcp libp2p-noise
 ```

 Then, in your favorite text editor create a file with the `.js` extension. I've called mine `1.js`.
@@ -25,7 +25,7 @@ First thing is to create our own libp2p node! Insert:

 const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
-const { NOISE } = require('@chainsafe/libp2p-noise')
+const { NOISE } = require('libp2p-noise')

 const createNode = async () => {
  const node = await Libp2p.create({
@@ -91,7 +91,7 @@ const concat = require('it-concat')
 const MPLEX = require('libp2p-mplex')
 ```

-We are going to reuse the `createNode` function from step 1, but this time add a stream multiplexer from `libp2p-mplex`.
+We are going to reuse the `createNode` function from step 1, but this time add a stream multiplexer from `libp2p-mplex`. 
 ```js
 const createNode = async () => {
  const node = await Libp2p.create({
@@ -140,7 +140,7 @@ Then add,
    console.log(result.toString())
  })

-  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
  const { stream } = await node1.dialProtocol(node2.peerId, '/print')

  await pipe(
@@ -224,9 +224,9 @@ node1.handle('/print', print)
 node2.handle('/print', print)
 node3.handle('/print', print)

-await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
-await node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)
+node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)

 // node 1 (TCP) dials to node 2 (TCP+WebSockets)
 const { stream } = await node1.dialProtocol(node2.peerId, '/print')
--- a/examples/transports/test-1.js
+++ b/examples/transports/test-1.js
@@ -1,14 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { waitForOutput } = require('../utils')
-
-async function test () {
-  process.stdout.write('1.js\n')
-
-  await waitForOutput('/p2p/', 'node', [path.join(__dirname, '1.js')], {
-    cwd: __dirname
-  })
-}
-
-module.exports = test
--- a/examples/transports/test-2.js
+++ b/examples/transports/test-2.js
@@ -1,14 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { waitForOutput } = require('../utils')
-
-async function test () {
-  process.stdout.write('2.js\n')
-
-  await waitForOutput('Hello p2p world!', 'node', [path.join(__dirname, '2.js')], {
-    cwd: __dirname
-  })
-}
-
-module.exports = test
--- a/examples/transports/test-3.js
+++ b/examples/transports/test-3.js
@@ -1,14 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { waitForOutput } = require('../utils')
-
-async function test () {
-  process.stdout.write('3.js\n')
-
-  await waitForOutput('node 3 failed to dial to node 1 with:', 'node', [path.join(__dirname, '3.js')], {
-    cwd: __dirname
-  })
-}
-
-module.exports = test
--- a/examples/transports/test-4.js
+++ b/examples/transports/test-4.js
@@ -1,14 +0,0 @@
-'use strict'
-
-const path = require('path')
-const { waitForOutput } = require('../utils')
-
-async function test () {
-  process.stdout.write('4.js\n')
-
-  await waitForOutput('node 2 dialed to node 1 successfully', 'node', [path.join(__dirname, '4.js')], {
-    cwd: __dirname
-  })
-}
-
-module.exports = test
--- a/examples/transports/test.js
+++ b/examples/transports/test.js
@@ -1,15 +0,0 @@
-'use strict'
-
-const test1 = require('./test-1')
-const test2 = require('./test-2')
-const test3 = require('./test-3')
-const test4 = require('./test-4')
-
-async function test() {
-  await test1()
-  await test2()
-  await test3()
-  await test4()
-}
-
-module.exports = test
--- a/examples/transports/test_certs/cert.pem
+++ b/examples/transports/test_certs/cert.pem
@@ -1,32 +0,0 @@
-----BEGIN CERTIFICATE-----
-MIIFlzCCA3+gAwIBAgIUMYedwb9L/BtvZ7Lhu71iSKrXsa4wDQYJKoZIhvcNAQEL
-BQAwajELMAkGA1UEBhMCVVMxCzAJBgNVBAgMAlZBMREwDwYDVQQHDAhTb21lQ2l0
-eTESMBAGA1UECgwJTXlDb21wYW55MRMwEQYDVQQLDApNeURpdmlzaW9uMRIwEAYD
-VQQDDAkxMjcuMC4wLjEwHhcNMjEwNDI4MDIzMjA5WhcNMjIwNDI4MDIzMjA5WjBq
-MQswCQYDVQQGEwJVUzELMAkGA1UECAwCVkExETAPBgNVBAcMCFNvbWVDaXR5MRIw
-EAYDVQQKDAlNeUNvbXBhbnkxEzARBgNVBAsMCk15RGl2aXNpb24xEjAQBgNVBAMM
-CTEyNy4wLjAuMTCCAiIwDQYJKoZIhvcNAQEBBQADggIPADCCAgoCggIBANNhXBu0
-GH1Kzl9iaQxCxEnyyAShS5FYScdKxqpYsgJT4poLWLQBZQEFLEqbdillIlTZqMss
-jWqkFL2xmjqdcnOKFEZUarntVE2hxFYYQex2Fi8MYwFj+Pvt74d02xPyfzFNFgyX
-a1EakoGBwClaf3I7jW7raPudjcf4HnwQ7r/NwiO8FqHFZgLcTnwI8bk+cxDoDAqu
-mhqMB5nnerqvKEyR9Fb2PoL+8PwOPJOOKTDVwLMeMJu2WLR8AU2FzOj5SVI2qsu9
-Ps5azysD8KQAMcw4y9s6do36SaMQS85fbvXBV7XBqMD34HPBUbFiCoFoaCzK9Zfb
-pCXyVJMUNmw5hyq9nbjUt4Kvr/58bU2gjUKSdPf6KhBxFnDZwl+2qqPdVIb/qtwz
-HExtJWq3upklXNOg3HoR6vcr1O9ReJHrzLRMEb51WP1aN/qJ2/lRskcZ4A806qwr
-W67BvnOg6s3ZtxHN9v3bsyfsvC66w8PEfCnCVxugC7cUW0gtW54AU75T3ukg7X+m
-vECr/+qIzNEBIxxCPgefCG/JAdJhQ5SCvoARAVPStUIWDmigDeOt7go5nKbdVIJ4
-7bbBFUhHT2mTHu30fHhRqSDcHzwE7Zz6YJIJmKq29UmzUazFnKlLU67MjLJwiDPm
-fC3GyOdAWkkZE5hjtkiy+3yWoEHhaJYRI1u3AgMBAAGjNTAzMAsGA1UdDwQEAwIE
-MDATBgNVHSUEDDAKBggrBgEFBQcDATAPBgNVHREECDAGhwR/AAABMA0GCSqGSIb3
-DQEBCwUAA4ICAQCx/ynu4iCQAK8VId/QQe7GqgOpFgx+6Mce9GQC6ZVEjAPgapsS
-Pl+l6+11cFjHKv0+Z/iN2JgkFmNXfwJcfYI0tHbMK+0U9hgKb1eFgiIwCqb4cPOz
-wMwusZ95BjIbtcEbL/+pMUpNhmjPz1fOILJZtDVq++lqJCv7t8+SoAmMVYtlcLNg
-muuV/UYR3uqvnAJmjgJVWs4otDGrxCYJE48M+9L2Gm05Htpi9WL1bZaQ+fJ85m85
-daedLc6R1/ZRTIH6i73sD4rYs0bx1fCJvkbcgXtKMHEkiHuG/MzR7Pa4cJAVKCx9
-lRTgrO7Gkllt2+jp4qg0YhdNq89e0DNA5cyB9H4udRgHQOcrlVRiX9OD/Kz+F5m/
-fQwMdbnqdg3ar5DSa8Q5g3bdLbNSCcI9sjCLTkNxUC/XTWGdG03RCVIt1qvBvZHk
-JaG6xGpbRZ5CN0T9eindd38JBrkPAPfgl6qhwvcqh6uVFYua+7KmF9K+mKarlmMw
-6RWaw2j4sMgUyRIS6fR9vDc20SrtoNvKQM1U6+0VYs1nizfkmsqqqRODmERKbKwc
-ahKJFubXfr8gz+PipAKFZbxr2EPAyoiNkx+0eM6Eedo55oP2BoGHEfXEoAonyMFM
-F/xTbpFtdRYE2hwsZCk86fpbcPTmdCY8txeZ7+4Bme2d9XXsTAxF64usqQ==
-----END CERTIFICATE-----
--- a/examples/transports/test_certs/key.pem
+++ b/examples/transports/test_certs/key.pem
@@ -1,52 +0,0 @@
-----BEGIN PRIVATE KEY-----
-MIIJRAIBADANBgkqhkiG9w0BAQEFAASCCS4wggkqAgEAAoICAQDTYVwbtBh9Ss5f
-YmkMQsRJ8sgEoUuRWEnHSsaqWLICU+KaC1i0AWUBBSxKm3YpZSJU2ajLLI1qpBS9
-sZo6nXJzihRGVGq57VRNocRWGEHsdhYvDGMBY/j77e+HdNsT8n8xTRYMl2tRGpKB
-gcApWn9yO41u62j7nY3H+B58EO6/zcIjvBahxWYC3E58CPG5PnMQ6AwKrpoajAeZ
-53q6ryhMkfRW9j6C/vD8DjyTjikw1cCzHjCbtli0fAFNhczo+UlSNqrLvT7OWs8r
-A/CkADHMOMvbOnaN+kmjEEvOX271wVe1wajA9+BzwVGxYgqBaGgsyvWX26Ql8lST
-FDZsOYcqvZ241LeCr6/+fG1NoI1CknT3+ioQcRZw2cJftqqj3VSG/6rcMxxMbSVq
-t7qZJVzToNx6Eer3K9TvUXiR68y0TBG+dVj9Wjf6idv5UbJHGeAPNOqsK1uuwb5z
-oOrN2bcRzfb927Mn7LwuusPDxHwpwlcboAu3FFtILVueAFO+U97pIO1/prxAq//q
-iMzRASMcQj4HnwhvyQHSYUOUgr6AEQFT0rVCFg5ooA3jre4KOZym3VSCeO22wRVI
-R09pkx7t9Hx4Uakg3B88BO2c+mCSCZiqtvVJs1GsxZypS1OuzIyycIgz5nwtxsjn
-QFpJGROYY7ZIsvt8lqBB4WiWESNbtwIDAQABAoICAQCpGV3iG7Trpohp7gQzdsYo
-kjxI1+/oGkULVVqQs9vT2N+SdDlF50eyBT1lgfCJNQq97lIGF2IaSaD+D7Jd6c7B
-d1i42pd2ndGvORYj+cvjKqSchsA9QIjSoYnZRzZrQrdV7WESOZ/0hdlmGTJs4qTJ
-8bI3ZcPaZjQiIO/iOHmGn0gL5lAEojH1X+C5gT4+/yJ2B+x6LyvAyPzbtj6MUctf
-VfOuDdf8W47VVV5IfJWfJ6C8qg4gw0M7P2ibZ8qBJcvuJSWFT6OK2UKaGtDLogw0
-X8tVWfO1qOB3vnWmZtoRZ9aO5JnnpWS9tY1w5gmZdLjB/Kt0DJXIdZALCURwV6U0
-q5XR0SETEgdRrNX92PA2lmxO9fAgXRSjP/OoeDjAVhnRfYyShDbEIb8GHk7nE+is
-6ak5ufxKE53S8wB9L7MTPqTvxusBHi8saLevdnPBMQPvtEVkg2Iw/iPBsegUuUjD
-uzXlq4WUMCUBJEMVPuYEsaQizxpp2oM6AZj/ecuTKFX5CirFFWKOQ4cp+O8lrfI5
-ruwHrMkfjowDYcQaOLHq13anvt8+8LBlngVw+jiAGB/bGwrAwEZWUc8i1HbH/G8e
-sm0kMuCqV1GbRyMCUO3pWjzrsz8LEy74Jr0z7KZn52vLWrTkiD4NRXahxTBhHpXb
-AVclJ+a4BKk2rRJVRFRRQQKCAQEA7+uTl2ZHp1v7A8/I2zPIxoVz0fiwxwAjuv34
-cV+uxG0n5Tko4PKMxavddRFKNeGvrz0aO/GNX8NIW7pDqZ2CwHyskgUX/bFAqGKF
-Z/z2DmiZ2rdSUH89O3ysq+OF3RjX/FBNJ0SVdwtrpz3kCSWpa4PnmN7+IevL6zxY
-8gLrs07Ge+ci94FZaDHBNrkGQ00krbOmwIvnc90hyRPCKfMS+u2/ejKZ5QDyRG+H
-jbQ008ZV2OqUdS6h1twfoJ1Q4QhHijB6PegRLGdZGuUXIQfFP8dIUsQluKSUFyOy
-bL9W2yBwtbn3EwYDHLJQnLICxfcTBWg/2vOIucsSjxG7KNY0yQKCAQEA4YwcVpi3
-D+8OcnbpRBRlHo84DRZorp0RO8vhxevvB1CcBnkLRIYXlS2JIfrnhZAI/5jBk1ei
-FmgRFyAjZ8gDdkDCiDMQMDUwUhLGSVurI9sk16B4TQKCM+iE0LDrXIy9ezJRJkj0
-rOt8sqo2/TOttm2KEXY8Cco59tU4bMZg5Tr9l7SMTTj4skTO6Jn6/6hX3XuFkJw7
-B0DsSzIqXyRHAzOidagIEoIr7k4cEGXsrSWoSiHg/eky1ihCyUw3vDDOmoViBR7s
-h5nLjQNNAzOtyoKLqST7B7uXkdUo5nV2IUHSGD5LNxlTaNp0XL9Ph3EBtcuwNuB6
-zyKXc+O5iNfMfwKCAQEA5/RJKCnRgsORxpif5xWEujIRzOHz/yFqagHarbnFHNEv
-rhT6Kak2YnIL1H/X0IoWsYSQlX2uofQKQ+ysOBM5c2HV8gKMtFAnY+SEeAn/1eRZ
-QzTTl1G84INj6Xc6V40KXD1CqoFLQ+G9vd4/Vnyb9H99bLXC2wa+ivo4QBqEyEGT
-8fyAOOxMhUj9NSvjGzQ9DtbOk/9u0PztChtZL/d61TEAW2MKmHW2xGVTl7OvE0QA
-gYwh5b0k6La+uSj/JeE8USUXOjzgRZ7RbggouV1q3YOMr8BFe+NZ7Zksiqjej1Io
-xfk6H6FDZv4ao7QSrFR4hlTIz6V9/aqQkdOhsBSQyQKCAQEAzHwz4Qr5xVduGLbY
-S6HV/7vHDI6Jf+3lBvqUidWa013w5yls3sZXsSckkgshRoVMszayIbystnXJMNcx
-YlEDWn3iIItzHNHMKkzdOvsCETMIlvnkt6UTmK4xY+dSq4jp7Ty0N+qi8fdaCb2q
-tyrYTnHHYId6bUHMBY5QZsYAaTNvYNAO96A0UaNyl42q84iTiLkJYg9SsQPad15W
-7gU84Jk6rEMYdndQDvEAHpnZ1y0yA2vtySZYsbK0wj34tgTl+0/8izn7JgF4ezNH
-6iQ7Z0OuDT763IrmIxBH0ZEi9YnwSYyIsr6iUYjlQIUuPFRnQYQXEdm5Xfw1pZsL
-xhYoTwKCAQB9edDe4LX+0z9i4qr0iHV8H/WoyI5UD/Pc217PKkYM3+ewR9SL9D9z
-TS78Sl7HgRgEmIu+MR/u5B2ePf7jkvB/oxyPwqAzJeJ72mV3Mevm27G/Ndd8lt5W
-FBCGOx7ZeP4/Cv4mvPD979ix2IalDoWMSWJnpQPN+B1jGeCrUYAXQc1k/vU99gLa
-8Tuu3WfBpVAsO7hAC9mu6tuLyfKVqiMOVs2aky9xLqiqW/6uIcGu+owrr+gkDDY/
-JfBSUfxYKcjtJiHOEbFGrrRe93XsngmaTz/Hv9A/QLVCuJgWEHlt4WHSc+BtAtaV
-9avp6VlyVNfe4KEKW7IekrI0cmfMdXkl
-----END PRIVATE KEY-----
--- a/examples/utils.js
+++ b/examples/utils.js
@@ -9,7 +9,7 @@ async function isExecutable (command) {
    await fs.access(command, fs.constants.X_OK)

    return true
-  } catch (/** @type {any} */ err) {
+  } catch (err) {
    if (err.code === 'ENOENT') {
      return isExecutable(await which(command))
    }
@@ -30,7 +30,7 @@ async function waitForOutput (expectedOutput, command, args = [], opts = {}) {

  const proc = execa(command, args, opts)
  let output = ''
-  let time = 600000
+  let time = 120000

  let timeout = setTimeout(() => {
    throw new Error(`Did not see "${expectedOutput}" in output from "${[command].concat(args).join(' ')}" after ${time/1000}s`)
@@ -49,7 +49,7 @@ async function waitForOutput (expectedOutput, command, args = [], opts = {}) {

  try {
    await proc
-  } catch (/** @type {any} */ err) {
+  } catch (err) {
    if (!err.killed) {
      throw err
    }
--- a/examples/webrtc-direct/README.md
+++ b/examples/webrtc-direct/README.md
@@ -1,33 +0,0 @@
-### Webrtc-direct example
-
-An example that uses [js-libp2p-webrtc-direct](https://github.com/libp2p/js-libp2p-webrtc-direct) for connecting
-nodejs libp2p and browser libp2p clients. To run the example:
-
-## 0. Run a nodejs libp2p listener
-
-When in the root folder of this example, type `node listener.js` in terminal. You should see an address that listens for
-incoming connections. Below is just an example of such address. In your case the suffix hash (`peerId`) will be different.
-
-```bash
-$ node listener.js 
-Listening on:
-/ip4/127.0.0.1/tcp/9090/http/p2p-webrtc-direct/p2p/QmUKQCzEUhhhobcNSrXU5uzxTqbvF1BjMCGNGZzZU14Kgd
-```
-
-## 1. Prepare a browser libp2p dialer
-Confirm that the above address is the same as the field `list` in `public/dialer.js`:
-```js
-    peerDiscovery: {
-      [Bootstrap.tag]: {
-        enabled: true,
-        // paste the address into `list`
-        list: ['/ip4/127.0.0.1/tcp/9090/http/p2p-webrtc-direct/p2p/QmUKQCzEUhhhobcNSrXU5uzxTqbvF1BjMCGNGZzZU14Kgd']
-      }
-    }
-```
-
-## 2. Run a browser libp2p dialer
-When in the root folder of this example, type `npm run dev` in terminal. You should see an address where you can browse
-the running client. Open this address in your browser. In console
-logs you should see logs about successful connection with the node client. In the output of node client you should see
-a log message about successful connection as well.
--- a/examples/webrtc-direct/dialer.js
+++ b/examples/webrtc-direct/dialer.js
@@ -1,57 +0,0 @@
-import 'babel-polyfill'
-const Libp2p = require('libp2p')
-const WebRTCDirect = require('libp2p-webrtc-direct')
-const Mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
-const Bootstrap = require('libp2p-bootstrap')
-
-document.addEventListener('DOMContentLoaded', async () => {
-  // use the same peer id as in `listener.js` to avoid copy-pasting of listener's peer id into `peerDiscovery`
-  const hardcodedPeerId = '12D3KooWCuo3MdXfMgaqpLC5Houi1TRoFqgK9aoxok4NK5udMu8m'
-  const libp2p = await Libp2p.create({
-    modules: {
-      transport: [WebRTCDirect],
-      streamMuxer: [Mplex],
-      connEncryption: [NOISE],
-      peerDiscovery: [Bootstrap]
-    },
-    config: {
-      peerDiscovery: {
-        [Bootstrap.tag]: {
-          enabled: true,
-          list: [`/ip4/127.0.0.1/tcp/9090/http/p2p-webrtc-direct/p2p/${hardcodedPeerId}`]
-        }
-      }
-    }
-  })
-
-  const status = document.getElementById('status')
-  const output = document.getElementById('output')
-
-  output.textContent = ''
-
-  function log (txt) {
-    console.info(txt)
-    output.textContent += `${txt.trim()}\n`
-  }
-
-  // Listen for new peers
-  libp2p.on('peer:discovery', (peerId) => {
-    log(`Found peer ${peerId.toB58String()}`)
-  })
-
-  // Listen for new connections to peers
-  libp2p.connectionManager.on('peer:connect', (connection) => {
-    log(`Connected to ${connection.remotePeer.toB58String()}`)
-  })
-
-  // Listen for peers disconnecting
-  libp2p.connectionManager.on('peer:disconnect', (connection) => {
-    log(`Disconnected from ${connection.remotePeer.toB58String()}`)
-  })
-
-  await libp2p.start()
-  status.innerText = 'libp2p started!'
-  log(`libp2p id is ${libp2p.peerId.toB58String()}`)
-
-})
--- a/examples/webrtc-direct/index.html
+++ b/examples/webrtc-direct/index.html
@@ -1,17 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta charset="UTF-8">
-  <title>js-libp2p parcel.js browser example</title>
-</head>
-
-<body>
-  <header>
-    <h1 id="status">Starting libp2p...</h1>
-  </header>
-  <main>
-    <pre id="output"></pre>
-  </main>
-  <script src="./dialer.js" type="module"></script>
-</body>
-</html>
--- a/examples/webrtc-direct/listener.js
+++ b/examples/webrtc-direct/listener.js
@@ -1,43 +0,0 @@
-const Libp2p = require('libp2p')
-const Bootstrap = require('libp2p-bootstrap')
-const WebRTCDirect = require('libp2p-webrtc-direct')
-const Mplex = require('libp2p-mplex')
-const { NOISE } = require('@chainsafe/libp2p-noise')
-const PeerId = require('peer-id')
-
-;(async () => {
-  // hardcoded peer id to avoid copy-pasting of listener's peer id into the dialer's bootstrap list
-  // generated with cmd `peer-id --type=ed25519`
-  const hardcodedPeerId = await PeerId.createFromJSON({
-    "id": "12D3KooWCuo3MdXfMgaqpLC5Houi1TRoFqgK9aoxok4NK5udMu8m",
-    "privKey": "CAESQAG6Ld7ev6nnD0FKPs033/j0eQpjWilhxnzJ2CCTqT0+LfcWoI2Vr+zdc1vwk7XAVdyoCa2nwUR3RJebPWsF1/I=",
-    "pubKey": "CAESIC33FqCNla/s3XNb8JO1wFXcqAmtp8FEd0SXmz1rBdfy"
-  })
-  const node = await Libp2p.create({
-    peerId: hardcodedPeerId,
-    addresses: {
-      listen: ['/ip4/127.0.0.1/tcp/9090/http/p2p-webrtc-direct']
-    },
-    modules: {
-      transport: [WebRTCDirect],
-      streamMuxer: [Mplex],
-      connEncryption: [NOISE]
-    },
-    config: {
-      peerDiscovery: {
-        [Bootstrap.tag]: {
-          enabled: false,
-        }
-      }
-    }
-  })
-
-  node.connectionManager.on('peer:connect', (connection) => {
-    console.info(`Connected to ${connection.remotePeer.toB58String()}!`)
-  })
-
-  await node.start()
-
-  console.log('Listening on:')
-  node.multiaddrs.forEach((ma) => console.log(`${ma.toString()}/p2p/${node.peerId.toB58String()}`))
-})()
--- a/examples/webrtc-direct/package.json
+++ b/examples/webrtc-direct/package.json
@@ -1,33 +0,0 @@
-{
-  "name": "webrtc-direct",
-  "version": "0.0.1",
-  "private": true,
-  "description": "",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "parcel build index.html",
-    "start": "parcel index.html"
-  },
-  "license": "ISC",
-  "devDependencies": {
-    "@babel/cli": "^7.13.10",
-    "@babel/core": "^7.13.10",
-    "@mapbox/node-pre-gyp": "^1.0.8",
-    "babel-plugin-syntax-async-functions": "^6.13.0",
-    "babel-plugin-transform-regenerator": "^6.26.0",
-    "babel-polyfill": "^6.26.0",
-    "parcel": "^2.0.1",
-    "util": "^0.12.3"
-  },
-  "dependencies": {
-    "@chainsafe/libp2p-noise": "^5.0.2",
-    "libp2p": "../../",
-    "libp2p-bootstrap": "^0.14.0",
-    "libp2p-mplex": "^0.10.4",
-    "libp2p-webrtc-direct": "^0.7.0",
-    "peer-id": "^0.16.0"
-  },
-  "browser": {
-    "ipfs": "ipfs/dist/index.min.js"
-  }
-}
--- a/examples/webrtc-direct/test.js
+++ b/examples/webrtc-direct/test.js
@@ -1,95 +0,0 @@
-'use strict'
-
-const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-const { chromium } = require('playwright');
-
-function startNode (name, args = []) {
-    return execa('node', [path.join(__dirname, name), ...args], {
-        cwd: path.resolve(__dirname),
-        all: true
-    })
-}
-
-function startBrowser (name, args = []) {
-    return execa('parcel', [path.join(__dirname, name), ...args], {
-        preferLocal: true,
-        localDir: __dirname,
-        cwd: __dirname,
-        all: true
-    })
-}
-
-async function test () {
-    // Step 1, listener process
-    const listenerProcReady = pDefer()
-    let listenerOutput = ''
-    process.stdout.write('listener.js\n')
-    const listenerProc = startNode('listener.js')
-
-    listenerProc.all.on('data', async (data) => {
-        process.stdout.write(data)
-        listenerOutput += uint8ArrayToString(data)
-        if (listenerOutput.includes('Listening on:') && listenerOutput.includes('12D3KooWCuo3MdXfMgaqpLC5Houi1TRoFqgK9aoxok4NK5udMu8m')) {
-            listenerProcReady.resolve()
-        }
-    })
-
-    await listenerProcReady.promise
-    process.stdout.write('==================================================================\n')
-
-    // Step 2, dialer process
-    process.stdout.write('dialer.js\n')
-    let dialerUrl = ''
-    const dialerProc = startBrowser('index.html')
-
-    dialerProc.all.on('data', async (chunk) => {
-        /**@type {string} */
-        const out = chunk.toString()
-
-        if (out.includes('Server running at')) {
-            dialerUrl = out.split('Server running at ')[1]
-        }
-
-
-        if (out.includes('Built in ')) {
-
-            try {
-                const browser = await chromium.launch();
-                const page = await browser.newPage();
-                await page.goto(dialerUrl);
-                await page.waitForFunction(selector => document.querySelector(selector).innerText === 'libp2p started!', '#status')
-                await page.waitForFunction(
-                  selector => {
-                      const text = document.querySelector(selector).innerText
-                      return text.includes('libp2p id is') &&
-                        text.includes('Found peer') &&
-                        text.includes('Connected to')
-                  },
-                  '#output',
-                  { timeout: 10000 }
-                )
-                await browser.close();
-            } catch (/** @type {any} */ err) {
-                console.error(err)
-                process.exit(1)
-            } finally {
-                dialerProc.cancel()
-                listenerProc.kill()
-            }
-        }
-    })
-
-    await Promise.all([
-        listenerProc,
-        dialerProc,
-    ]).catch((err) => {
-        if (err.signal !== 'SIGTERM') {
-            throw err
-        }
-    })
-}
-
-module.exports = test
--- a/package-list.json
+++ b/package-list.json
@@ -42,12 +42,15 @@
    ["libp2p/js-libp2p-delegated-peer-routing", "libp2p-delegated-peer-routing"],
    ["libp2p/js-libp2p-kad-dht", "libp2p-kad-dht"],

+    "service discovery",
+    ["libp2p/js-libp2p-rendezvous", "libp2p-rendezvous"],
+
    "utilities",
    ["libp2p/js-libp2p-crypto", "libp2p-crypto"],
+    ["libp2p/js-libp2p-crypto-secp256k1", "libp2p-crypto-secp256k1"],

    "data types",
    ["libp2p/js-peer-id", "peer-id"],
-    ["libp2p/js-libp2p-record", "libp2p-record"],

    "pubsub",
    ["libp2p/js-libp2p-floodsub", "libp2p-floodsub"],
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "libp2p",
-  "version": "0.36.1",
+  "version": "0.30.1",
  "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
  "leadMaintainer": "Jacob Heun <jacobheun@gmail.com>",
  "main": "src/index.js",
@@ -20,29 +20,13 @@
  "scripts": {
    "lint": "aegir lint",
    "build": "aegir build",
-    "build:proto": "npm run build:proto:circuit && npm run build:proto:fetch && npm run build:proto:identify && npm run build:proto:plaintext && npm run build:proto:address-book && npm run build:proto:proto-book && npm run build:proto:peer && npm run build:proto:peer-record && npm run build:proto:envelope",
-    "build:proto:circuit": "pbjs -t static-module -w commonjs -r libp2p-circuit --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/circuit/protocol/index.js ./src/circuit/protocol/index.proto",
-    "build:proto:fetch": "pbjs -t static-module -w commonjs -r libp2p-fetch --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/fetch/proto.js ./src/fetch/proto.proto",
-    "build:proto:identify": "pbjs -t static-module -w commonjs -r libp2p-identify --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/identify/message.js ./src/identify/message.proto",
-    "build:proto:plaintext": "pbjs -t static-module -w commonjs -r libp2p-plaintext --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/insecure/proto.js ./src/insecure/proto.proto",
-    "build:proto:peer": "pbjs -t static-module -w commonjs -r libp2p-peer --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/peer-store/pb/peer.js ./src/peer-store/pb/peer.proto",
-    "build:proto:peer-record": "pbjs -t static-module -w commonjs -r libp2p-peer-record --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/record/peer-record/peer-record.js ./src/record/peer-record/peer-record.proto",
-    "build:proto:envelope": "pbjs -t static-module -w commonjs -r libp2p-envelope --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/record/envelope/envelope.js ./src/record/envelope/envelope.proto",
-    "build:proto-types": "npm run build:proto-types:circuit && npm run build:proto-types:fetch && npm run build:proto-types:identify && npm run build:proto-types:plaintext && npm run build:proto-types:address-book && npm run build:proto-types:proto-book && npm run build:proto-types:peer && npm run build:proto-types:peer-record && npm run build:proto-types:envelope",
-    "build:proto-types:circuit": "pbts -o src/circuit/protocol/index.d.ts src/circuit/protocol/index.js",
-    "build:proto-types:fetch": "pbts -o src/fetch/proto.d.ts src/fetch/proto.js",
-    "build:proto-types:identify": "pbts -o src/identify/message.d.ts src/identify/message.js",
-    "build:proto-types:plaintext": "pbts -o src/insecure/proto.d.ts src/insecure/proto.js",
-    "build:proto-types:peer": "pbts -o src/peer-store/pb/peer.d.ts src/peer-store/pb/peer.js",
-    "build:proto-types:peer-record": "pbts -o src/record/peer-record/peer-record.d.ts src/record/peer-record/peer-record.js",
-    "build:proto-types:envelope": "pbts -o src/record/envelope/envelope.d.ts src/record/envelope/envelope.js",
-    "test": "aegir test",
-    "test:ts": "aegir build --no-bundle && npm run test --prefix test/ts-use",
+    "test": "npm run test:node && npm run test:browser",
    "test:node": "aegir test -t node -f \"./test/**/*.{node,spec}.js\"",
    "test:browser": "aegir test -t browser",
    "test:examples": "cd examples && npm run test:all",
-    "test:interop": "LIBP2P_JS=$PWD npx aegir test -t node -f ./node_modules/libp2p-interop/test/*",
-    "prepare": "npm run build",
+    "release": "aegir release -t node -t browser",
+    "release-minor": "aegir release --type minor -t node -t browser",
+    "release-major": "aegir release --type major -t node -t browser",
    "coverage": "nyc --reporter=text --reporter=lcov npm run test:node"
  },
  "repository": {
@@ -63,116 +47,97 @@
  "homepage": "https://libp2p.io",
  "license": "MIT",
  "engines": {
-    "node": ">=15.0.0"
-  },
-  "browser": {
-    "nat-api": false
-  },
-  "eslintConfig": {
-    "extends": "ipfs",
-    "ignorePatterns": [
-      "!.aegir.js",
-      "test/ts-use",
-      "*.d.ts"
-    ]
+    "node": ">=12.0.0",
+    "npm": ">=6.0.0"
  },
  "dependencies": {
-    "@vascosantos/moving-average": "^1.1.0",
-    "abortable-iterator": "^3.0.0",
-    "aggregate-error": "^3.1.0",
-    "any-signal": "^3.0.0",
-    "bignumber.js": "^9.0.1",
+    "abort-controller": "^3.0.0",
+    "aggregate-error": "^3.0.1",
+    "any-signal": "^1.1.0",
+    "bignumber.js": "^9.0.0",
+    "cids": "^1.0.0",
    "class-is": "^1.1.0",
-    "datastore-core": "^7.0.0",
-    "debug": "^4.3.1",
-    "err-code": "^3.0.0",
-    "es6-promisify": "^7.0.0",
-    "events": "^3.3.0",
+    "debug": "^4.1.1",
+    "err-code": "^2.0.0",
+    "events": "^3.1.0",
    "hashlru": "^2.3.0",
-    "interface-datastore": "^6.0.2",
-    "it-all": "^1.0.4",
+    "interface-datastore": "^2.0.0",
+    "ipfs-utils": "^5.0.1",
+    "it-all": "^1.0.1",
    "it-buffer": "^0.1.2",
-    "it-drain": "^1.0.3",
-    "it-filter": "^1.0.1",
-    "it-first": "^1.0.4",
-    "it-foreach": "^0.1.1",
-    "it-handshake": "^2.0.0",
-    "it-length-prefixed": "^5.0.2",
-    "it-map": "^1.0.4",
-    "it-merge": "^1.0.0",
+    "it-handshake": "^1.0.1",
+    "it-length-prefixed": "^3.0.1",
    "it-pipe": "^1.1.0",
-    "it-sort": "^1.0.1",
-    "it-take": "^1.0.0",
-    "libp2p-crypto": "^0.21.2",
-    "libp2p-interfaces": "^4.0.0",
-    "libp2p-utils": "^0.4.0",
-    "mafmt": "^10.0.0",
-    "merge-options": "^3.0.4",
-    "mortice": "^2.0.1",
-    "multiaddr": "^10.0.0",
-    "multiformats": "^9.0.0",
-    "multistream-select": "^3.0.0",
+    "it-protocol-buffers": "^0.2.0",
+    "libp2p-crypto": "^0.18.0",
+    "libp2p-interfaces": "^0.8.1",
+    "libp2p-utils": "^0.2.2",
+    "mafmt": "^8.0.0",
+    "merge-options": "^2.0.0",
+    "moving-average": "^1.0.0",
+    "multiaddr": "^8.1.0",
+    "multicodec": "^2.0.0",
+    "multihashing-async": "^2.0.1",
+    "multistream-select": "^1.0.0",
    "mutable-proxy": "^1.0.0",
-    "nat-api": "^0.3.1",
-    "node-forge": "^1.2.1",
+    "node-forge": "^0.9.1",
    "p-any": "^3.0.0",
    "p-fifo": "^1.0.0",
-    "p-retry": "^4.4.0",
-    "p-settle": "^4.1.1",
-    "peer-id": "^0.16.0",
-    "private-ip": "^2.1.0",
-    "protobufjs": "^6.10.2",
-    "retimer": "^3.0.0",
+    "p-settle": "^4.0.1",
+    "peer-id": "^0.14.2",
+    "protons": "^2.0.0",
+    "retimer": "^2.0.0",
    "sanitize-filename": "^1.6.3",
    "set-delayed-interval": "^1.0.0",
-    "streaming-iterables": "^6.0.0",
-    "timeout-abort-controller": "^3.0.0",
-    "uint8arrays": "^3.0.0",
-    "varint": "^6.0.0",
-    "wherearewe": "^1.0.0",
-    "xsalsa20": "^1.1.0"
+    "streaming-iterables": "^5.0.2",
+    "timeout-abort-controller": "^1.1.1",
+    "varint": "^5.0.0",
+    "xsalsa20": "^1.0.2"
  },
  "devDependencies": {
-    "@chainsafe/libp2p-noise": "^5.0.0",
    "@nodeutils/defaults-deep": "^1.1.0",
-    "@types/es6-promisify": "^6.0.0",
-    "@types/node": "^16.0.1",
-    "@types/node-forge": "^1.0.0",
-    "@types/varint": "^6.0.0",
-    "aegir": "^36.0.0",
-    "buffer": "^6.0.3",
-    "delay": "^5.0.0",
+    "abortable-iterator": "^3.0.0",
+    "aegir": "^29.2.0",
+    "chai-bytes": "^0.1.2",
+    "chai-string": "^1.5.0",
+    "delay": "^4.3.0",
+    "interop-libp2p": "^0.3.0",
    "into-stream": "^6.0.0",
-    "ipfs-http-client": "^54.0.2",
-    "it-concat": "^2.0.0",
+    "ipfs-http-client": "^47.0.1",
+    "it-concat": "^1.0.0",
    "it-pair": "^1.0.0",
    "it-pushable": "^1.4.0",
    "libp2p": ".",
-    "libp2p-bootstrap": "^0.14.0",
-    "libp2p-delegated-content-routing": "^0.11.0",
-    "libp2p-delegated-peer-routing": "^0.11.1",
-    "libp2p-interfaces-compliance-tests": "^4.0.8",
-    "libp2p-interop": "^0.7.1",
-    "libp2p-kad-dht": "^0.28.6",
-    "libp2p-mdns": "^0.18.0",
-    "libp2p-mplex": "^0.10.4",
-    "libp2p-tcp": "^0.17.0",
-    "libp2p-webrtc-star": "^0.25.0",
-    "libp2p-websockets": "^0.16.0",
+    "libp2p-bootstrap": "^0.12.0",
+    "libp2p-delegated-content-routing": "^0.8.0",
+    "libp2p-delegated-peer-routing": "^0.8.0",
+    "libp2p-floodsub": "^0.24.0",
+    "libp2p-gossipsub": "^0.7.0",
+    "libp2p-kad-dht": "^0.20.0",
+    "libp2p-mdns": "^0.15.0",
+    "libp2p-mplex": "^0.10.1",
+    "libp2p-noise": "^2.0.0",
+    "libp2p-rendezvous": "libp2p/js-libp2p-rendezvous#feat/rendezvous-protocol-full-implementation",
+    "libp2p-secio": "^0.13.1",
+    "libp2p-tcp": "^0.15.1",
+    "libp2p-webrtc-star": "^0.20.0",
+    "libp2p-websockets": "^0.15.0",
+    "multihashes": "^3.0.1",
    "nock": "^13.0.3",
    "p-defer": "^3.0.0",
    "p-times": "^3.0.0",
-    "p-wait-for": "^3.2.0",
+    "p-wait-for": "^3.1.0",
+    "promisify-es6": "^1.0.3",
    "rimraf": "^3.0.2",
-    "sinon": "^12.0.1",
-    "util": "^0.12.3"
+    "sinon": "^9.0.2",
+    "uint8arrays": "^1.1.0"
  },
  "contributors": [
-    "Vasco Santos <vasco.santos@moxy.studio>",
    "David Dias <daviddias.p@gmail.com>",
    "Jacob Heun <jacobheun@gmail.com>",
-    "Alex Potsides <alex@achingbrain.net>",
+    "Vasco Santos <vasco.santos@moxy.studio>",
    "Alan Shaw <alan@tableflip.io>",
+    "Alex Potsides <alex@achingbrain.net>",
    "Cayman <caymannava@gmail.com>",
    "Pedro Teixeira <i@pgte.me>",
    "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
@@ -180,74 +145,42 @@
    "Hugo Dias <mail@hugodias.me>",
    "dirkmc <dirkmdev@gmail.com>",
    "Volker Mische <volker.mische@gmail.com>",
-    "Chris Dostert <chrisdostert@users.noreply.github.com>",
-    "zeim839 <50573884+zeim839@users.noreply.github.com>",
-    "Robert Kiel <robert.kiel@hoprnet.org>",
    "Richard Littauer <richard.littauer@gmail.com>",
    "a1300 <matthias-knopp@gmx.net>",
-    "Ryan Bell <ryan@piing.net>",
-    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
-    "Andrew Nesbitt <andrewnez@gmail.com>",
-    "Franck Royer <franck@royer.one>",
-    "Thomas Eizinger <thomas@eizinger.io>",
-    "Vít Habada <vithabada93@gmail.com>",
-    "Giovanni T. Parra <fiatjaf@gmail.com>",
-    "acolytec3 <17355484+acolytec3@users.noreply.github.com>",
-    "Alan Smithee <ggnore.alan.smithee@gmail.com>",
    "Elven <mon.samuel@qq.com>",
-    "Samlior <samlior@foxmail.com>",
-    "Didrik Nordström <didrik.nordstrom@gmail.com>",
-    "Aditya Bose <13054902+adbose@users.noreply.github.com>",
-    "TJKoury <TJKoury@gmail.com>",
-    "TheStarBoys <41286328+TheStarBoys@users.noreply.github.com>",
-    "Tiago Alves <alvesjtiago@gmail.com>",
-    "Tim Daubenschütz <tim@daubenschuetz.de>",
-    "XiaoZhang <zxinmyth@gmail.com>",
-    "Yusef Napora <yusef@napora.org>",
-    "Zane Starr <zcstarr@gmail.com>",
-    "ebinks <elizabethjbinks@gmail.com>",
-    "greenSnot <greenSnot@users.noreply.github.com>",
-    "isan_rivkin <isanrivkin@gmail.com>",
-    "mayerwin <mayerwin@users.noreply.github.com>",
-    "mcclure <andi.m.mcclure@gmail.com>",
-    "patrickwoodhead <91056047+patrickwoodhead@users.noreply.github.com>",
-    "phillmac <phillmac@users.noreply.github.com>",
-    "robertkiel <robert.kiel@validitylabs.org>",
-    "shresthagrawal <34920931+shresthagrawal@users.noreply.github.com>",
-    "swedneck <40505480+swedneck@users.noreply.github.com>",
-    "tuyennhv <vutuyen2636@gmail.com>",
-    "Sönke Hahn <soenkehahn@gmail.com>",
-    "Aleksei <vozhdb@gmail.com>",
-    "Bernd Strehl <bernd.strehl@gmail.com>",
-    "Chris Bratlien <chrisbratlien@gmail.com>",
-    "Cindy Wu <ciindy.wu@gmail.com>",
-    "Daijiro Wachi <daijiro.wachi@gmail.com>",
-    "Diogo Silva <fsdiogo@gmail.com>",
-    "Dmitriy Ryajov <dryajov@gmail.com>",
-    "Ethan Lam <elmemphis2000@gmail.com>",
+    "Andrew Nesbitt <andrewnez@gmail.com>",
+    "Giovanni T. Parra <fiatjaf@gmail.com>",
+    "Ryan Bell <ryan@piing.net>",
+    "Thomas Eizinger <thomas@eizinger.io>",
+    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
+    "Didrik Nordström <didrik@betamos.se>",
    "Fei Liu <liu.feiwood@gmail.com>",
-    "Felipe Martins <felipebrasil93@gmail.com>",
-    "Florian-Merle <florian.david.merle@gmail.com>",
-    "Francis Gulotta <wizard@roborooter.com>",
-    "Guy Sviry <32539816+guysv@users.noreply.github.com>",
-    "Henrique Dias <hacdias@gmail.com>",
-    "Irakli Gozalishvili <rfobic@gmail.com>",
+    "Ethan Lam <elmemphis2000@gmail.com>",
    "Joel Gustafson <joelg@mit.edu>",
-    "John Rees <johnrees@users.noreply.github.com>",
-    "João Santos <joaosantos15@users.noreply.github.com>",
    "Julien Bouquillon <contact@revolunet.com>",
    "Kevin Kwok <antimatter15@gmail.com>",
-    "Kevin Lacker <lacker@gmail.com>",
-    "Lars Gierth <lgierth@users.noreply.github.com>",
-    "Leask Wong <i@leaskh.com>",
-    "Marcin Tojek <mtojek@users.noreply.github.com>",
-    "Marston Connell <34043723+TheMarstonConnell@users.noreply.github.com>",
-    "Michael Burns <5170+mburns@users.noreply.github.com>",
-    "Miguel Mota <miguelmota2@gmail.com>",
    "Nuno Nogueira <nunofmn@gmail.com>",
-    "Philipp Muens <raute1337@gmx.de>",
+    "Dmitriy Ryajov <dryajov@gmail.com>",
    "RasmusErik Voel Jensen <github@solsort.com>",
+    "Diogo Silva <fsdiogo@gmail.com>",
+    "Samlior <samlior@foxmail.com>",
    "Smite Chow <xiaopengyou@live.com>",
-    "Soeren <nikorpoulsen@gmail.com>"
+    "Soeren <nikorpoulsen@gmail.com>",
+    "Sönke Hahn <soenkehahn@gmail.com>",
+    "Tiago Alves <alvesjtiago@gmail.com>",
+    "Daijiro Wachi <daijiro.wachi@gmail.com>",
+    "Yusef Napora <yusef@napora.org>",
+    "Zane Starr <zcstarr@gmail.com>",
+    "robertkiel <robert.kiel@validitylabs.org>",
+    "Cindy Wu <ciindy.wu@gmail.com>",
+    "Chris Bratlien <chrisbratlien@gmail.com>",
+    "ebinks <elizabethjbinks@gmail.com>",
+    "Florian-Merle <florian.david.merle@gmail.com>",
+    "Francis Gulotta <wizard@roborooter.com>",
+    "Felipe Martins <felipebrasil93@gmail.com>",
+    "Bernd Strehl <bernd.strehl@gmail.com>",
+    "Henrique Dias <hacdias@gmail.com>",
+    "isan_rivkin <isanrivkin@gmail.com>",
+    "Irakli Gozalishvili <rfobic@gmail.com>"
  ]
 }
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
Vasco Santos	162a68f807	chore: add rendezvous example	2021-01-19 11:51:31 +01:00
Vasco Santos	4d7b3b397f	feat: rendezvous client	2021-01-19 11:08:51 +01:00
Vasco Santos	762062b904	chore: add discovery example with relay and pubsub	2021-01-19 11:08:51 +01:00