chore: release version v0.30.13

.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
 
@@ -48,23 +47,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: '223kB' },
+  hooks: {
+    pre: before,
+    post: after
   },
-  test: {
-    before,
-    after,
-    browser: {
-      config: {
-        buildConfig: esbuild
-      }
+  webpack: {
+    node: {
+      // needed by bcrypto
+      Buffer: true
     }
   }
 }

.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

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

.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

.github/workflows/examples.yml

@@ -1,102 +0,0 @@
-name: examples
-on:
-  push:
-    branches:
-      - master
-  pull_request:
-    branches:
-      - '**'
-
-jobs:
-  check:
-    runs-on: ubuntu-latest
-    steps:
-    - uses: actions/checkout@v2
-    - run: npm install
-    - run: npx aegir lint
-    - run: npx aegir ts -p check
-    - run: npx aegir build
-  test-auto-relay-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- auto-relay
-  test-chat-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- chat
-  test-connection-encryption-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- connection-encryption
-  test-discovery-mechanisms-example:
-    needs: check
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- discovery-mechanisms
-  test-echo-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- echo
-  test-libp2p-in-the-browser-example:
-    needs: check
-    runs-on: macos-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- libp2p-in-the-browser
-  test-peer-and-content-routing-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- peer-and-content-routing
-  test-pnet-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- pnet
-  test-protocol-and-stream-muxing-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- protocol-and-stream-muxing
-  test-pubsub-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- pubsub
-  test-transports-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- transports
-  test-webrtc-direct-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && npm install && npm run test -- webrtc-direct

.github/workflows/main.yml

@@ -12,15 +12,12 @@ jobs:
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
-    - uses: actions/setup-node@v2
-      with:
-        node-version: 14
-    - run: npm install
-    - run: npx aegir lint
+    - run: yarn
+    - run: yarn lint
     - uses: gozala/typescript-error-reporter-action@v1.0.8
-    - run: npx aegir build
-    - run: npx aegir dep-check
-    - uses: ipfs/aegir/actions/bundle-size@v32.1.0
+    - run: yarn build
+    - run: yarn aegir dep-check
+    - uses: ipfs/aegir/actions/bundle-size@master
       name: size
       with:
         github_token: ${{ secrets.GITHUB_TOKEN }}
@@ -30,41 +27,118 @@ jobs:
     strategy:
       matrix:
         os: [windows-latest, ubuntu-latest, macos-latest]
-        node: [14, 16]
+        node: [14]
       fail-fast: true
     steps:
       - uses: actions/checkout@v2
-      - uses: actions/setup-node@v2
+      - uses: actions/setup-node@v1
         with:
           node-version: ${{ matrix.node }}
-      - run: npm install
-      - run: npx aegir test -t node --cov --bail
+      - run: yarn
+      - run: npx nyc --reporter=lcov aegir test -t node -- --bail
       - uses: codecov/codecov-action@v1
   test-chrome:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: npm install
+      - run: yarn
       - run: npx aegir test -t browser -t webworker --bail
   test-firefox:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: npm install
-      - run: npx aegir test -t browser -t webworker --bail -- --browser firefox
-  test-ts:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: npm run test:ts
+      - run: yarn
+      - run: npx aegir test -t browser -t webworker --bail -- --browsers FirefoxHeadless
   test-interop:
     needs: check
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd node_modules/interop-libp2p && yarn && LIBP2P_JS=${GITHUB_WORKSPACE}/src/index.js npx aegir test -t node --bail -- --exit
+      - run: 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
+    steps:
+      - uses: actions/checkout@v2
+      - 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-connection-encryption-example:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- connection-encryption
+  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
+  test-echo-example:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- echo
+  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-peer-and-content-routing-example:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- peer-and-content-routing
+  test-pnet-example:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- pnet
+  test-protocol-and-stream-muxing-example:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- protocol-and-stream-muxing
+  test-pubsub-example:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- pubsub
+  test-transports-example:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- transports
+  test-webrtc-direct-example:
+    needs: check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - run: yarn
+      - run: cd examples && yarn && npm run test -- webrtc-direct

.gitignore

@@ -4,7 +4,6 @@ docs
 test/repo-tests*
 **/bundle.js
 .cache
-.parcel-cache
 
 # Logs
 logs

CHANGELOG.md

@@ -1,223 +1,4 @@
-# [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.13](https://github.com/libp2p/js-libp2p/compare/v0.30.12...v0.30.13) (2021-08-19)
 
 
 

README.md

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

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

doc/CONFIGURATION.md

@@ -1,4 +1,4 @@
-# 
+# Configuration
 
 - [Configuration](#configuration)
   - [Overview](#overview)
@@ -210,7 +210,7 @@ const modules = {
 Moreover, the majority of the modules can be customized via option parameters. This way, it is also possible to provide this options through a `config` object. This config object should have the property name of each building block to configure, the same way as the modules specification.
 
 Besides the `modules` and `config`, libp2p allows other internal options and configurations:
-- `datastore`: an instance of [ipfs/interface-datastore](https://github.com/ipfs/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.
@@ -282,7 +282,7 @@ const node = await Libp2p.create({
         interval: 1000,
         enabled: true
       },
-      [Bootstrap.tag]: {
+      [Bootstrap.tag:] {
         list: [ // A list of bootstrap peers to connect to starting up the node
           "/ip4/104.131.131.82/tcp/4001/ipfs/QmaCpDMGvV2BGHeYERUEnRQAwe3N8SzbUtfsmvsqQLuvuJ",
           "/dnsaddr/bootstrap.libp2p.io/ipfs/QmNnooDu7bfjPFoTZYxMNLWUQJyrVwtbZg5gBMjTezGAJN",
@@ -373,7 +373,7 @@ 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)
+      enabled: true,
       randomWalk: {
         enabled: true,            // Allows to disable discovery (enabled by default)
         interval: 300e3,
@@ -399,13 +399,13 @@ const PeerId = require('peer-id')
 // create a peerId
 const peerId = await PeerId.create()
 
-const delegatedPeerRouting = new DelegatedPeerRouter(ipfsHttpClient.create({
+const delegatedPeerRouting = new DelegatedPeerRouter(ipfsHttpClient({
   host: 'node0.delegate.ipfs.io', // In production you should setup your own delegates
   protocol: 'https',
   port: 443
 }))
 
-const delegatedContentRouting = new DelegatedContentRouter(peerId, ipfsHttpClient.create({
+const delegatedContentRouting = new DelegatedContentRouter(peerId, ipfsHttpClient({
   host: 'node0.delegate.ipfs.io', // In production you should setup your own delegates
   protocol: 'https',
   port: 443
@@ -503,9 +503,6 @@ const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
 const LevelStore = require('datastore-level')
 
-const datastore = new LevelStore('path/to/store')
-await datastore.open()
-
 const node = await Libp2p.create({
   modules: {
     transport: [TCP],
@@ -514,11 +511,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
@@ -528,7 +525,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 |
@@ -553,7 +549,6 @@ const node = await Libp2p.create({
   },
   dialer: {
     maxParallelDials: 100,
-    maxAddrsToDial: 25,
     maxDialsPerPeer: 4,
     dialTimeout: 30e3,
     resolvers: {
@@ -604,7 +599,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: {
@@ -676,10 +671,8 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
-const LevelStore = require('datastore-level')
 
-const datastore = new LevelStore('path/to/store')
-const dsInstant = await datastore.open()
+const LevelStore = require('datastore-level')
 
 const node = await Libp2p.create({
   modules: {
@@ -687,7 +680,7 @@ const node = await Libp2p.create({
     streamMuxer: [MPLEX],
     connEncryption: [NOISE]
   },
-  datastore: dsInstant,
+  datastore: new LevelStore('path/to/store'),
   peerStore: {
     persistence: true,
     threshold: 5
@@ -786,26 +779,6 @@ By default under nodejs libp2p will attempt to use [UPnP](https://en.wikipedia.o
 
 [NAT-PMP](http://miniupnp.free.fr/nat-pmp.html) is a feature of some modern routers which performs a similar job to UPnP. NAT-PMP is disabled by default, if enabled libp2p will try to use NAT-PMP and will fall back to UPnP if it fails.
 
-#### Configuring protocol name
-
-Changing the protocol name prefix can isolate default public network (IPFS) for custom purposes. 
-
-```js
-const node = await Libp2p.create({
-  config: {
-    protocolPrefix: 'ipfs' // default
-  }
-})
-/*
-protocols: [
-  "/ipfs/id/1.0.0", // identify service protocol (if we have multiplexers)
-  "/ipfs/id/push/1.0.0", // identify service push protocol (if we have multiplexers)
-  "/ipfs/ping/1.0.0", // built-in ping protocol
-]
-*/
-```
-
-
 ## Configuration examples
 
 As libp2p is designed to be a modular networking library, its usage will vary based on individual project needs. We've included links to some existing project configurations for your reference, in case you wish to replicate their configuration:

doc/migrations/v0.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.

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.

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.

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:

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 () {

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 () {

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 () {

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], {

examples/chat/src/dialer.js

@@ -2,7 +2,7 @@
 /* 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')
 
@@ -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')

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('../../..')
 

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)], {

examples/connection-encryption/1.js

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

examples/connection-encryption/README.md

@@ -8,13 +8,13 @@ A byproduct of having these encrypted communications modules is that we can auth
 
 # 1. Set up encrypted communications
 
-We will build this example on top of example for [Protocol and Stream Multiplexing](../protocol-and-stream-multiplexing). You will need the `@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({

examples/connection-encryption/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')
 
 async function test () {
   const messageReceived = pDefer()

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

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 () => {

examples/discovery-mechanisms/3.js

@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('@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')

examples/discovery-mechanisms/README.md

@@ -168,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')

examples/discovery-mechanisms/test-1.js

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

examples/discovery-mechanisms/test-2.js

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

examples/discovery-mechanisms/test-3.js

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

examples/echo/src/libp2p.js

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

examples/echo/test.js

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

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

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>
 

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'
 

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"
   ],
@@ -16,11 +17,11 @@
   "dependencies": {
     "@babel/preset-env": "^7.13.0",
     "libp2p": "../../",
-    "libp2p-bootstrap": "^0.13.0",
-    "libp2p-mplex": "^0.10.4",
-    "@chainsafe/libp2p-noise": "^4.1.0",
-    "libp2p-webrtc-star": "^0.23.0",
-    "libp2p-websockets": "^0.16.1"
+    "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",
@@ -28,6 +29,6 @@
     "babel-plugin-syntax-async-functions": "^6.13.0",
     "babel-plugin-transform-regenerator": "^6.26.0",
     "babel-polyfill": "^6.26.0",
-    "parcel": "next"
+    "parcel-bundler": "1.12.3"
   }
 }

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();

examples/package.json

@@ -10,16 +10,12 @@
   "dependencies": {
     "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-gossipsub": "^0.11.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"
   }
 }

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

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')
@@ -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)

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

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

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

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

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

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

examples/pnet/libp2p-node.js

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

examples/pnet/test.js

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

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

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

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

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

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

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

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

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

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

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

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

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

examples/pubsub/1.js

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

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

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 { NOISE } = require('libp2p-noise')
 const Gossipsub = require('libp2p-gossipsub')
-const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
+const uint8ArrayFromString = require('uint8arrays/from-string')
+const uint8ArrayToString = require('uint8arrays/to-string')
 
 const createNode = async () => {
   const node = await Libp2p.create({

examples/pubsub/message-filtering/test.js

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

examples/pubsub/test-1.js

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

examples/transports/1.js

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

examples/transports/2.js

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

examples/transports/3.js

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

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
-  )
-})();

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

examples/transports/test-1.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')
 
 async function test () {
   const deferStarted = pDefer()

examples/transports/test-2.js

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

examples/transports/test-3.js

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

examples/transports/test-4.js

@@ -1,33 +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 deferNode1 = pDefer()
-
-  process.stdout.write('4.js\n')
-
-  const proc = execa('node', [path.join(__dirname, '4.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
-  })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-    const line = uint8ArrayToString(data)
-
-    if (line.includes('node 2 dialed to node 1 successfully')) {
-      deferNode1.resolve()
-    }
-  })
-
-  await Promise.all([
-    deferNode1.promise,
-  ])
-  proc.kill()
-}
-
-module.exports = test

examples/transports/test.js

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

examples/transports/test_certs/cert.pem

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

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

examples/webrtc-direct/dialer.js

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

examples/webrtc-direct/listener.js

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

examples/webrtc-direct/package.json

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

examples/webrtc-direct/test.js

@@ -3,7 +3,7 @@
 const path = require('path')
 const execa = require('execa')
 const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
+const uint8ArrayToString = require('uint8arrays/to-string')
 const { chromium } = require('playwright');
 
 function startNode (name, args = []) {
@@ -50,12 +50,10 @@ async function test () {
         const out = chunk.toString()
 
         if (out.includes('Server running at')) {
-            dialerUrl = out.split('Server running at ')[1]
+            dialerUrl = 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();

package-list.json

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

package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "0.33.0",
+  "version": "0.30.13",
   "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
   "leadMaintainer": "Jacob Heun <jacobheun@gmail.com>",
   "main": "src/index.js",
@@ -20,28 +20,10 @@
   "scripts": {
     "lint": "aegir lint",
     "build": "aegir build",
-    "build:proto": "npm run build:proto:circuit && 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-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: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:address-book": "pbjs -t static-module -w commonjs -r libp2p-address-book --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/peer-store/persistent/pb/address-book.js ./src/peer-store/persistent/pb/address-book.proto",
-    "build:proto:proto-book": "pbjs -t static-module -w commonjs -r libp2p-proto-book --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/peer-store/persistent/pb/proto-book.js ./src/peer-store/persistent/pb/proto-book.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: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-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: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:address-book": "pbts -o src/peer-store/persistent/pb/address-book.d.ts src/peer-store/persistent/pb/address-book.js",
-    "build:proto-types:proto-book": "pbts -o src/peer-store/persistent/pb/proto-book.d.ts src/peer-store/persistent/pb/proto-book.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",
-    "prepare": "aegir build --no-bundle",
     "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",
@@ -65,183 +47,171 @@
   "homepage": "https://libp2p.io",
   "license": "MIT",
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=12.0.0",
+    "npm": ">=6.0.0"
   },
   "browser": {
     "@motrix/nat-api": false
   },
-  "eslintConfig": {
-    "extends": "ipfs",
-    "ignorePatterns": [
-      "!.aegir.js",
-      "test/ts-use"
-    ]
-  },
   "dependencies": {
-    "abortable-iterator": "^3.0.0",
     "@motrix/nat-api": "^0.3.1",
-    "@vascosantos/moving-average": "^1.1.0",
     "abort-controller": "^3.0.0",
     "aggregate-error": "^3.1.0",
     "any-signal": "^2.1.1",
     "bignumber.js": "^9.0.1",
+    "cids": "^1.1.5",
     "class-is": "^1.1.0",
     "debug": "^4.3.1",
-    "err-code": "^3.0.0",
-    "es6-promisify": "^7.0.0",
-    "events": "^3.3.0",
+    "err-code": "^2.0.0",
+    "es6-promisify": "^6.1.1",
+    "events": "^3.2.0",
     "hashlru": "^2.3.0",
-    "interface-datastore": "^6.0.2",
+    "interface-datastore": "^3.0.3",
+    "ipfs-utils": "^6.0.0",
     "it-all": "^1.0.4",
     "it-buffer": "^0.1.2",
     "it-drain": "^1.0.3",
     "it-filter": "^1.0.1",
     "it-first": "^1.0.4",
-    "it-handshake": "^2.0.0",
-    "it-length-prefixed": "^5.0.2",
+    "it-handshake": "^1.0.2",
+    "it-length-prefixed": "^3.1.0",
     "it-map": "^1.0.4",
-    "it-merge": "^1.0.0",
+    "it-merge": "1.0.0",
     "it-pipe": "^1.1.0",
-    "it-take": "^1.0.0",
-    "libp2p-crypto": "^0.19.4",
-    "libp2p-interfaces": "^1.0.0",
-    "libp2p-utils": "^0.4.0",
-    "mafmt": "^10.0.0",
+    "it-protocol-buffers": "^0.2.0",
+    "it-take": "1.0.0",
+    "libp2p-crypto": "^0.19.0",
+    "libp2p-interfaces": "^0.8.1",
+    "libp2p-utils": "^0.2.2",
+    "mafmt": "^8.0.0",
     "merge-options": "^3.0.4",
-    "multiaddr": "^10.0.0",
-    "multiformats": "^9.0.0",
-    "multistream-select": "^2.0.0",
+    "moving-average": "^1.0.0",
+    "multiaddr": "^8.1.0",
+    "multicodec": "^2.1.0",
+    "multihashing-async": "^2.0.1",
+    "multistream-select": "^1.0.0",
     "mutable-proxy": "^1.0.0",
     "node-forge": "^0.10.0",
     "p-any": "^3.0.0",
     "p-fifo": "^1.0.0",
-    "p-retry": "^4.4.0",
-    "p-settle": "^4.1.1",
-    "peer-id": "^0.15.0",
-    "private-ip": "^2.1.0",
-    "protobufjs": "^6.10.2",
-    "retimer": "^3.0.0",
+    "p-retry": "^4.2.0",
+    "p-settle": "^4.0.1",
+    "peer-id": "^0.14.2",
+    "private-ip": "^2.0.0",
+    "protons": "^2.0.0",
+    "retimer": "^2.0.0",
     "sanitize-filename": "^1.6.3",
     "set-delayed-interval": "^1.0.0",
-    "streaming-iterables": "^6.0.0",
+    "streaming-iterables": "^5.0.2",
     "timeout-abort-controller": "^1.1.1",
-    "uint8arrays": "^3.0.0",
+    "uint8arrays": "^2.1.3",
     "varint": "^6.0.0",
-    "wherearewe": "^1.0.0",
-    "xsalsa20": "^1.1.0"
+    "xsalsa20": "^1.0.2"
   },
   "devDependencies": {
-    "@chainsafe/libp2p-noise": "^4.0.0",
     "@nodeutils/defaults-deep": "^1.1.0",
     "@types/es6-promisify": "^6.0.0",
-    "@types/node": "^16.0.1",
-    "@types/node-forge": "^0.10.1",
-    "@types/varint": "^6.0.0",
-    "aegir": "^33.1.1",
-    "buffer": "^6.0.3",
-    "datastore-core": "^6.0.7",
-    "delay": "^5.0.0",
-    "interop-libp2p": "^0.4.0",
-    "into-stream": "^7.0.0",
-    "ipfs-http-client": "^52.0.2",
-    "it-concat": "^2.0.0",
+    "abortable-iterator": "^3.0.0",
+    "aegir": "^29.2.0",
+    "chai-bytes": "^0.1.2",
+    "chai-string": "^1.5.0",
+    "delay": "^4.4.0",
+    "interop-libp2p": "^0.3.0",
+    "into-stream": "^6.0.0",
+    "ipfs-http-client": "^48.2.2",
+    "it-concat": "^1.0.0",
     "it-pair": "^1.0.0",
     "it-pushable": "^1.4.0",
     "libp2p": ".",
-    "libp2p-bootstrap": "^0.13.0",
-    "libp2p-delegated-content-routing": "^0.11.0",
-    "libp2p-delegated-peer-routing": "^0.10.0",
-    "libp2p-floodsub": "^0.27.0",
-    "libp2p-gossipsub": "^0.11.0",
-    "libp2p-interfaces-compliance-tests": "^1.0.0",
-    "libp2p-kad-dht": "^0.24.2",
-    "libp2p-mdns": "^0.17.0",
+    "libp2p-bootstrap": "^0.12.0",
+    "libp2p-delegated-content-routing": "^0.9.0",
+    "libp2p-delegated-peer-routing": "^0.8.0",
+    "libp2p-floodsub": "^0.24.0",
+    "libp2p-gossipsub": "^0.8.0",
+    "libp2p-kad-dht": "^0.20.5",
+    "libp2p-mdns": "^0.15.0",
     "libp2p-mplex": "^0.10.1",
-    "libp2p-tcp": "^0.17.0",
-    "libp2p-webrtc-star": "^0.23.0",
-    "libp2p-websockets": "^0.16.0",
+    "libp2p-noise": "^2.0.0",
+    "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",
     "rimraf": "^3.0.2",
-    "sinon": "^11.1.1",
-    "util": "^0.12.3"
+    "sinon": "^9.2.4",
+    "uint8arrays": "^2.0.5"
   },
   "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>",
     "Maciej Krüger <mkg20001@gmail.com>",
     "Hugo Dias <mail@hugodias.me>",
-    "Chris Dostert <chrisdostert@users.noreply.github.com>",
-    "dirkmc <dirkmdev@gmail.com>",
     "Volker Mische <volker.mische@gmail.com>",
-    "zeim839 <50573884+zeim839@users.noreply.github.com>",
+    "dirkmc <dirkmdev@gmail.com>",
+    "Chris Dostert <chrisdostert@users.noreply.github.com>",
     "Richard Littauer <richard.littauer@gmail.com>",
     "a1300 <matthias-knopp@gmx.net>",
-    "Ryan Bell <ryan@piing.net>",
-    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
-    "Franck Royer <franck@royer.one>",
-    "Thomas Eizinger <thomas@eizinger.io>",
-    "Giovanni T. Parra <fiatjaf@gmail.com>",
-    "acolytec3 <17355484+acolytec3@users.noreply.github.com>",
     "Elven <mon.samuel@qq.com>",
     "Andrew Nesbitt <andrewnez@gmail.com>",
+    "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
+    "Giovanni T. Parra <fiatjaf@gmail.com>",
+    "Ryan Bell <ryan@piing.net>",
+    "Thomas Eizinger <thomas@eizinger.io>",
     "Samlior <samlior@foxmail.com>",
-    "Didrik Nordström <didrik.nordstrom@gmail.com>",
-    "RasmusErik Voel Jensen <github@solsort.com>",
-    "Robert Kiel <robert.kiel@hoprnet.org>",
-    "Smite Chow <xiaopengyou@live.com>",
-    "Soeren <nikorpoulsen@gmail.com>",
-    "Sönke Hahn <soenkehahn@gmail.com>",
-    "TJKoury <TJKoury@gmail.com>",
-    "Tiago Alves <alvesjtiago@gmail.com>",
-    "XiaoZhang <zxinmyth@gmail.com>",
-    "Yusef Napora <yusef@napora.org>",
-    "Zane Starr <zcstarr@gmail.com>",
-    "ebinks <elizabethjbinks@gmail.com>",
-    "Aditya Bose <13054902+adbose@users.noreply.github.com>",
-    "isan_rivkin <isanrivkin@gmail.com>",
-    "mayerwin <mayerwin@users.noreply.github.com>",
-    "mcclure <andi.m.mcclure@gmail.com>",
-    "phillmac <phillmac@users.noreply.github.com>",
-    "robertkiel <robert.kiel@validitylabs.org>",
-    "shresthagrawal <34920931+shresthagrawal@users.noreply.github.com>",
-    "swedneck <40505480+swedneck@users.noreply.github.com>",
-    "greenSnot <greenSnot@users.noreply.github.com>",
-    "Aleksei <vozhdb@gmail.com>",
-    "Bernd Strehl <bernd.strehl@gmail.com>",
-    "Chris Bratlien <chrisbratlien@gmail.com>",
-    "Cindy Wu <ciindy.wu@gmail.com>",
-    "Daijiro Wachi <daijiro.wachi@gmail.com>",
-    "Diogo Silva <fsdiogo@gmail.com>",
-    "Dmitriy Ryajov <dryajov@gmail.com>",
-    "Ethan Lam <elmemphis2000@gmail.com>",
-    "Fei Liu <liu.feiwood@gmail.com>",
-    "Felipe Martins <felipebrasil93@gmail.com>",
-    "Florian-Merle <florian.david.merle@gmail.com>",
-    "Francis Gulotta <wizard@roborooter.com>",
-    "Guy Sviry <32539816+guysv@users.noreply.github.com>",
-    "Henrique Dias <hacdias@gmail.com>",
-    "Irakli Gozalishvili <rfobic@gmail.com>",
-    "Joel Gustafson <joelg@mit.edu>",
+    "acolytec3 <17355484+acolytec3@users.noreply.github.com>",
+    "Didrik Nordström <didrik@betamos.se>",
     "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>",
     "Michael Burns <5170+mburns@users.noreply.github.com>",
     "Miguel Mota <miguelmota2@gmail.com>",
     "Nuno Nogueira <nunofmn@gmail.com>",
-    "Philipp Muens <raute1337@gmx.de>"
+    "Philipp Muens <raute1337@gmx.de>",
+    "RasmusErik Voel Jensen <github@solsort.com>",
+    "Aditya Bose <13054902+adbose@users.noreply.github.com>",
+    "Smite Chow <xiaopengyou@live.com>",
+    "Soeren <nikorpoulsen@gmail.com>",
+    "Sönke Hahn <soenkehahn@gmail.com>",
+    "TJKoury <TJKoury@gmail.com>",
+    "Tiago Alves <alvesjtiago@gmail.com>",
+    "Daijiro Wachi <daijiro.wachi@gmail.com>",
+    "Cindy Wu <ciindy.wu@gmail.com>",
+    "Chris Bratlien <chrisbratlien@gmail.com>",
+    "Yusef Napora <yusef@napora.org>",
+    "Zane Starr <zcstarr@gmail.com>",
+    "Bernd Strehl <bernd.strehl@gmail.com>",
+    "ebinks <elizabethjbinks@gmail.com>",
+    "Ethan Lam <elmemphis2000@gmail.com>",
+    "isan_rivkin <isanrivkin@gmail.com>",
+    "mayerwin <mayerwin@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>",
+    "Aleksei <vozhdb@gmail.com>",
+    "Fei Liu <liu.feiwood@gmail.com>",
+    "Felipe Martins <felipebrasil93@gmail.com>",
+    "Florian-Merle <florian.david.merle@gmail.com>",
+    "Francis Gulotta <wizard@roborooter.com>",
+    "Dmitriy Ryajov <dryajov@gmail.com>",
+    "Guy Sviry <32539816+guysv@users.noreply.github.com>",
+    "Henrique Dias <hacdias@gmail.com>",
+    "Irakli Gozalishvili <rfobic@gmail.com>",
+    "Diogo Silva <fsdiogo@gmail.com>",
+    "Joel Gustafson <joelg@mit.edu>"
   ]
 }

scripts/node-globals.js

@@ -1,2 +0,0 @@
-// @ts-nocheck
-export const { Buffer } = require('buffer')

src/address-manager/index.js

@@ -1,9 +1,15 @@
 'use strict'
 
-const { EventEmitter } = require('events')
-const { Multiaddr } = require('multiaddr')
+/** @typedef {import('../types').EventEmitterFactory} Events */
+/** @type Events */
+const EventEmitter = require('events')
+const multiaddr = require('multiaddr')
 const PeerId = require('peer-id')
 
+/**
+ * @typedef {import('multiaddr')} Multiaddr
+ */
+
 /**
  * @typedef {Object} AddressManagerOptions
  * @property {string[]} [listen = []] - list of multiaddrs string representation to listen.
@@ -41,7 +47,7 @@ class AddressManager extends EventEmitter {
    * @returns {Multiaddr[]}
    */
   getListenAddrs () {
-    return Array.from(this.listen).map((a) => new Multiaddr(a))
+    return Array.from(this.listen).map((a) => multiaddr(a))
   }
 
   /**
@@ -50,7 +56,7 @@ class AddressManager extends EventEmitter {
    * @returns {Multiaddr[]}
    */
   getAnnounceAddrs () {
-    return Array.from(this.announce).map((a) => new Multiaddr(a))
+    return Array.from(this.announce).map((a) => multiaddr(a))
   }
 
   /**
@@ -59,7 +65,7 @@ class AddressManager extends EventEmitter {
    * @returns {Array<Multiaddr>}
    */
   getObservedAddrs () {
-    return Array.from(this.observed).map((a) => new Multiaddr(a))
+    return Array.from(this.observed).map((a) => multiaddr(a))
   }
 
   /**
@@ -68,7 +74,7 @@ class AddressManager extends EventEmitter {
    * @param {string | Multiaddr} addr
    */
   addObservedAddr (addr) {
-    let ma = new Multiaddr(addr)
+    let ma = multiaddr(addr)
     const remotePeer = ma.getPeerId()
 
     // strip our peer id if it has been passed
@@ -77,7 +83,7 @@ class AddressManager extends EventEmitter {
 
       // use same encoding for comparison
       if (remotePeerId.equals(this.peerId)) {
-        ma = ma.decapsulate(new Multiaddr(`/p2p/${this.peerId}`))
+        ma = ma.decapsulate(multiaddr(`/p2p/${this.peerId}`))
       }
     }
 

src/circuit/README.md

@@ -37,7 +37,7 @@ Libp2p circuit configuration can be seen at [Setup with Relay](../../doc/CONFIGU
 Once you have a circuit relay node running, you can configure other nodes to use it as a relay as follows:
 
 ```js
-const { Multiaddr } = require('multiaddr')
+const multiaddr = require('multiaddr')
 const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
@@ -47,7 +47,7 @@ const relayAddr = ...
 
 const node = await Libp2p.create({
   addresses: {
-    listen: [new Multiaddr(`${relayAddr}/p2p-circuit`)]
+    listen: [multiaddr(`${relayAddr}/p2p-circuit`)]
   },
   modules: {
     transport: [TCP],

src/circuit/auto-relay.js

@@ -5,9 +5,9 @@ const log = Object.assign(debug('libp2p:auto-relay'), {
   error: debug('libp2p:auto-relay:err')
 })
 
-const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-const { Multiaddr } = require('multiaddr')
+const uint8ArrayFromString = require('uint8arrays/from-string')
+const uint8ArrayToString = require('uint8arrays/to-string')
+const multiaddr = require('multiaddr')
 const PeerId = require('peer-id')
 
 const { relay: multicodec } = require('./multicodec')
@@ -31,7 +31,6 @@ const {
  *
  * @typedef {Object} AutoRelayOptions
  * @property {number} [maxListeners = 1] - maximum number of relays to listen.
- * @property {(error: Error, msg?: string) => {}} [onError]
  */
 
 class AutoRelay {
@@ -41,7 +40,7 @@ class AutoRelay {
    * @class
    * @param {AutoRelayProperties & AutoRelayOptions} props
    */
-  constructor ({ libp2p, maxListeners = 1, onError }) {
+  constructor ({ libp2p, maxListeners = 1 }) {
     this._libp2p = libp2p
     this._peerId = libp2p.peerId
     this._peerStore = libp2p.peerStore
@@ -61,15 +60,6 @@ class AutoRelay {
 
     this._peerStore.on('change:protocols', this._onProtocolChange)
     this._connectionManager.on('peer:disconnect', this._onPeerDisconnected)
-
-    /**
-     * @param {Error} error
-     * @param {string} [msg]
-     */
-    this._onError = (error, msg) => {
-      log.error(msg || error)
-      onError && onError(error, msg)
-    }
   }
 
   /**
@@ -117,7 +107,7 @@ class AutoRelay {
         await this._addListenRelay(connection, id)
       }
     } catch (err) {
-      this._onError(err)
+      log.error(err)
     }
   }
 
@@ -167,10 +157,10 @@ class AutoRelay {
 
     // Attempt to listen on relay
     try {
-      await this._transportManager.listen([new Multiaddr(listenAddr)])
+      await this._transportManager.listen([multiaddr(listenAddr)])
       // Announce multiaddrs will update on listen success by TransportManager event being triggered
     } catch (err) {
-      this._onError(err)
+      log.error(err)
       this._listenRelays.delete(id)
     }
   }
@@ -222,7 +212,7 @@ class AutoRelay {
         continue
       }
 
-      const peerId = PeerId.createFromB58String(id)
+      const peerId = PeerId.createFromCID(id)
       const connection = this._connectionManager.get(peerId)
 
       // If not connected, store for possible later use.
@@ -241,7 +231,8 @@ class AutoRelay {
 
     // Try to listen on known peers that are not connected
     for (const peerId of knownHopsToDial) {
-      await this._tryToListenOnRelay(peerId)
+      const connection = await this._libp2p.dial(peerId)
+      await this._addListenRelay(connection, peerId.toB58String())
 
       // Check if already listening on enough relays
       if (this._listenRelays.size >= this.maxListeners) {
@@ -256,11 +247,12 @@ class AutoRelay {
         if (!provider.multiaddrs.length) {
           continue
         }
-
         const peerId = provider.id
-        this._peerStore.addressBook.add(peerId, provider.multiaddrs)
 
-        await this._tryToListenOnRelay(peerId)
+        this._peerStore.addressBook.add(peerId, provider.multiaddrs)
+        const connection = await this._libp2p.dial(peerId)
+
+        await this._addListenRelay(connection, peerId.toB58String())
 
         // Check if already listening on enough relays
         if (this._listenRelays.size >= this.maxListeners) {
@@ -268,19 +260,7 @@ class AutoRelay {
         }
       }
     } catch (err) {
-      this._onError(err)
-    }
-  }
-
-  /**
-   * @param {PeerId} peerId
-   */
-  async _tryToListenOnRelay (peerId) {
-    try {
-      const connection = await this._libp2p.dial(peerId)
-      await this._addListenRelay(connection, peerId.toB58String())
-    } catch (err) {
-      this._onError(err, `could not connect and listen on known hop relay ${peerId.toB58String()}`)
+      log.error(err)
     }
   }
 }

src/circuit/circuit/hop.js

@@ -18,17 +18,17 @@ const { stop } = require('./stop')
 const multicodec = require('./../multicodec')
 
 /**
- * @typedef {import('../protocol').ICircuitRelay} ICircuitRelay
+ * @typedef {import('../../types').CircuitRequest} CircuitRequest
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
+ * @typedef {import('./stream-handler')<CircuitRequest>} StreamHandlerT
  * @typedef {import('../transport')} Transport
  */
 
 /**
  * @typedef {Object} HopRequest
  * @property {Connection} connection
- * @property {ICircuitRelay} request
- * @property {StreamHandler} streamHandler
+ * @property {CircuitRequest} request
+ * @property {StreamHandlerT} streamHandler
  * @property {Transport} circuit
  */
 
@@ -58,11 +58,6 @@ async function handleHop ({
     return log.error('invalid hop request via peer %s', connection.remotePeer.toB58String(), err)
   }
 
-  if (!request.dstPeer) {
-    log('HOP request received but we do not receive a dstPeer')
-    return
-  }
-
   // Get the connection to the destination (stop) peer
   const destinationPeer = new PeerId(request.dstPeer.id)
 
@@ -118,8 +113,8 @@ async function handleHop ({
  *
  * @param {object} options
  * @param {Connection} options.connection - Connection to the relay
- * @param {ICircuitRelay} options.request
- * @returns {Promise<MuxedStream>}
+ * @param {CircuitRequest} options.request
+ * @returns {Promise<Connection>}
  */
 async function hop ({
   connection,
@@ -133,10 +128,6 @@ async function hop ({
 
   const response = await streamHandler.read()
 
-  if (!response) {
-    throw errCode(new Error('HOP request had no response'), Errors.ERR_HOP_REQUEST_FAILED)
-  }
-
   if (response.code === CircuitPB.Status.SUCCESS) {
     log('hop request was successful')
     return streamHandler.rest()
@@ -168,7 +159,7 @@ async function canHop ({
   const response = await streamHandler.read()
   await streamHandler.close()
 
-  if (!response || response.code !== CircuitPB.Status.SUCCESS) {
+  if (response.code !== CircuitPB.Status.SUCCESS) {
     return false
   }
 
@@ -180,7 +171,7 @@ async function canHop ({
  *
  * @param {Object} options
  * @param {Connection} options.connection
- * @param {StreamHandler} options.streamHandler
+ * @param {StreamHandlerT} options.streamHandler
  * @param {Transport} options.circuit
  * @private
  */

src/circuit/circuit/stop.js

@@ -13,7 +13,8 @@ const { validateAddrs } = require('./utils')
 /**
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
  * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
- * @typedef {import('../protocol').ICircuitRelay} ICircuitRelay
+ * @typedef {import('../../types').CircuitRequest} CircuitRequest
+ * @typedef {import('./stream-handler')<CircuitRequest>} StreamHandlerT
  */
 
 /**
@@ -22,8 +23,8 @@ const { validateAddrs } = require('./utils')
  * @private
  * @param {Object} options
  * @param {Connection} options.connection
- * @param {ICircuitRelay} options.request - The CircuitRelay protobuf request (unencoded)
- * @param {StreamHandler} options.streamHandler
+ * @param {CircuitRequest} options.request - The CircuitRelay protobuf request (unencoded)
+ * @param {StreamHandlerT} options.streamHandler
  * @returns {Promise<MuxedStream>|void} Resolves a duplex iterable
  */
 module.exports.handleStop = function handleStop ({
@@ -53,7 +54,7 @@ module.exports.handleStop = function handleStop ({
  * @private
  * @param {Object} options
  * @param {Connection} options.connection
- * @param {ICircuitRelay} options.request - The CircuitRelay protobuf request (unencoded)
+ * @param {CircuitRequest} options.request - The CircuitRelay protobuf request (unencoded)
  * @returns {Promise<MuxedStream|void>} Resolves a duplex iterable
  */
 module.exports.stop = async function stop ({
@@ -67,10 +68,6 @@ module.exports.stop = async function stop ({
   streamHandler.write(request)
   const response = await streamHandler.read()
 
-  if (!response) {
-    return streamHandler.close()
-  }
-
   if (response.code === CircuitPB.Status.SUCCESS) {
     log('stop request to %s was successful', connection.remotePeer.toB58String())
     return streamHandler.rest()

src/circuit/circuit/stream-handler.js

@@ -6,15 +6,16 @@ const log = Object.assign(debug('libp2p:circuit:stream-handler'), {
 })
 
 const lp = require('it-length-prefixed')
-// @ts-ignore it-handshake does not export types
 const handshake = require('it-handshake')
-const { CircuitRelay } = require('../protocol')
+const { CircuitRelay: CircuitPB } = require('../protocol')
 
 /**
  * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
- * @typedef {import('../protocol').ICircuitRelay} ICircuitRelay
  */
 
+/**
+ * @template T
+ */
 class StreamHandler {
   /**
    * Create a stream handler for connection
@@ -28,7 +29,6 @@ class StreamHandler {
     this.stream = stream
 
     this.shake = handshake(this.stream)
-    // @ts-ignore options are not optional
     this.decoder = lp.decode.fromReader(this.shake.reader, { maxDataLength: maxLength })
   }
 
@@ -36,11 +36,12 @@ class StreamHandler {
    * Read and decode message
    *
    * @async
+   * @returns {Promise<T|undefined>}
    */
   async read () {
     const msg = await this.decoder.next()
     if (msg.value) {
-      const value = CircuitRelay.decode(msg.value.slice())
+      const value = CircuitPB.decode(msg.value.slice())
       log('read message type', value.type)
       return value
     }
@@ -53,13 +54,13 @@ class StreamHandler {
   /**
    * Encode and write array of buffers
    *
-   * @param {ICircuitRelay} msg - An unencoded CircuitRelay protobuf message
+   * @param {CircuitPB} msg - An unencoded CircuitRelay protobuf message
    * @returns {void}
    */
   write (msg) {
     log('write message type %s', msg.type)
     // @ts-ignore lp.encode expects type type 'Buffer | BufferList', not 'Uint8Array'
-    this.shake.write(lp.encode.single(CircuitRelay.encode(msg).finish()))
+    this.shake.write(lp.encode.single(CircuitPB.encode(msg)))
   }
 
   /**
@@ -72,9 +73,6 @@ class StreamHandler {
     return this.shake.stream
   }
 
-  /**
-   * @param {ICircuitRelay} msg - An unencoded CircuitRelay protobuf message
-   */
   end (msg) {
     this.write(msg)
     this.close()

src/circuit/circuit/utils.js

@@ -1,18 +1,18 @@
 'use strict'
 
-const { Multiaddr } = require('multiaddr')
+const multiaddr = require('multiaddr')
 const { CircuitRelay } = require('../protocol')
 
 /**
  * @typedef {import('./stream-handler')} StreamHandler
- * @typedef {import('../protocol').ICircuitRelay} ICircuitRelay
+ * @typedef {import('../../types').CircuitStatus} CircuitStatus
  */
 
 /**
  * Write a response
  *
  * @param {StreamHandler} streamHandler
- * @param {import('../protocol').CircuitRelay.Status} status
+ * @param {CircuitStatus} status
  */
 function writeResponse (streamHandler, status) {
   streamHandler.write({
@@ -24,16 +24,14 @@ function writeResponse (streamHandler, status) {
 /**
  * Validate incomming HOP/STOP message
  *
- * @param {ICircuitRelay} msg - A CircuitRelay unencoded protobuf message
+ * @param {*} msg - A CircuitRelay unencoded protobuf message
  * @param {StreamHandler} streamHandler
  */
 function validateAddrs (msg, streamHandler) {
   try {
-    if (msg.dstPeer && msg.dstPeer.addrs) {
     msg.dstPeer.addrs.forEach((addr) => {
-        return new Multiaddr(addr)
+      return multiaddr(addr)
     })
-    }
   } catch (err) {
     writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
       ? CircuitRelay.Status.HOP_DST_MULTIADDR_INVALID
@@ -42,11 +40,9 @@ function validateAddrs (msg, streamHandler) {
   }
 
   try {
-    if (msg.srcPeer && msg.srcPeer.addrs) {
     msg.srcPeer.addrs.forEach((addr) => {
-        return new Multiaddr(addr)
+      return multiaddr(addr)
     })
-    }
   } catch (err) {
     writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
       ? CircuitRelay.Status.HOP_SRC_MULTIADDR_INVALID

src/circuit/index.js

@@ -8,12 +8,13 @@ const log = Object.assign(debug('libp2p:relay'), {
 const {
   setDelayedInterval,
   clearDelayedInterval
-// @ts-ignore set-delayed-interval does not export types
 } = require('set-delayed-interval')
 
 const AutoRelay = require('./auto-relay')
 const { namespaceToCid } = require('./utils')
 const {
+  ADVERTISE_BOOT_DELAY,
+  ADVERTISE_TTL,
   RELAY_RENDEZVOUS_NS
 } = require('./constants')
 
@@ -44,6 +45,12 @@ class Relay {
   constructor (libp2p) {
     this._libp2p = libp2p
     this._options = {
+      advertise: {
+        bootDelay: ADVERTISE_BOOT_DELAY,
+        enabled: true,
+        ttl: ADVERTISE_TTL,
+        ...libp2p._config.relay.advertise
+      },
       ...libp2p._config.relay
     }
 

src/circuit/listener.js

@@ -1,9 +1,10 @@
 'use strict'
 
 const { EventEmitter } = require('events')
-const { Multiaddr } = require('multiaddr')
+const multiaddr = require('multiaddr')
 
 /**
+ * @typedef {import('multiaddr')} Multiaddr
  * @typedef {import('libp2p-interfaces/src/transport/types').Listener} Listener
  */
 
@@ -23,7 +24,7 @@ module.exports = (libp2p) => {
   async function listen (addr) {
     const addrString = String(addr).split('/p2p-circuit').find(a => a !== '')
 
-    const relayConn = await libp2p.dial(new Multiaddr(addrString))
+    const relayConn = await libp2p.dial(multiaddr(addrString))
     const relayedAddr = relayConn.remoteAddr.encapsulate('/p2p-circuit')
 
     listeningAddrs.set(relayConn.remotePeer.toB58String(), relayedAddr)

src/circuit/protocol/index.d.ts

@@ -1,173 +0,0 @@
-import * as $protobuf from "protobufjs";
-/** Properties of a CircuitRelay. */
-export interface ICircuitRelay {
-
-    /** CircuitRelay type */
-    type?: (CircuitRelay.Type|null);
-
-    /** CircuitRelay srcPeer */
-    srcPeer?: (CircuitRelay.IPeer|null);
-
-    /** CircuitRelay dstPeer */
-    dstPeer?: (CircuitRelay.IPeer|null);
-
-    /** CircuitRelay code */
-    code?: (CircuitRelay.Status|null);
-}
-
-/** Represents a CircuitRelay. */
-export class CircuitRelay implements ICircuitRelay {
-
-    /**
-     * Constructs a new CircuitRelay.
-     * @param [p] Properties to set
-     */
-    constructor(p?: ICircuitRelay);
-
-    /** CircuitRelay type. */
-    public type: CircuitRelay.Type;
-
-    /** CircuitRelay srcPeer. */
-    public srcPeer?: (CircuitRelay.IPeer|null);
-
-    /** CircuitRelay dstPeer. */
-    public dstPeer?: (CircuitRelay.IPeer|null);
-
-    /** CircuitRelay code. */
-    public code: CircuitRelay.Status;
-
-    /**
-     * Encodes the specified CircuitRelay message. Does not implicitly {@link CircuitRelay.verify|verify} messages.
-     * @param m CircuitRelay message or plain object to encode
-     * @param [w] Writer to encode to
-     * @returns Writer
-     */
-    public static encode(m: ICircuitRelay, w?: $protobuf.Writer): $protobuf.Writer;
-
-    /**
-     * Decodes a CircuitRelay message from the specified reader or buffer.
-     * @param r Reader or buffer to decode from
-     * @param [l] Message length if known beforehand
-     * @returns CircuitRelay
-     * @throws {Error} If the payload is not a reader or valid buffer
-     * @throws {$protobuf.util.ProtocolError} If required fields are missing
-     */
-    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): CircuitRelay;
-
-    /**
-     * Creates a CircuitRelay message from a plain object. Also converts values to their respective internal types.
-     * @param d Plain object
-     * @returns CircuitRelay
-     */
-    public static fromObject(d: { [k: string]: any }): CircuitRelay;
-
-    /**
-     * Creates a plain object from a CircuitRelay message. Also converts values to other types if specified.
-     * @param m CircuitRelay
-     * @param [o] Conversion options
-     * @returns Plain object
-     */
-    public static toObject(m: CircuitRelay, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-    /**
-     * Converts this CircuitRelay to JSON.
-     * @returns JSON object
-     */
-    public toJSON(): { [k: string]: any };
-}
-
-export namespace CircuitRelay {
-
-    /** Status enum. */
-    enum Status {
-        SUCCESS = 100,
-        HOP_SRC_ADDR_TOO_LONG = 220,
-        HOP_DST_ADDR_TOO_LONG = 221,
-        HOP_SRC_MULTIADDR_INVALID = 250,
-        HOP_DST_MULTIADDR_INVALID = 251,
-        HOP_NO_CONN_TO_DST = 260,
-        HOP_CANT_DIAL_DST = 261,
-        HOP_CANT_OPEN_DST_STREAM = 262,
-        HOP_CANT_SPEAK_RELAY = 270,
-        HOP_CANT_RELAY_TO_SELF = 280,
-        STOP_SRC_ADDR_TOO_LONG = 320,
-        STOP_DST_ADDR_TOO_LONG = 321,
-        STOP_SRC_MULTIADDR_INVALID = 350,
-        STOP_DST_MULTIADDR_INVALID = 351,
-        STOP_RELAY_REFUSED = 390,
-        MALFORMED_MESSAGE = 400
-    }
-
-    /** Type enum. */
-    enum Type {
-        HOP = 1,
-        STOP = 2,
-        STATUS = 3,
-        CAN_HOP = 4
-    }
-
-    /** Properties of a Peer. */
-    interface IPeer {
-
-        /** Peer id */
-        id: Uint8Array;
-
-        /** Peer addrs */
-        addrs?: (Uint8Array[]|null);
-    }
-
-    /** Represents a Peer. */
-    class Peer implements IPeer {
-
-        /**
-         * Constructs a new Peer.
-         * @param [p] Properties to set
-         */
-        constructor(p?: CircuitRelay.IPeer);
-
-        /** Peer id. */
-        public id: Uint8Array;
-
-        /** Peer addrs. */
-        public addrs: Uint8Array[];
-
-        /**
-         * Encodes the specified Peer message. Does not implicitly {@link CircuitRelay.Peer.verify|verify} messages.
-         * @param m Peer message or plain object to encode
-         * @param [w] Writer to encode to
-         * @returns Writer
-         */
-        public static encode(m: CircuitRelay.IPeer, w?: $protobuf.Writer): $protobuf.Writer;
-
-        /**
-         * Decodes a Peer message from the specified reader or buffer.
-         * @param r Reader or buffer to decode from
-         * @param [l] Message length if known beforehand
-         * @returns Peer
-         * @throws {Error} If the payload is not a reader or valid buffer
-         * @throws {$protobuf.util.ProtocolError} If required fields are missing
-         */
-        public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): CircuitRelay.Peer;
-
-        /**
-         * Creates a Peer message from a plain object. Also converts values to their respective internal types.
-         * @param d Plain object
-         * @returns Peer
-         */
-        public static fromObject(d: { [k: string]: any }): CircuitRelay.Peer;
-
-        /**
-         * Creates a plain object from a Peer message. Also converts values to other types if specified.
-         * @param m Peer
-         * @param [o] Conversion options
-         * @returns Plain object
-         */
-        public static toObject(m: CircuitRelay.Peer, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-        /**
-         * Converts this Peer to JSON.
-         * @returns JSON object
-         */
-        public toJSON(): { [k: string]: any };
-    }
-}

src/circuit/protocol/index.js

@@ -1,530 +1,46 @@
-/*eslint-disable*/
-"use strict";
+'use strict'
+const protobuf = require('protons')
 
-var $protobuf = require("protobufjs/minimal");
+/** @type {{CircuitRelay: import('../../types').CircuitMessageProto}} */
+module.exports = protobuf(`
+message CircuitRelay {
 
-// Common aliases
-var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
-
-// Exported root namespace
-var $root = $protobuf.roots["libp2p-circuit"] || ($protobuf.roots["libp2p-circuit"] = {});
-
-$root.CircuitRelay = (function() {
-
-    /**
-     * Properties of a CircuitRelay.
-     * @exports ICircuitRelay
-     * @interface ICircuitRelay
-     * @property {CircuitRelay.Type|null} [type] CircuitRelay type
-     * @property {CircuitRelay.IPeer|null} [srcPeer] CircuitRelay srcPeer
-     * @property {CircuitRelay.IPeer|null} [dstPeer] CircuitRelay dstPeer
-     * @property {CircuitRelay.Status|null} [code] CircuitRelay code
-     */
-
-    /**
-     * Constructs a new CircuitRelay.
-     * @exports CircuitRelay
-     * @classdesc Represents a CircuitRelay.
-     * @implements ICircuitRelay
-     * @constructor
-     * @param {ICircuitRelay=} [p] Properties to set
-     */
-    function CircuitRelay(p) {
-        if (p)
-            for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
-                if (p[ks[i]] != null)
-                    this[ks[i]] = p[ks[i]];
+  enum Status {
+    SUCCESS                    = 100;
+    HOP_SRC_ADDR_TOO_LONG      = 220;
+    HOP_DST_ADDR_TOO_LONG      = 221;
+    HOP_SRC_MULTIADDR_INVALID  = 250;
+    HOP_DST_MULTIADDR_INVALID  = 251;
+    HOP_NO_CONN_TO_DST         = 260;
+    HOP_CANT_DIAL_DST          = 261;
+    HOP_CANT_OPEN_DST_STREAM   = 262;
+    HOP_CANT_SPEAK_RELAY       = 270;
+    HOP_CANT_RELAY_TO_SELF     = 280;
+    STOP_SRC_ADDR_TOO_LONG     = 320;
+    STOP_DST_ADDR_TOO_LONG     = 321;
+    STOP_SRC_MULTIADDR_INVALID = 350;
+    STOP_DST_MULTIADDR_INVALID = 351;
+    STOP_RELAY_REFUSED         = 390;
+    MALFORMED_MESSAGE          = 400;
   }
 
-    /**
-     * CircuitRelay type.
-     * @member {CircuitRelay.Type} type
-     * @memberof CircuitRelay
-     * @instance
-     */
-    CircuitRelay.prototype.type = 1;
-
-    /**
-     * CircuitRelay srcPeer.
-     * @member {CircuitRelay.IPeer|null|undefined} srcPeer
-     * @memberof CircuitRelay
-     * @instance
-     */
-    CircuitRelay.prototype.srcPeer = null;
-
-    /**
-     * CircuitRelay dstPeer.
-     * @member {CircuitRelay.IPeer|null|undefined} dstPeer
-     * @memberof CircuitRelay
-     * @instance
-     */
-    CircuitRelay.prototype.dstPeer = null;
-
-    /**
-     * CircuitRelay code.
-     * @member {CircuitRelay.Status} code
-     * @memberof CircuitRelay
-     * @instance
-     */
-    CircuitRelay.prototype.code = 100;
-
-    /**
-     * Encodes the specified CircuitRelay message. Does not implicitly {@link CircuitRelay.verify|verify} messages.
-     * @function encode
-     * @memberof CircuitRelay
-     * @static
-     * @param {ICircuitRelay} m CircuitRelay message or plain object to encode
-     * @param {$protobuf.Writer} [w] Writer to encode to
-     * @returns {$protobuf.Writer} Writer
-     */
-    CircuitRelay.encode = function encode(m, w) {
-        if (!w)
-            w = $Writer.create();
-        if (m.type != null && Object.hasOwnProperty.call(m, "type"))
-            w.uint32(8).int32(m.type);
-        if (m.srcPeer != null && Object.hasOwnProperty.call(m, "srcPeer"))
-            $root.CircuitRelay.Peer.encode(m.srcPeer, w.uint32(18).fork()).ldelim();
-        if (m.dstPeer != null && Object.hasOwnProperty.call(m, "dstPeer"))
-            $root.CircuitRelay.Peer.encode(m.dstPeer, w.uint32(26).fork()).ldelim();
-        if (m.code != null && Object.hasOwnProperty.call(m, "code"))
-            w.uint32(32).int32(m.code);
-        return w;
-    };
-
-    /**
-     * Decodes a CircuitRelay message from the specified reader or buffer.
-     * @function decode
-     * @memberof CircuitRelay
-     * @static
-     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
-     * @param {number} [l] Message length if known beforehand
-     * @returns {CircuitRelay} CircuitRelay
-     * @throws {Error} If the payload is not a reader or valid buffer
-     * @throws {$protobuf.util.ProtocolError} If required fields are missing
-     */
-    CircuitRelay.decode = function decode(r, l) {
-        if (!(r instanceof $Reader))
-            r = $Reader.create(r);
-        var c = l === undefined ? r.len : r.pos + l, m = new $root.CircuitRelay();
-        while (r.pos < c) {
-            var t = r.uint32();
-            switch (t >>> 3) {
-            case 1:
-                m.type = r.int32();
-                break;
-            case 2:
-                m.srcPeer = $root.CircuitRelay.Peer.decode(r, r.uint32());
-                break;
-            case 3:
-                m.dstPeer = $root.CircuitRelay.Peer.decode(r, r.uint32());
-                break;
-            case 4:
-                m.code = r.int32();
-                break;
-            default:
-                r.skipType(t & 7);
-                break;
-            }
-        }
-        return m;
-    };
-
-    /**
-     * Creates a CircuitRelay message from a plain object. Also converts values to their respective internal types.
-     * @function fromObject
-     * @memberof CircuitRelay
-     * @static
-     * @param {Object.<string,*>} d Plain object
-     * @returns {CircuitRelay} CircuitRelay
-     */
-    CircuitRelay.fromObject = function fromObject(d) {
-        if (d instanceof $root.CircuitRelay)
-            return d;
-        var m = new $root.CircuitRelay();
-        switch (d.type) {
-        case "HOP":
-        case 1:
-            m.type = 1;
-            break;
-        case "STOP":
-        case 2:
-            m.type = 2;
-            break;
-        case "STATUS":
-        case 3:
-            m.type = 3;
-            break;
-        case "CAN_HOP":
-        case 4:
-            m.type = 4;
-            break;
-        }
-        if (d.srcPeer != null) {
-            if (typeof d.srcPeer !== "object")
-                throw TypeError(".CircuitRelay.srcPeer: object expected");
-            m.srcPeer = $root.CircuitRelay.Peer.fromObject(d.srcPeer);
-        }
-        if (d.dstPeer != null) {
-            if (typeof d.dstPeer !== "object")
-                throw TypeError(".CircuitRelay.dstPeer: object expected");
-            m.dstPeer = $root.CircuitRelay.Peer.fromObject(d.dstPeer);
-        }
-        switch (d.code) {
-        case "SUCCESS":
-        case 100:
-            m.code = 100;
-            break;
-        case "HOP_SRC_ADDR_TOO_LONG":
-        case 220:
-            m.code = 220;
-            break;
-        case "HOP_DST_ADDR_TOO_LONG":
-        case 221:
-            m.code = 221;
-            break;
-        case "HOP_SRC_MULTIADDR_INVALID":
-        case 250:
-            m.code = 250;
-            break;
-        case "HOP_DST_MULTIADDR_INVALID":
-        case 251:
-            m.code = 251;
-            break;
-        case "HOP_NO_CONN_TO_DST":
-        case 260:
-            m.code = 260;
-            break;
-        case "HOP_CANT_DIAL_DST":
-        case 261:
-            m.code = 261;
-            break;
-        case "HOP_CANT_OPEN_DST_STREAM":
-        case 262:
-            m.code = 262;
-            break;
-        case "HOP_CANT_SPEAK_RELAY":
-        case 270:
-            m.code = 270;
-            break;
-        case "HOP_CANT_RELAY_TO_SELF":
-        case 280:
-            m.code = 280;
-            break;
-        case "STOP_SRC_ADDR_TOO_LONG":
-        case 320:
-            m.code = 320;
-            break;
-        case "STOP_DST_ADDR_TOO_LONG":
-        case 321:
-            m.code = 321;
-            break;
-        case "STOP_SRC_MULTIADDR_INVALID":
-        case 350:
-            m.code = 350;
-            break;
-        case "STOP_DST_MULTIADDR_INVALID":
-        case 351:
-            m.code = 351;
-            break;
-        case "STOP_RELAY_REFUSED":
-        case 390:
-            m.code = 390;
-            break;
-        case "MALFORMED_MESSAGE":
-        case 400:
-            m.code = 400;
-            break;
-        }
-        return m;
-    };
-
-    /**
-     * Creates a plain object from a CircuitRelay message. Also converts values to other types if specified.
-     * @function toObject
-     * @memberof CircuitRelay
-     * @static
-     * @param {CircuitRelay} m CircuitRelay
-     * @param {$protobuf.IConversionOptions} [o] Conversion options
-     * @returns {Object.<string,*>} Plain object
-     */
-    CircuitRelay.toObject = function toObject(m, o) {
-        if (!o)
-            o = {};
-        var d = {};
-        if (o.defaults) {
-            d.type = o.enums === String ? "HOP" : 1;
-            d.srcPeer = null;
-            d.dstPeer = null;
-            d.code = o.enums === String ? "SUCCESS" : 100;
-        }
-        if (m.type != null && m.hasOwnProperty("type")) {
-            d.type = o.enums === String ? $root.CircuitRelay.Type[m.type] : m.type;
-        }
-        if (m.srcPeer != null && m.hasOwnProperty("srcPeer")) {
-            d.srcPeer = $root.CircuitRelay.Peer.toObject(m.srcPeer, o);
-        }
-        if (m.dstPeer != null && m.hasOwnProperty("dstPeer")) {
-            d.dstPeer = $root.CircuitRelay.Peer.toObject(m.dstPeer, o);
-        }
-        if (m.code != null && m.hasOwnProperty("code")) {
-            d.code = o.enums === String ? $root.CircuitRelay.Status[m.code] : m.code;
-        }
-        return d;
-    };
-
-    /**
-     * Converts this CircuitRelay to JSON.
-     * @function toJSON
-     * @memberof CircuitRelay
-     * @instance
-     * @returns {Object.<string,*>} JSON object
-     */
-    CircuitRelay.prototype.toJSON = function toJSON() {
-        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
-    };
-
-    /**
-     * Status enum.
-     * @name CircuitRelay.Status
-     * @enum {number}
-     * @property {number} SUCCESS=100 SUCCESS value
-     * @property {number} HOP_SRC_ADDR_TOO_LONG=220 HOP_SRC_ADDR_TOO_LONG value
-     * @property {number} HOP_DST_ADDR_TOO_LONG=221 HOP_DST_ADDR_TOO_LONG value
-     * @property {number} HOP_SRC_MULTIADDR_INVALID=250 HOP_SRC_MULTIADDR_INVALID value
-     * @property {number} HOP_DST_MULTIADDR_INVALID=251 HOP_DST_MULTIADDR_INVALID value
-     * @property {number} HOP_NO_CONN_TO_DST=260 HOP_NO_CONN_TO_DST value
-     * @property {number} HOP_CANT_DIAL_DST=261 HOP_CANT_DIAL_DST value
-     * @property {number} HOP_CANT_OPEN_DST_STREAM=262 HOP_CANT_OPEN_DST_STREAM value
-     * @property {number} HOP_CANT_SPEAK_RELAY=270 HOP_CANT_SPEAK_RELAY value
-     * @property {number} HOP_CANT_RELAY_TO_SELF=280 HOP_CANT_RELAY_TO_SELF value
-     * @property {number} STOP_SRC_ADDR_TOO_LONG=320 STOP_SRC_ADDR_TOO_LONG value
-     * @property {number} STOP_DST_ADDR_TOO_LONG=321 STOP_DST_ADDR_TOO_LONG value
-     * @property {number} STOP_SRC_MULTIADDR_INVALID=350 STOP_SRC_MULTIADDR_INVALID value
-     * @property {number} STOP_DST_MULTIADDR_INVALID=351 STOP_DST_MULTIADDR_INVALID value
-     * @property {number} STOP_RELAY_REFUSED=390 STOP_RELAY_REFUSED value
-     * @property {number} MALFORMED_MESSAGE=400 MALFORMED_MESSAGE value
-     */
-    CircuitRelay.Status = (function() {
-        var valuesById = {}, values = Object.create(valuesById);
-        values[valuesById[100] = "SUCCESS"] = 100;
-        values[valuesById[220] = "HOP_SRC_ADDR_TOO_LONG"] = 220;
-        values[valuesById[221] = "HOP_DST_ADDR_TOO_LONG"] = 221;
-        values[valuesById[250] = "HOP_SRC_MULTIADDR_INVALID"] = 250;
-        values[valuesById[251] = "HOP_DST_MULTIADDR_INVALID"] = 251;
-        values[valuesById[260] = "HOP_NO_CONN_TO_DST"] = 260;
-        values[valuesById[261] = "HOP_CANT_DIAL_DST"] = 261;
-        values[valuesById[262] = "HOP_CANT_OPEN_DST_STREAM"] = 262;
-        values[valuesById[270] = "HOP_CANT_SPEAK_RELAY"] = 270;
-        values[valuesById[280] = "HOP_CANT_RELAY_TO_SELF"] = 280;
-        values[valuesById[320] = "STOP_SRC_ADDR_TOO_LONG"] = 320;
-        values[valuesById[321] = "STOP_DST_ADDR_TOO_LONG"] = 321;
-        values[valuesById[350] = "STOP_SRC_MULTIADDR_INVALID"] = 350;
-        values[valuesById[351] = "STOP_DST_MULTIADDR_INVALID"] = 351;
-        values[valuesById[390] = "STOP_RELAY_REFUSED"] = 390;
-        values[valuesById[400] = "MALFORMED_MESSAGE"] = 400;
-        return values;
-    })();
-
-    /**
-     * Type enum.
-     * @name CircuitRelay.Type
-     * @enum {number}
-     * @property {number} HOP=1 HOP value
-     * @property {number} STOP=2 STOP value
-     * @property {number} STATUS=3 STATUS value
-     * @property {number} CAN_HOP=4 CAN_HOP value
-     */
-    CircuitRelay.Type = (function() {
-        var valuesById = {}, values = Object.create(valuesById);
-        values[valuesById[1] = "HOP"] = 1;
-        values[valuesById[2] = "STOP"] = 2;
-        values[valuesById[3] = "STATUS"] = 3;
-        values[valuesById[4] = "CAN_HOP"] = 4;
-        return values;
-    })();
-
-    CircuitRelay.Peer = (function() {
-
-        /**
-         * Properties of a Peer.
-         * @memberof CircuitRelay
-         * @interface IPeer
-         * @property {Uint8Array} id Peer id
-         * @property {Array.<Uint8Array>|null} [addrs] Peer addrs
-         */
-
-        /**
-         * Constructs a new Peer.
-         * @memberof CircuitRelay
-         * @classdesc Represents a Peer.
-         * @implements IPeer
-         * @constructor
-         * @param {CircuitRelay.IPeer=} [p] Properties to set
-         */
-        function Peer(p) {
-            this.addrs = [];
-            if (p)
-                for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
-                    if (p[ks[i]] != null)
-                        this[ks[i]] = p[ks[i]];
+  enum Type { // RPC identifier, either HOP, STOP or STATUS
+    HOP = 1;
+    STOP = 2;
+    STATUS = 3;
+    CAN_HOP = 4;
   }
 
-        /**
-         * Peer id.
-         * @member {Uint8Array} id
-         * @memberof CircuitRelay.Peer
-         * @instance
-         */
-        Peer.prototype.id = $util.newBuffer([]);
+  message Peer {
+    required bytes id = 1;    // peer id
+    repeated bytes addrs = 2; // peer's known addresses
+  }
 
-        /**
-         * Peer addrs.
-         * @member {Array.<Uint8Array>} addrs
-         * @memberof CircuitRelay.Peer
-         * @instance
-         */
-        Peer.prototype.addrs = $util.emptyArray;
+  optional Type type = 1;     // Type of the message
 
-        /**
-         * Encodes the specified Peer message. Does not implicitly {@link CircuitRelay.Peer.verify|verify} messages.
-         * @function encode
-         * @memberof CircuitRelay.Peer
-         * @static
-         * @param {CircuitRelay.IPeer} m Peer message or plain object to encode
-         * @param {$protobuf.Writer} [w] Writer to encode to
-         * @returns {$protobuf.Writer} Writer
-         */
-        Peer.encode = function encode(m, w) {
-            if (!w)
-                w = $Writer.create();
-            w.uint32(10).bytes(m.id);
-            if (m.addrs != null && m.addrs.length) {
-                for (var i = 0; i < m.addrs.length; ++i)
-                    w.uint32(18).bytes(m.addrs[i]);
-            }
-            return w;
-        };
+  optional Peer srcPeer = 2;  // srcPeer and dstPeer are used when Type is HOP or STATUS
+  optional Peer dstPeer = 3;
 
-        /**
-         * Decodes a Peer message from the specified reader or buffer.
-         * @function decode
-         * @memberof CircuitRelay.Peer
-         * @static
-         * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
-         * @param {number} [l] Message length if known beforehand
-         * @returns {CircuitRelay.Peer} Peer
-         * @throws {Error} If the payload is not a reader or valid buffer
-         * @throws {$protobuf.util.ProtocolError} If required fields are missing
-         */
-        Peer.decode = function decode(r, l) {
-            if (!(r instanceof $Reader))
-                r = $Reader.create(r);
-            var c = l === undefined ? r.len : r.pos + l, m = new $root.CircuitRelay.Peer();
-            while (r.pos < c) {
-                var t = r.uint32();
-                switch (t >>> 3) {
-                case 1:
-                    m.id = r.bytes();
-                    break;
-                case 2:
-                    if (!(m.addrs && m.addrs.length))
-                        m.addrs = [];
-                    m.addrs.push(r.bytes());
-                    break;
-                default:
-                    r.skipType(t & 7);
-                    break;
+  optional Status code = 4;   // Status code, used when Type is STATUS
 }
-            }
-            if (!m.hasOwnProperty("id"))
-                throw $util.ProtocolError("missing required 'id'", { instance: m });
-            return m;
-        };
-
-        /**
-         * Creates a Peer message from a plain object. Also converts values to their respective internal types.
-         * @function fromObject
-         * @memberof CircuitRelay.Peer
-         * @static
-         * @param {Object.<string,*>} d Plain object
-         * @returns {CircuitRelay.Peer} Peer
-         */
-        Peer.fromObject = function fromObject(d) {
-            if (d instanceof $root.CircuitRelay.Peer)
-                return d;
-            var m = new $root.CircuitRelay.Peer();
-            if (d.id != null) {
-                if (typeof d.id === "string")
-                    $util.base64.decode(d.id, m.id = $util.newBuffer($util.base64.length(d.id)), 0);
-                else if (d.id.length)
-                    m.id = d.id;
-            }
-            if (d.addrs) {
-                if (!Array.isArray(d.addrs))
-                    throw TypeError(".CircuitRelay.Peer.addrs: array expected");
-                m.addrs = [];
-                for (var i = 0; i < d.addrs.length; ++i) {
-                    if (typeof d.addrs[i] === "string")
-                        $util.base64.decode(d.addrs[i], m.addrs[i] = $util.newBuffer($util.base64.length(d.addrs[i])), 0);
-                    else if (d.addrs[i].length)
-                        m.addrs[i] = d.addrs[i];
-                }
-            }
-            return m;
-        };
-
-        /**
-         * Creates a plain object from a Peer message. Also converts values to other types if specified.
-         * @function toObject
-         * @memberof CircuitRelay.Peer
-         * @static
-         * @param {CircuitRelay.Peer} m Peer
-         * @param {$protobuf.IConversionOptions} [o] Conversion options
-         * @returns {Object.<string,*>} Plain object
-         */
-        Peer.toObject = function toObject(m, o) {
-            if (!o)
-                o = {};
-            var d = {};
-            if (o.arrays || o.defaults) {
-                d.addrs = [];
-            }
-            if (o.defaults) {
-                if (o.bytes === String)
-                    d.id = "";
-                else {
-                    d.id = [];
-                    if (o.bytes !== Array)
-                        d.id = $util.newBuffer(d.id);
-                }
-            }
-            if (m.id != null && m.hasOwnProperty("id")) {
-                d.id = o.bytes === String ? $util.base64.encode(m.id, 0, m.id.length) : o.bytes === Array ? Array.prototype.slice.call(m.id) : m.id;
-            }
-            if (m.addrs && m.addrs.length) {
-                d.addrs = [];
-                for (var j = 0; j < m.addrs.length; ++j) {
-                    d.addrs[j] = o.bytes === String ? $util.base64.encode(m.addrs[j], 0, m.addrs[j].length) : o.bytes === Array ? Array.prototype.slice.call(m.addrs[j]) : m.addrs[j];
-                }
-            }
-            return d;
-        };
-
-        /**
-         * Converts this Peer to JSON.
-         * @function toJSON
-         * @memberof CircuitRelay.Peer
-         * @instance
-         * @returns {Object.<string,*>} JSON object
-         */
-        Peer.prototype.toJSON = function toJSON() {
-            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
-        };
-
-        return Peer;
-    })();
-
-    return CircuitRelay;
-})();
-
-module.exports = $root;
+`)

src/circuit/protocol/index.proto

@@ -1,42 +0,0 @@
-syntax = "proto2";
-
-message CircuitRelay {
-
-  enum Status {
-    SUCCESS                    = 100;
-    HOP_SRC_ADDR_TOO_LONG      = 220;
-    HOP_DST_ADDR_TOO_LONG      = 221;
-    HOP_SRC_MULTIADDR_INVALID  = 250;
-    HOP_DST_MULTIADDR_INVALID  = 251;
-    HOP_NO_CONN_TO_DST         = 260;
-    HOP_CANT_DIAL_DST          = 261;
-    HOP_CANT_OPEN_DST_STREAM   = 262;
-    HOP_CANT_SPEAK_RELAY       = 270;
-    HOP_CANT_RELAY_TO_SELF     = 280;
-    STOP_SRC_ADDR_TOO_LONG     = 320;
-    STOP_DST_ADDR_TOO_LONG     = 321;
-    STOP_SRC_MULTIADDR_INVALID = 350;
-    STOP_DST_MULTIADDR_INVALID = 351;
-    STOP_RELAY_REFUSED         = 390;
-    MALFORMED_MESSAGE          = 400;
-  }
-
-  enum Type { // RPC identifier, either HOP, STOP or STATUS
-    HOP = 1;
-    STOP = 2;
-    STATUS = 3;
-    CAN_HOP = 4;
-  }
-
-  message Peer {
-    required bytes id = 1;    // peer id
-    repeated bytes addrs = 2; // peer's known addresses
-  }
-
-  optional Type type = 1;     // Type of the message
-
-  optional Peer srcPeer = 2;  // srcPeer and dstPeer are used when Type is HOP or STATUS
-  optional Peer dstPeer = 3;
-
-  optional Status code = 4;   // Status code, used when Type is STATUS
-}

src/circuit/transport.js

@@ -5,12 +5,10 @@ const log = Object.assign(debug('libp2p:circuit'), {
   error: debug('libp2p:circuit:err')
 })
 
-const errCode = require('err-code')
 const mafmt = require('mafmt')
-const { Multiaddr } = require('multiaddr')
+const multiaddr = require('multiaddr')
 const PeerId = require('peer-id')
 const { CircuitRelay: CircuitPB } = require('./protocol')
-const { codes } = require('../errors')
 
 const toConnection = require('libp2p-utils/src/stream-to-ma-conn')
 
@@ -23,8 +21,10 @@ const StreamHandler = require('./circuit/stream-handler')
 const transportSymbol = Symbol.for('@libp2p/js-libp2p-circuit/circuit')
 
 /**
+ * @typedef {import('multiaddr')} Multiaddr
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
  * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
+ * @typedef {import('../types').CircuitRequest} CircuitRequest
  */
 
 class Circuit {
@@ -54,7 +54,7 @@ class Circuit {
    * @param {MuxedStream} props.stream
    */
   async _onProtocol ({ connection, stream }) {
-    /** @type {import('./circuit/stream-handler')} */
+    /** @type {import('./circuit/stream-handler')<CircuitRequest>} */
     const streamHandler = new StreamHandler({ stream })
     const request = await streamHandler.read()
 
@@ -96,10 +96,8 @@ class Circuit {
     }
 
     if (virtualConnection) {
-      // @ts-ignore dst peer will not be undefined
-      const remoteAddr = new Multiaddr(request.dstPeer.addrs[0])
-      // @ts-ignore src peer will not be undefined
-      const localAddr = new Multiaddr(request.srcPeer.addrs[0])
+      const remoteAddr = multiaddr(request.dstPeer.addrs[0])
+      const localAddr = multiaddr(request.srcPeer.addrs[0])
       const maConn = toConnection({
         stream: virtualConnection,
         remoteAddr,
@@ -125,19 +123,10 @@ class Circuit {
   async dial (ma, options) {
     // Check the multiaddr to see if it contains a relay and a destination peer
     const addrs = ma.toString().split('/p2p-circuit')
-    const relayAddr = new Multiaddr(addrs[0])
-    const destinationAddr = new Multiaddr(addrs[addrs.length - 1])
-    const relayId = relayAddr.getPeerId()
-    const destinationId = destinationAddr.getPeerId()
-
-    if (!relayId || !destinationId) {
-      const errMsg = 'Circuit relay dial failed as addresses did not have peer id'
-      log.error(errMsg)
-      throw errCode(new Error(errMsg), codes.ERR_RELAYED_DIAL)
-    }
-
-    const relayPeer = PeerId.createFromB58String(relayId)
-    const destinationPeer = PeerId.createFromB58String(destinationId)
+    const relayAddr = multiaddr(addrs[0])
+    const destinationAddr = multiaddr(addrs[addrs.length - 1])
+    const relayPeer = PeerId.createFromCID(relayAddr.getPeerId())
+    const destinationPeer = PeerId.createFromCID(destinationAddr.getPeerId())
 
     let disconnectOnFailure = false
     let relayConnection = this._connectionManager.get(relayPeer)
@@ -157,7 +146,7 @@ class Circuit {
           },
           dstPeer: {
             id: destinationPeer.toBytes(),
-            addrs: [new Multiaddr(destinationAddr).bytes]
+            addrs: [multiaddr(destinationAddr).bytes]
           }
         }
       })

src/circuit/utils.js

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

src/config.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const mergeOptions = require('merge-options')
-// @ts-ignore no types in multiaddr path
 const { dnsaddrResolver } = require('multiaddr/src/resolvers')
 
 const Constants = require('./constants')
@@ -11,18 +10,11 @@ const RelayConstants = require('./circuit/constants')
 const { publicAddressesFirst } = require('libp2p-utils/src/address-sort')
 const { FaultTolerance } = require('./transport-manager')
 
-/**
- * @typedef {import('multiaddr').Multiaddr} Multiaddr
- * @typedef {import('.').Libp2pOptions} Libp2pOptions
- * @typedef {import('.').constructorOptions} constructorOptions
- */
-
 const DefaultConfig = {
   addresses: {
     listen: [],
     announce: [],
-    noAnnounce: [],
-    announceFilter: (/** @type {Multiaddr[]} */ multiaddrs) => multiaddrs
+    noAnnounce: []
   },
   connectionManager: {
     minConnections: 25
@@ -57,7 +49,6 @@ const DefaultConfig = {
     }
   },
   config: {
-    protocolPrefix: 'ipfs',
     dht: {
       enabled: false,
       kBucketSize: 20,
@@ -104,15 +95,10 @@ const DefaultConfig = {
   }
 }
 
-/**
- * @param {Libp2pOptions} opts
- * @returns {DefaultConfig & Libp2pOptions & constructorOptions}
- */
 module.exports.validate = (opts) => {
-  /** @type {DefaultConfig & Libp2pOptions & constructorOptions} */
-  const resultingOptions = mergeOptions(DefaultConfig, opts)
+  opts = mergeOptions(DefaultConfig, opts)
 
-  if (resultingOptions.modules.transport.length < 1) throw new Error("'options.modules.transport' must contain at least 1 transport")
+  if (opts.modules.transport.length < 1) throw new Error("'options.modules.transport' must contain at least 1 transport")
 
-  return resultingOptions
+  return opts
 }

src/connection-manager/index.js

@@ -8,10 +8,11 @@ const log = Object.assign(debug('libp2p:connection-manager'), {
 const errcode = require('err-code')
 const mergeOptions = require('merge-options')
 const LatencyMonitor = require('./latency-monitor')
-// @ts-ignore retimer does not have types
 const retimer = require('retimer')
 
-const { EventEmitter } = require('events')
+/** @typedef {import('../types').EventEmitterFactory} Events */
+/** @type Events */
+const EventEmitter = require('events')
 
 const PeerId = require('peer-id')
 
@@ -97,11 +98,6 @@ class ConnectionManager extends EventEmitter {
     this._autoDialTimeout = null
     this._checkMetrics = this._checkMetrics.bind(this)
     this._autoDial = this._autoDial.bind(this)
-
-    this._latencyMonitor = new LatencyMonitor({
-      latencyCheckIntervalMs: this._options.pollInterval,
-      dataEmitIntervalMs: this._options.pollInterval
-    })
   }
 
   /**
@@ -122,7 +118,10 @@ class ConnectionManager extends EventEmitter {
     }
 
     // latency monitor
-    this._latencyMonitor.start()
+    this._latencyMonitor = new LatencyMonitor({
+      latencyCheckIntervalMs: this._options.pollInterval,
+      dataEmitIntervalMs: this._options.pollInterval
+    })
     this._onLatencyMeasure = this._onLatencyMeasure.bind(this)
     this._latencyMonitor.on('data', this._onLatencyMeasure)
 
@@ -140,9 +139,7 @@ class ConnectionManager extends EventEmitter {
   async stop () {
     this._autoDialTimeout && this._autoDialTimeout.clear()
     this._timer && this._timer.clear()
-
-    this._latencyMonitor.removeListener('data', this._onLatencyMeasure)
-    this._latencyMonitor.stop()
+    this._latencyMonitor && this._latencyMonitor.removeListener('data', this._onLatencyMeasure)
 
     this._started = false
     await this._close()
@@ -191,10 +188,8 @@ class ConnectionManager extends EventEmitter {
   _checkMetrics () {
     if (this._libp2p.metrics) {
       const movingAverages = this._libp2p.metrics.global.movingAverages
-      // @ts-ignore moving averages object types
       const received = movingAverages.dataReceived[this._options.movingAverageInterval].movingAverage()
       this._checkMaxLimit('maxReceivedData', received)
-      // @ts-ignore moving averages object types
       const sent = movingAverages.dataSent[this._options.movingAverageInterval].movingAverage()
       this._checkMaxLimit('maxSentData', sent)
       const total = received + sent
@@ -367,7 +362,7 @@ class ConnectionManager extends EventEmitter {
    */
   _maybeDisconnectOne () {
     if (this._options.minConnections < this.connections.size) {
-      const peerValues = Array.from(new Map([...this._peerValues.entries()].sort((a, b) => a[1] - b[1])))
+      const peerValues = Array.from(this._peerValues).sort(byPeerValue)
       log('%s: sorted peer values: %j', this._peerId, peerValues)
       const disconnectPeer = peerValues[0]
       if (disconnectPeer) {
@@ -386,3 +381,7 @@ class ConnectionManager extends EventEmitter {
 }
 
 module.exports = ConnectionManager
+
+function byPeerValue (peerValueEntryA, peerValueEntryB) {
+  return peerValueEntryA[1] - peerValueEntryB[1]
+}

src/connection-manager/latency-monitor.js

@@ -5,7 +5,9 @@
  * This code is based on `latency-monitor` (https://github.com/mlucool/latency-monitor) by `mlucool` (https://github.com/mlucool), available under Apache License 2.0 (https://github.com/mlucool/latency-monitor/blob/master/LICENSE)
  */
 
-const { EventEmitter } = require('events')
+/** @typedef {import('../types').EventEmitterFactory} Events */
+/** @type Events */
+const EventEmitter = require('events')
 const VisibilityChangeEmitter = require('./visibility-change-emitter')
 const debug = require('debug')('latency-monitor:LatencyMonitor')
 
@@ -57,8 +59,7 @@ class LatencyMonitor extends EventEmitter {
     that._latecyCheckMultiply = 2 * (that.latencyRandomPercentage / 100.0) * that.latencyCheckIntervalMs
     that._latecyCheckSubtract = that._latecyCheckMultiply / 2
 
-    that.dataEmitIntervalMs = (dataEmitIntervalMs === null || dataEmitIntervalMs === 0)
-      ? undefined
+    that.dataEmitIntervalMs = (dataEmitIntervalMs === null || dataEmitIntervalMs === 0) ? undefined
       : dataEmitIntervalMs || 5 * 1000 // 5s
     debug('latencyCheckIntervalMs: %s dataEmitIntervalMs: %s',
       that.latencyCheckIntervalMs, that.dataEmitIntervalMs)
@@ -69,55 +70,49 @@ class LatencyMonitor extends EventEmitter {
     }
 
     that.asyncTestFn = asyncTestFn // If there is no asyncFn, we measure latency
-  }
 
-  start () {
     // If process: use high resolution timer
     if (globalThis.process && globalThis.process.hrtime) { // eslint-disable-line no-undef
       debug('Using process.hrtime for timing')
-      this.now = globalThis.process.hrtime // eslint-disable-line no-undef
-      this.getDeltaMS = (startTime) => {
-        const hrtime = this.now(startTime)
+      that.now = globalThis.process.hrtime // eslint-disable-line no-undef
+      that.getDeltaMS = (startTime) => {
+        const hrtime = that.now(startTime)
         return (hrtime[0] * 1000) + (hrtime[1] / 1000000)
       }
       // Let's try for a timer that only monotonically increases
     } else if (typeof window !== 'undefined' && window.performance && window.performance.now) {
       debug('Using performance.now for timing')
-      this.now = window.performance.now.bind(window.performance)
-      this.getDeltaMS = (startTime) => Math.round(this.now() - startTime)
+      that.now = window.performance.now.bind(window.performance)
+      that.getDeltaMS = (startTime) => Math.round(that.now() - startTime)
     } else {
       debug('Using Date.now for timing')
-      this.now = Date.now
-      this.getDeltaMS = (startTime) => this.now() - startTime
+      that.now = Date.now
+      that.getDeltaMS = (startTime) => that.now() - startTime
     }
 
-    this._latencyData = this._initLatencyData()
+    that._latencyData = that._initLatencyData()
 
     // We check for isBrowser because of browsers set max rates of timeouts when a page is hidden,
     // so we fall back to another library
     // See: http://stackoverflow.com/questions/6032429/chrome-timeouts-interval-suspended-in-background-tabs
     if (isBrowser()) {
-      this._visibilityChangeEmitter = new VisibilityChangeEmitter()
+      that._visibilityChangeEmitter = new VisibilityChangeEmitter()
 
-      this._visibilityChangeEmitter.on('visibilityChange', (pageInFocus) => {
+      that._visibilityChangeEmitter.on('visibilityChange', (pageInFocus) => {
         if (pageInFocus) {
-          this._startTimers()
+          that._startTimers()
         } else {
-          this._emitSummary()
-          this._stopTimers()
+          that._emitSummary()
+          that._stopTimers()
         }
       })
     }
 
-    if (!this._visibilityChangeEmitter || this._visibilityChangeEmitter.isVisible()) {
-      this._startTimers()
+    if (!that._visibilityChangeEmitter || that._visibilityChangeEmitter.isVisible()) {
+      that._startTimers()
     }
   }
 
-  stop () {
-    this._stopTimers()
-  }
-
   /**
    * Start internal timers
    *
@@ -179,8 +174,7 @@ class LatencyMonitor extends EventEmitter {
       events: this._latencyData.events,
       minMs: this._latencyData.minMs,
       maxMs: this._latencyData.maxMs,
-      avgMs: this._latencyData.events
-        ? this._latencyData.totalMs / this._latencyData.events
+      avgMs: this._latencyData.events ? this._latencyData.totalMs / this._latencyData.events
         : Number.POSITIVE_INFINITY,
       lengthMs: this.getDeltaMS(this._latencyData.startTime)
     }

src/connection-manager/visibility-change-emitter.js

@@ -6,7 +6,9 @@
  */
 'use strict'
 
-const { EventEmitter } = require('events')
+/** @typedef {import('../types').EventEmitterFactory} Events */
+/** @type Events */
+const EventEmitter = require('events')
 
 const debug = require('debug')('latency-monitor:VisibilityChangeEmitter')
 

src/constants.js

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

src/content-routing/index.js

@@ -14,9 +14,8 @@ const { pipe } = require('it-pipe')
 
 /**
  * @typedef {import('peer-id')} PeerId
- * @typedef {import('multiaddr').Multiaddr} Multiaddr
- * @typedef {import('multiformats/cid').CID} CID
- * @typedef {import('libp2p-interfaces/src/content-routing/types').ContentRouting} ContentRoutingModule
+ * @typedef {import('multiaddr')} Multiaddr
+ * @typedef {import('cids')} CID
  */
 
 /**
@@ -32,7 +31,6 @@ class ContentRouting {
    */
   constructor (libp2p) {
     this.libp2p = libp2p
-    /** @type {ContentRoutingModule[]} */
     this.routers = libp2p._modules.contentRouting || []
     this.dht = libp2p._dht
 

src/content-routing/utils.js

@@ -7,7 +7,7 @@ const take = require('it-take')
 
 /**
  * @typedef {import('peer-id')} PeerId
- * @typedef {import('multiaddr').Multiaddr} Multiaddr
+ * @typedef {import('multiaddr')} Multiaddr
  */
 
 /**

src/dialer/dial-request.js

@@ -3,14 +3,13 @@
 const errCode = require('err-code')
 const AbortController = require('abort-controller').default
 const { anySignal } = require('any-signal')
-// @ts-ignore p-fifo does not export types
 const FIFO = require('p-fifo')
 const pAny = require('p-any')
 
 /**
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
  * @typedef {import('./')} Dialer
- * @typedef {import('multiaddr').Multiaddr} Multiaddr
+ * @typedef {import('multiaddr')} Multiaddr
  */
 
 /**

src/dialer/index.js

@@ -5,10 +5,8 @@ const log = Object.assign(debug('libp2p:dialer'), {
   error: debug('libp2p:dialer:err')
 })
 const errCode = require('err-code')
-const { Multiaddr } = require('multiaddr')
-// @ts-ignore timeout-abourt-controles does not export types
+const multiaddr = require('multiaddr')
 const TimeoutController = require('timeout-abort-controller')
-const { AbortError } = require('abortable-iterator')
 const { anySignal } = require('any-signal')
 
 const DialRequest = require('./dial-request')
@@ -19,12 +17,12 @@ const { codes } = require('../errors')
 const {
   DIAL_TIMEOUT,
   MAX_PARALLEL_DIALS,
-  MAX_PER_PEER_DIALS,
-  MAX_ADDRS_TO_DIAL
+  MAX_PER_PEER_DIALS
 } = require('../constants')
 
 /**
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
+ * @typedef {import('multiaddr')} Multiaddr
  * @typedef {import('peer-id')} PeerId
  * @typedef {import('../peer-store')} PeerStore
  * @typedef {import('../peer-store/address-book').Address} Address
@@ -40,10 +38,9 @@ const {
  *
  * @typedef {Object} DialerOptions
  * @property {(addresses: Address[]) => Address[]} [options.addressSorter = publicAddressesFirst] - Sort the known addresses of a peer before trying to dial.
- * @property {number} [maxParallelDials = MAX_PARALLEL_DIALS] - Number of max concurrent dials.
- * @property {number} [maxAddrsToDial = MAX_ADDRS_TO_DIAL] - Number of max addresses to dial for a given peer.
- * @property {number} [maxDialsPerPeer = MAX_PER_PEER_DIALS] - Number of max concurrent dials per peer.
- * @property {number} [dialTimeout = DIAL_TIMEOUT] - How long a dial attempt is allowed to take.
+ * @property {number} [concurrency = MAX_PARALLEL_DIALS] - Number of max concurrent dials.
+ * @property {number} [perPeerLimit = MAX_PER_PEER_DIALS] - Number of max concurrent dials per peer.
+ * @property {number} [timeout = DIAL_TIMEOUT] - How long a dial attempt is allowed to take.
  * @property {Record<string, Resolver>} [resolvers = {}] - multiaddr resolvers to use when dialing
  *
  * @typedef DialTarget
@@ -53,7 +50,7 @@ const {
  * @typedef PendingDial
  * @property {DialRequest} dialRequest
  * @property {TimeoutController} controller
- * @property {Promise<Connection>} promise
+ * @property {Promise} promise
  * @property {function():void} destroy
  */
 
@@ -66,25 +63,22 @@ class Dialer {
     transportManager,
     peerStore,
     addressSorter = publicAddressesFirst,
-    maxParallelDials = MAX_PARALLEL_DIALS,
-    maxAddrsToDial = MAX_ADDRS_TO_DIAL,
-    dialTimeout = DIAL_TIMEOUT,
-    maxDialsPerPeer = MAX_PER_PEER_DIALS,
+    concurrency = MAX_PARALLEL_DIALS,
+    timeout = DIAL_TIMEOUT,
+    perPeerLimit = MAX_PER_PEER_DIALS,
     resolvers = {}
   }) {
     this.transportManager = transportManager
     this.peerStore = peerStore
     this.addressSorter = addressSorter
-    this.maxParallelDials = maxParallelDials
-    this.maxAddrsToDial = maxAddrsToDial
-    this.timeout = dialTimeout
-    this.maxDialsPerPeer = maxDialsPerPeer
-    this.tokens = [...new Array(maxParallelDials)].map((_, index) => index)
+    this.concurrency = concurrency
+    this.timeout = timeout
+    this.perPeerLimit = perPeerLimit
+    this.tokens = [...new Array(concurrency)].map((_, index) => index)
     this._pendingDials = new Map()
-    this._pendingDialTargets = new Map()
 
     for (const [key, value] of Object.entries(resolvers)) {
-      Multiaddr.resolvers.set(key, value)
+      multiaddr.resolvers.set(key, value)
     }
   }
 
@@ -100,11 +94,6 @@ class Dialer {
       }
     }
     this._pendingDials.clear()
-
-    for (const pendingTarget of this._pendingDialTargets.values()) {
-      pendingTarget.reject(new AbortError('Dialer was destroyed'))
-    }
-    this._pendingDialTargets.clear()
   }
 
   /**
@@ -118,10 +107,10 @@ class Dialer {
    * @returns {Promise<Connection>}
    */
   async connectToPeer (peer, options = {}) {
-    const dialTarget = await this._createCancellableDialTarget(peer)
+    const dialTarget = await this._createDialTarget(peer)
 
     if (!dialTarget.addrs.length) {
-      throw errCode(new Error('The dial request has no valid addresses'), codes.ERR_NO_VALID_ADDRESSES)
+      throw errCode(new Error('The dial request has no addresses'), codes.ERR_NO_VALID_ADDRESSES)
     }
     const pendingDial = this._pendingDials.get(dialTarget.id) || this._createPendingDial(dialTarget, options)
 
@@ -141,36 +130,10 @@ class Dialer {
     }
   }
 
-  /**
-   * Connects to a given `peer` by dialing all of its known addresses.
-   * The dial to the first address that is successfully able to upgrade a connection
-   * will be used.
-   *
-   * @param {PeerId|Multiaddr|string} peer - The peer to dial
-   * @returns {Promise<DialTarget>}
-   */
-  async _createCancellableDialTarget (peer) {
-    // Make dial target promise cancellable
-    const id = `${(parseInt(String(Math.random() * 1e9), 10)).toString() + Date.now()}`
-    const cancellablePromise = new Promise((resolve, reject) => {
-      this._pendingDialTargets.set(id, { resolve, reject })
-    })
-
-    const dialTarget = await Promise.race([
-      this._createDialTarget(peer),
-      cancellablePromise
-    ])
-
-    this._pendingDialTargets.delete(id)
-
-    return dialTarget
-  }
-
   /**
    * Creates a DialTarget. The DialTarget is used to create and track
    * the DialRequest to a given peer.
    * If a multiaddr is received it should be the first address attempted.
-   * Multiaddrs not supported by the available transports will be filtered out.
    *
    * @private
    * @param {PeerId|Multiaddr|string} peer - A PeerId or Multiaddr
@@ -187,29 +150,20 @@ class Dialer {
 
     // If received a multiaddr to dial, it should be the first to use
     // But, if we know other multiaddrs for the peer, we should try them too.
-    if (Multiaddr.isMultiaddr(peer)) {
+    if (multiaddr.isMultiaddr(peer)) {
       knownAddrs = knownAddrs.filter((addr) => !peer.equals(addr))
       knownAddrs.unshift(peer)
     }
 
-    /** @type {Multiaddr[]} */
     const addrs = []
     for (const a of knownAddrs) {
       const resolvedAddrs = await this._resolve(a)
       resolvedAddrs.forEach(ra => addrs.push(ra))
     }
 
-    // Multiaddrs not supported by the available transports will be filtered out.
-    const supportedAddrs = addrs.filter(a => this.transportManager.transportForMultiaddr(a))
-
-    if (supportedAddrs.length > this.maxAddrsToDial) {
-      this.peerStore.delete(id)
-      throw errCode(new Error('dial with more addresses than allowed'), codes.ERR_TOO_MANY_ADDRESSES)
-    }
-
     return {
       id: id.toB58String(),
-      addrs: supportedAddrs
+      addrs
     }
   }
 
@@ -223,10 +177,6 @@ class Dialer {
    * @returns {PendingDial}
    */
   _createPendingDial (dialTarget, options = {}) {
-    /**
-     * @param {Multiaddr} addr
-     * @param {{ signal: { aborted: any; }; }} options
-     */
     const dialAction = (addr, options) => {
       if (options.signal.aborted) throw errCode(new Error('already aborted'), codes.ERR_ALREADY_ABORTED)
       return this.transportManager.dial(addr, options)
@@ -257,19 +207,13 @@ class Dialer {
     return pendingDial
   }
 
-  /**
-   * @param {number} num
-   */
   getTokens (num) {
-    const total = Math.min(num, this.maxDialsPerPeer, this.tokens.length)
+    const total = Math.min(num, this.perPeerLimit, this.tokens.length)
     const tokens = this.tokens.splice(0, total)
     log('%d tokens request, returning %d, %d remaining', num, total, this.tokens.length)
     return tokens
   }
 
-  /**
-   * @param {number} token
-   */
   releaseToken (token) {
     // Guard against duplicate releases
     if (this.tokens.indexOf(token) > -1) return
@@ -315,7 +259,7 @@ class Dialer {
    */
   async _resolveRecord (ma) {
     try {
-      ma = new Multiaddr(ma.toString()) // Use current multiaddr module
+      ma = multiaddr(ma.toString()) // Use current multiaddr module
       const multiaddrs = await ma.resolve()
       return multiaddrs
     } catch (_) {