chore: release 0.36.0 (#1127)

## [0.36.0](https://www.github.com/libp2p/js-libp2p/compare/v0.35.8...v0.36.0) (2022-01-25)

### ⚠ BREAKING CHANGES

* abort-controller dep is gone from dependency tree
* `libp2p.handle`, `libp2p.registrar.register` and the peerstore methods have become async

### Features

* add fetch protocol ([#1036](https://www.github.com/libp2p/js-libp2p/issues/1036)) ([d8ceb0b](d8ceb0bc66))
* async peerstore backed by datastores ([#1058](https://www.github.com/libp2p/js-libp2p/issues/1058)) ([978eb36](978eb3676f))
* connection gater ([#1142](https://www.github.com/libp2p/js-libp2p/issues/1142)) ([ff32eba](ff32eba6a0))


### Bug Fixes

* cache build artefacts ([#1091](https://www.github.com/libp2p/js-libp2p/issues/1091)) ([5043cd5](5043cd5643))
* catch errors during identify ([#1138](https://www.github.com/libp2p/js-libp2p/issues/1138)) ([12f1bb0](12f1bb0aee))
* import uint8arrays package in example ([#1083](https://www.github.com/libp2p/js-libp2p/issues/1083)) ([c3700f5](c3700f55d5))
* make tests more reliable ([#1139](https://www.github.com/libp2p/js-libp2p/issues/1139)) ([b7e8706](b7e87066a6))
* prevent auto-dialer from dialing self ([#1104](https://www.github.com/libp2p/js-libp2p/issues/1104)) ([9b22c6e](9b22c6e2f9))
* remove abort-controller dep ([#1095](https://www.github.com/libp2p/js-libp2p/issues/1095)) ([0a4dc54](0a4dc54d08))
* try all peer addresses when dialing a relay ([#1140](https://www.github.com/libp2p/js-libp2p/issues/1140)) ([63aa480](63aa480800))
* update any-signal and timeout-abort-controller ([#1128](https://www.github.com/libp2p/js-libp2p/issues/1128)) ([e0354b4](e0354b4c6b))
* update multistream select ([#1136](https://www.github.com/libp2p/js-libp2p/issues/1136)) ([00e4959](00e49592a3))
* update node-forge ([#1133](https://www.github.com/libp2p/js-libp2p/issues/1133)) ([a4bba35](a4bba35948))
---

This PR was generated with [Release Please](https://github.com/googleapis/release-please). See [documentation](https://github.com/googleapis/release-please#release-please).

Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>

.aegir.js

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

.github/dependabot.yml

@@ -0,0 +1,8 @@
+version: 2
+updates:
+- package-ecosystem: npm
+  directory: "/"
+  schedule:
+    interval: daily
+    time: "11:00"
+  open-pull-requests-limit: 10

.github/workflows/examples.yml

@@ -8,95 +8,59 @@ on:
       - '**'
 
 jobs:
-  check:
+
+  build:
     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
+    - uses: actions/setup-node@v2
+      with:
+        node-version: lts/*
+    - uses: ipfs/aegir/actions/cache-node-modules@master
+      with:
+        directories: |
+          ./examples/node_modules
+          ~/.cache
+        build: |
+          cd examples
+          npm i
+          npx playwright install
+        cache_name: cache-examples
+
+  test-example:
+    needs: build
     runs-on: ubuntu-latest
+    strategy:
+      matrix:
+        example: [
+          chat,
+          connection-encryption,
+          discovery-mechanisms,
+          echo,
+          libp2p-in-the-browser,
+          peer-and-content-routing,
+          pnet,
+          protocol-and-stream-muxing,
+          pubsub,
+          transports,
+          webrtc-direct
+        ]
+      fail-fast: true
     steps:
       - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && yarn && 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 && yarn && 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 && yarn && 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 && yarn && 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 && yarn && 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 && 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: npm install
-      - 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: npm install
-      - 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: npm install
-      - 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: npm install
-      - run: cd examples && yarn && npm run test -- pubsub
-  test-transports-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && yarn && npm run test -- transports
-  test-webrtc-direct-example:
-    needs: check
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - run: npm install
-      - run: cd examples && yarn && npm run test -- webrtc-direct
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+        with:
+          directories: |
+            ./examples/node_modules
+            ~/.cache
+          build: |
+            cd examples
+            npm i
+            npx playwright install
+          cache_name: cache-examples
+      - run: |
+          cd examples
+          npm run test -- ${{ matrix.example }}

.github/workflows/main.yml

@@ -8,63 +8,163 @@ on:
       - '**'
 
 jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest]
+        node: [16]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: 16
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+
   check:
+    needs: build
     runs-on: ubuntu-latest
     steps:
     - uses: actions/checkout@v2
     - uses: actions/setup-node@v2
       with:
-        node-version: 14
-    - run: npm install
+        node-version: lts/*
+    - uses: ipfs/aegir/actions/cache-node-modules@master
     - run: npx aegir lint
-    - uses: gozala/typescript-error-reporter-action@v1.0.8
-    - run: npx aegir build
     - run: npx aegir dep-check
     - uses: ipfs/aegir/actions/bundle-size@master
       name: size
       with:
         github_token: ${{ secrets.GITHUB_TOKEN }}
+
   test-node:
-    needs: check
+    needs: build
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
         os: [windows-latest, ubuntu-latest, macos-latest]
-        node: [14, 16]
+        node: [16]
       fail-fast: true
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v2
         with:
           node-version: ${{ matrix.node }}
-      - run: npm install
-      - run: npx aegir test -t node --cov --bail
-      - uses: codecov/codecov-action@v1
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:node -- --cov --bail
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          directory: ./.nyc_output
+          flags: node
+
   test-chrome:
-    needs: check
+    needs: build
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: npm install
-      - run: npx aegir test -t browser -t webworker --bail
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:browser -- -t browser --cov --bail
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          directory: ./.nyc_output
+          flags: chrome
+
+  test-chrome-webworker:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:browser -- -t webworker --bail
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          directory: ./.nyc_output
+          flags: chrome-webworker
+
   test-firefox:
-    needs: check
+    needs: build
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: npm install
-      - run: npx aegir test -t browser -t webworker --bail -- --browser firefox
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:browser -- -t browser --bail -- --browser firefox
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          directory: ./.nyc_output
+          flags: firefox
+
+  test-firefox-webworker:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:browser -- -t webworker --bail -- --browser firefox
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          directory: ./.nyc_output
+          flags: firefox-webworker
+
   test-ts:
-    needs: check
+    needs: build
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
-      - run: npm install
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
       - run: npm run test:ts
+
   test-interop:
-    needs: check
+    needs: build
     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
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:interop -- --bail -- --exit
+
+  release:
+    runs-on: ubuntu-latest
+    needs: [test-node, test-chrome, test-chrome-webworker, test-firefox, test-firefox-webworker, test-ts, test-interop]
+    if: github.event_name == 'push' && github.ref == 'refs/heads/master'
+    steps:
+      - uses: GoogleCloudPlatform/release-please-action@v2
+        id: release
+        with:
+          token: ${{ secrets.GITHUB_TOKEN }}
+          release-type: node
+          bump-minor-pre-major: true
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+          registry-url: 'https://registry.npmjs.org'
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - if: ${{ steps.release.outputs.release_created }}
+        name: Run release version
+        run: npm publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+      - if: ${{ !steps.release.outputs.release_created }}
+        name: Run release rc
+        run: |
+            npm version `node -p -e "require('./package.json').version"`-`git rev-parse --short HEAD` --no-git-tag-version
+            npm publish --tag next
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

CHANGELOG.md

@@ -1,3 +1,207 @@
+## [0.35.8](https://github.com/libp2p/js-libp2p/compare/v0.35.7...v0.35.8) (2021-12-29)
+
+
+### Bug Fixes
+
+* do not wait for autodial start ([#1089](https://github.com/libp2p/js-libp2p/issues/1089)) ([79b3cfc](https://github.com/libp2p/js-libp2p/commit/79b3cfc6ad02ecc76fe23a3c3ff2d0b32a0ae4a8))
+* increase listeners on any-signal ([#1084](https://github.com/libp2p/js-libp2p/issues/1084)) ([f18fc80](https://github.com/libp2p/js-libp2p/commit/f18fc80b70bf7b6b26fffa70b0a8d0502a6c4801))
+* look for final peer event instead of peer response ([#1092](https://github.com/libp2p/js-libp2p/issues/1092)) ([d2b7ec0](https://github.com/libp2p/js-libp2p/commit/d2b7ec0f6be0ee80f2c963279a8ec2385059a889))
+* record tracked map clears ([#1085](https://github.com/libp2p/js-libp2p/issues/1085)) ([b4b4324](https://github.com/libp2p/js-libp2p/commit/b4b432406ebc08ef2fc3a1922c64cde7c9060cae))
+
+
+
+## [0.36.0](https://www.github.com/libp2p/js-libp2p/compare/v0.35.8...v0.36.0) (2022-01-25)
+
+
+### ⚠ BREAKING CHANGES
+
+* abort-controller dep is gone from dependency tree
+* `libp2p.handle`, `libp2p.registrar.register` and the peerstore methods have become async
+
+### Features
+
+* add fetch protocol ([#1036](https://www.github.com/libp2p/js-libp2p/issues/1036)) ([d8ceb0b](https://www.github.com/libp2p/js-libp2p/commit/d8ceb0bc66fe225d1335d3f05b9a3a30983c2a57))
+* async peerstore backed by datastores ([#1058](https://www.github.com/libp2p/js-libp2p/issues/1058)) ([978eb36](https://www.github.com/libp2p/js-libp2p/commit/978eb3676fad5d5d50ddb28d1a7868f448cbb20b))
+* connection gater ([#1142](https://www.github.com/libp2p/js-libp2p/issues/1142)) ([ff32eba](https://www.github.com/libp2p/js-libp2p/commit/ff32eba6a0fa222af1a7a46775d5e0346ad6ebdf))
+
+
+### Bug Fixes
+
+* cache build artefacts ([#1091](https://www.github.com/libp2p/js-libp2p/issues/1091)) ([5043cd5](https://www.github.com/libp2p/js-libp2p/commit/5043cd56435a264e83db4fb8388d33e9a0442fff))
+* catch errors during identify ([#1138](https://www.github.com/libp2p/js-libp2p/issues/1138)) ([12f1bb0](https://www.github.com/libp2p/js-libp2p/commit/12f1bb0aeec4b639bd2af05807215f3b4284e379))
+* import uint8arrays package in example ([#1083](https://www.github.com/libp2p/js-libp2p/issues/1083)) ([c3700f5](https://www.github.com/libp2p/js-libp2p/commit/c3700f55d5a0b62182d683ca37258887b24065b9))
+* make tests more reliable ([#1139](https://www.github.com/libp2p/js-libp2p/issues/1139)) ([b7e8706](https://www.github.com/libp2p/js-libp2p/commit/b7e87066a69970f1adca4ba552c7fdf624916a7e))
+* prevent auto-dialer from dialing self ([#1104](https://www.github.com/libp2p/js-libp2p/issues/1104)) ([9b22c6e](https://www.github.com/libp2p/js-libp2p/commit/9b22c6e2f987a20c6639cd07f31fe9c824e24923))
+* remove abort-controller dep ([#1095](https://www.github.com/libp2p/js-libp2p/issues/1095)) ([0a4dc54](https://www.github.com/libp2p/js-libp2p/commit/0a4dc54d084c901df47cce1788bd5922090ee037))
+* try all peer addresses when dialing a relay ([#1140](https://www.github.com/libp2p/js-libp2p/issues/1140)) ([63aa480](https://www.github.com/libp2p/js-libp2p/commit/63aa480800974515f44d3b7e013da9c8ccaae8ad))
+* update any-signal and timeout-abort-controller ([#1128](https://www.github.com/libp2p/js-libp2p/issues/1128)) ([e0354b4](https://www.github.com/libp2p/js-libp2p/commit/e0354b4c6b95bb90656b868849182eb3efddf096))
+* update multistream select ([#1136](https://www.github.com/libp2p/js-libp2p/issues/1136)) ([00e4959](https://www.github.com/libp2p/js-libp2p/commit/00e49592a356e39b20c889d5f40b9bb37d4bf293))
+* update node-forge ([#1133](https://www.github.com/libp2p/js-libp2p/issues/1133)) ([a4bba35](https://www.github.com/libp2p/js-libp2p/commit/a4bba35948e1cd8dbe5147f2c8d6385b1fbb6fae))
+
+## [0.35.7](https://github.com/libp2p/js-libp2p/compare/v0.35.2...v0.35.7) (2021-12-24)
+
+
+### Bug Fixes
+
+* add tracked map ([#1069](https://github.com/libp2p/js-libp2p/issues/1069)) ([b425fa1](https://github.com/libp2p/js-libp2p/commit/b425fa12304def2a007d43a0aa445c28b766ed02))
+* clean up pending dial targets ([#1059](https://github.com/libp2p/js-libp2p/issues/1059)) ([bdc9f16](https://github.com/libp2p/js-libp2p/commit/bdc9f16d0cbe56ccf26822f11068e7795bcef046))
+* fix uncaught promise rejection when finding peers ([#1044](https://github.com/libp2p/js-libp2p/issues/1044)) ([3b683e7](https://github.com/libp2p/js-libp2p/commit/3b683e715686163e229b7b5c3a892327dfd4fc63))
+* increase the maxlisteners for timeout controllers ([#1065](https://github.com/libp2p/js-libp2p/issues/1065)) ([09a0f94](https://github.com/libp2p/js-libp2p/commit/09a0f940df7fdb4ece34604e85693709df5c213e))
+* main ci ([#1079](https://github.com/libp2p/js-libp2p/issues/1079)) ([d1c48dc](https://github.com/libp2p/js-libp2p/commit/d1c48dcbeded828f2dd3044cc9aed3f17f02846d))
+* make error codes consistent ([#1054](https://github.com/libp2p/js-libp2p/issues/1054)) ([b25e0fe](https://github.com/libp2p/js-libp2p/commit/b25e0fe5312db58a06c39500ae84c50fed3a93bd))
+* type definitions for big dialrequest and persistent peerstore ([#1078](https://github.com/libp2p/js-libp2p/issues/1078)) ([cb0d7d6](https://github.com/libp2p/js-libp2p/commit/cb0d7d6c99d179498f04e76df76e70e4f7d41c4c))
+
+
+### Features
+
+* allow per-component metrics to be collected ([#1061](https://github.com/libp2p/js-libp2p/issues/1061)) ([2f0b311](https://github.com/libp2p/js-libp2p/commit/2f0b311df7127aa44512c2008142d4ca30268986)), closes [#1060](https://github.com/libp2p/js-libp2p/issues/1060)
+
+
+
+## [0.35.6](https://github.com/libp2p/js-libp2p/compare/v0.35.5...v0.35.6) (2021-12-18)
+
+
+### Bug Fixes
+
+* increase the maxlisteners for timeout controllers ([#1065](https://github.com/libp2p/js-libp2p/issues/1065)) ([09a0f94](https://github.com/libp2p/js-libp2p/commit/09a0f940df7fdb4ece34604e85693709df5c213e))
+
+
+
+## [0.35.5](https://github.com/libp2p/js-libp2p/compare/v0.35.4...v0.35.5) (2021-12-15)
+
+
+
+## [0.35.4](https://github.com/libp2p/js-libp2p/compare/v0.35.3...v0.35.4) (2021-12-15)
+
+
+### Features
+
+* allow per-component metrics to be collected ([#1061](https://github.com/libp2p/js-libp2p/issues/1061)) ([2f0b311](https://github.com/libp2p/js-libp2p/commit/2f0b311df7127aa44512c2008142d4ca30268986)), closes [#1060](https://github.com/libp2p/js-libp2p/issues/1060)
+
+
+
+## [0.35.3](https://github.com/libp2p/js-libp2p/compare/v0.35.2...v0.35.3) (2021-12-13)
+
+
+### Bug Fixes
+
+* clean up pending dial targets ([#1059](https://github.com/libp2p/js-libp2p/issues/1059)) ([bdc9f16](https://github.com/libp2p/js-libp2p/commit/bdc9f16d0cbe56ccf26822f11068e7795bcef046))
+* fix uncaught promise rejection when finding peers ([#1044](https://github.com/libp2p/js-libp2p/issues/1044)) ([3b683e7](https://github.com/libp2p/js-libp2p/commit/3b683e715686163e229b7b5c3a892327dfd4fc63))
+* make error codes consistent ([#1054](https://github.com/libp2p/js-libp2p/issues/1054)) ([b25e0fe](https://github.com/libp2p/js-libp2p/commit/b25e0fe5312db58a06c39500ae84c50fed3a93bd))
+
+
+
+## [0.35.2](https://github.com/libp2p/js-libp2p/compare/v0.33.0...v0.35.2) (2021-12-06)
+
+
+### Bug Fixes
+
+* do not let closest peers run forever ([#1047](https://github.com/libp2p/js-libp2p/issues/1047)) ([91c2ec9](https://github.com/libp2p/js-libp2p/commit/91c2ec9856a3e972b7b2c9c4d9a4eda1d431c7ef))
+* increase maxlisteners on event target ([#1050](https://github.com/libp2p/js-libp2p/issues/1050)) ([b70fb43](https://github.com/libp2p/js-libp2p/commit/b70fb43427b47df079b55929ec8956f69cbda966)), closes [#900](https://github.com/libp2p/js-libp2p/issues/900)
+* private ip ts compile has no call signatures ([#1020](https://github.com/libp2p/js-libp2p/issues/1020)) ([77d7cb8](https://github.com/libp2p/js-libp2p/commit/77d7cb8f0815f2cdd3bfdfa8b641a7a186fe9520))
+* stop dht before connection manager ([#1041](https://github.com/libp2p/js-libp2p/issues/1041)) ([3a9d5f6](https://github.com/libp2p/js-libp2p/commit/3a9d5f64d96719ebb4d3b083c4f5832db4fa0816)), closes [#1039](https://github.com/libp2p/js-libp2p/issues/1039)
+
+
+### chore
+
+* update peer id and libp2p crypto ([#1042](https://github.com/libp2p/js-libp2p/issues/1042)) ([9cbf36f](https://github.com/libp2p/js-libp2p/commit/9cbf36fcb54099e6fed35ceccc4a2376f0926c1f))
+
+
+### Features
+
+* update dht ([#1009](https://github.com/libp2p/js-libp2p/issues/1009)) ([2f598eb](https://github.com/libp2p/js-libp2p/commit/2f598eba09cff4301474af08196158065e3602d8))
+
+
+### BREAKING CHANGES
+
+* requires node 15+
+* libp2p-kad-dht has a new event-based API which is exposed as `_dht`
+
+
+
+## [0.35.1](https://github.com/libp2p/js-libp2p/compare/v0.35.0...v0.35.1) (2021-12-03)
+
+
+### Bug Fixes
+
+* do not let closest peers run forever ([#1047](https://github.com/libp2p/js-libp2p/issues/1047)) ([91c2ec9](https://github.com/libp2p/js-libp2p/commit/91c2ec9856a3e972b7b2c9c4d9a4eda1d431c7ef))
+
+
+
+# [0.35.0](https://github.com/libp2p/js-libp2p/compare/v0.34.0...v0.35.0) (2021-12-02)
+
+
+### Bug Fixes
+
+* stop dht before connection manager ([#1041](https://github.com/libp2p/js-libp2p/issues/1041)) ([3a9d5f6](https://github.com/libp2p/js-libp2p/commit/3a9d5f64d96719ebb4d3b083c4f5832db4fa0816)), closes [#1039](https://github.com/libp2p/js-libp2p/issues/1039)
+
+
+### chore
+
+* update peer id and libp2p crypto ([#1042](https://github.com/libp2p/js-libp2p/issues/1042)) ([9cbf36f](https://github.com/libp2p/js-libp2p/commit/9cbf36fcb54099e6fed35ceccc4a2376f0926c1f))
+
+
+### BREAKING CHANGES
+
+* requires node 15+
+
+
+
+# [0.34.0](https://github.com/libp2p/js-libp2p/compare/v0.33.0...v0.34.0) (2021-11-25)
+
+
+### Bug Fixes
+
+* private ip ts compile has no call signatures ([#1020](https://github.com/libp2p/js-libp2p/issues/1020)) ([77d7cb8](https://github.com/libp2p/js-libp2p/commit/77d7cb8f0815f2cdd3bfdfa8b641a7a186fe9520))
+
+
+### Features
+
+* update dht ([#1009](https://github.com/libp2p/js-libp2p/issues/1009)) ([2f598eb](https://github.com/libp2p/js-libp2p/commit/2f598eba09cff4301474af08196158065e3602d8))
+
+
+### BREAKING CHANGES
+
+* libp2p-kad-dht has a new event-based API which is exposed as `_dht`
+
+
+
+# [0.33.0](https://github.com/libp2p/js-libp2p/compare/v0.32.5...v0.33.0) (2021-09-24)
+
+
+### chore
+
+* update datastore ([#990](https://github.com/libp2p/js-libp2p/issues/990)) ([83734ef](https://github.com/libp2p/js-libp2p/commit/83734ef52061ad61ddb5ca49aae27e3a8b937058))
+
+
+### BREAKING CHANGES
+
+* datastore implementations provided to libp2p must be compliant with interface-datastore@6.0.0
+
+
+
+## [0.32.5](https://github.com/libp2p/js-libp2p/compare/v0.32.4...v0.32.5) (2021-09-21)
+
+
+### Bug Fixes
+
+* move abortable-iterator to dependencies ([#992](https://github.com/libp2p/js-libp2p/issues/992)) ([122c89d](https://github.com/libp2p/js-libp2p/commit/122c89dd0df55a59edaae078e3dc7c31b5603715)), closes [#986](https://github.com/libp2p/js-libp2p/issues/986)
+
+
+
+## [0.32.4](https://github.com/libp2p/js-libp2p/compare/v0.32.3...v0.32.4) (2021-08-20)
+
+
+
+## [0.32.3](https://github.com/libp2p/js-libp2p/compare/v0.32.2...v0.32.3) (2021-08-16)
+
+
+### Bug Fixes
+
+* uint8arrays is a dep ([#964](https://github.com/libp2p/js-libp2p/issues/964)) ([ba2b4d4](https://github.com/libp2p/js-libp2p/commit/ba2b4d4b28f1d9940b457de344aed44537f9eabd))
+
+
+
 ## [0.32.2](https://github.com/libp2p/js-libp2p/compare/v0.32.1...v0.32.2) (2021-08-13)
 
 
@@ -1585,6 +1789,3 @@ for subscribe to see how it should be used.
 
 <a name="0.5.5"></a>
 ## [0.5.5](https://github.com/libp2p/js-libp2p/compare/v0.5.4...v0.5.5) (2017-03-21)
-
-
-

README.md

@@ -23,8 +23,8 @@
   <a href="https://david-dm.org/libp2p/js-libp2p"><img src="https://david-dm.org/libp2p/js-libp2p.svg?style=flat-square" /></a>
   <a href="https://github.com/feross/standard"><img src="https://img.shields.io/badge/code%20style-standard-brightgreen.svg?style=flat-square"></a>
   <a href="https://github.com/RichardLitt/standard-readme"><img src="https://img.shields.io/badge/standard--readme-OK-green.svg?style=flat-square" /></a>
-  <a href=""><img src="https://img.shields.io/badge/npm-%3E%3D6.0.0-orange.svg?style=flat-square" /></a>
-  <a href=""><img src="https://img.shields.io/badge/Node.js-%3E%3D12.0.0-orange.svg?style=flat-square" /></a>
+  <a href=""><img src="https://img.shields.io/badge/npm-%3E%3D7.0.0-orange.svg?style=flat-square" /></a>
+  <a href=""><img src="https://img.shields.io/badge/Node.js-%3E%3D15.0.0-orange.svg?style=flat-square" /></a>
   <br>
 </p>
 
@@ -163,9 +163,9 @@ List of packages currently in existence for libp2p
 | [`libp2p-kad-dht`](//github.com/libp2p/js-libp2p-kad-dht) | [![npm](https://img.shields.io/npm/v/libp2p-kad-dht.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-kad-dht/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-kad-dht.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-kad-dht) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-kad-dht/master)](https://travis-ci.com/libp2p/js-libp2p-kad-dht) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-kad-dht/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-kad-dht) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
 | **utilities** |
 | [`libp2p-crypto`](//github.com/libp2p/js-libp2p-crypto) | [![npm](https://img.shields.io/npm/v/libp2p-crypto.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-crypto/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-crypto.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-crypto) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-crypto/master)](https://travis-ci.com/libp2p/js-libp2p-crypto) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-crypto/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-crypto) | [Jacob Heun](mailto:jacobheun@gmail.com) |
-| [`libp2p-crypto-secp256k1`](//github.com/libp2p/js-libp2p-crypto-secp256k1) | [![npm](https://img.shields.io/npm/v/libp2p-crypto-secp256k1.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-crypto-secp256k1/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-crypto-secp256k1.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-crypto-secp256k1) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-crypto-secp256k1/master)](https://travis-ci.com/libp2p/js-libp2p-crypto-secp256k1) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-crypto-secp256k1/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-crypto-secp256k1) | [Friedel Ziegelmayer](mailto:dignifiedquire@gmail.com) |
 | **data types** |
 | [`peer-id`](//github.com/libp2p/js-peer-id) | [![npm](https://img.shields.io/npm/v/peer-id.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-peer-id/releases) | [![Deps](https://david-dm.org/libp2p/js-peer-id.svg?style=flat-square)](https://david-dm.org/libp2p/js-peer-id) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-peer-id/master)](https://travis-ci.com/libp2p/js-peer-id) | [![codecov](https://codecov.io/gh/libp2p/js-peer-id/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-peer-id) | [Vasco Santos](mailto:santos.vasco10@gmail.com) |
+| [`libp2p-record`](//github.com/libp2p/js-libp2p-record) | [![npm](https://img.shields.io/npm/v/libp2p-record.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-record/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-record.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-record) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-record/master)](https://travis-ci.com/libp2p/js-libp2p-record) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-record/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-record) | [Jacob Heun](mailto:santos.vasco10@gmail.com) |
 | **pubsub** |
 | [`libp2p-floodsub`](//github.com/libp2p/js-libp2p-floodsub) | [![npm](https://img.shields.io/npm/v/libp2p-floodsub.svg?maxAge=86400&style=flat-square)](//github.com/libp2p/js-libp2p-floodsub/releases) | [![Deps](https://david-dm.org/libp2p/js-libp2p-floodsub.svg?style=flat-square)](https://david-dm.org/libp2p/js-libp2p-floodsub) | [![Travis CI](https://flat.badgen.net/travis/libp2p/js-libp2p-floodsub/master)](https://travis-ci.com/libp2p/js-libp2p-floodsub) | [![codecov](https://codecov.io/gh/libp2p/js-libp2p-floodsub/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/libp2p/js-libp2p-floodsub) | [Vasco Santos](mailto:vasco.santos@moxy.studio) |
 | [`libp2p-gossipsub`](//github.com/ChainSafe/js-libp2p-gossipsub) | [![npm](https://img.shields.io/npm/v/libp2p-gossipsub.svg?maxAge=86400&style=flat-square)](//github.com/ChainSafe/js-libp2p-gossipsub/releases) | [![Deps](https://david-dm.org/ChainSafe/js-libp2p-gossipsub.svg?style=flat-square)](https://david-dm.org/ChainSafe/js-libp2p-gossipsub) | [![Travis CI](https://flat.badgen.net/travis/ChainSafe/js-libp2p-gossipsub/master)](https://travis-ci.com/ChainSafe/js-libp2p-gossipsub) | [![codecov](https://codecov.io/gh/ChainSafe/js-libp2p-gossipsub/branch/master/graph/badge.svg?style=flat-square)](https://codecov.io/gh/ChainSafe/js-libp2p-gossipsub) | [Cayman Nava](mailto:caymannava@gmail.com) |

doc/API.md

@@ -3,6 +3,7 @@
 * [Static Functions](#static-functions)
   * [`create`](#create)
 * [Instance Methods](#libp2p-instance-methods)
+  * [`loadkeychain`](#loadkeychain)
   * [`start`](#start)
   * [`stop`](#stop)
   * [`dial`](#dial)
@@ -11,6 +12,9 @@
   * [`handle`](#handle)
   * [`unhandle`](#unhandle)
   * [`ping`](#ping)
+  * [`fetch`](#fetch)
+  * [`fetchService.registerLookupFunction`](#fetchserviceregisterlookupfunction)
+  * [`fetchService.unRegisterLookupFunction`](#fetchserviceunregisterlookupfunction)
   * [`multiaddrs`](#multiaddrs)
   * [`addressManager.getListenAddrs`](#addressmanagergetlistenaddrs)
   * [`addressManager.getAnnounceAddrs`](#addressmanagergetannounceaddrs)
@@ -454,6 +458,72 @@ Pings a given peer and get the operation's latency.
 const latency = await libp2p.ping(otherPeerId)
 ```
 
+## fetch
+
+Fetch a value from a remote node
+
+`libp2p.fetch(peer, key)`
+
+#### Parameters
+
+| Name | Type | Description |
+|------|------|-------------|
+| peer | [`PeerId`][peer-id]\|[`Multiaddr`][multiaddr]\|`string` | peer to ping |
+| key | `string` | A key that corresponds to a value on the remote node |
+
+#### Returns
+
+| Type | Description |
+|------|-------------|
+| `Promise<Uint8Array | null>` | The value for the key or null if it cannot be found |
+
+#### Example
+
+```js
+// ...
+const value = await libp2p.fetch(otherPeerId, '/some/key')
+```
+
+## fetchService.registerLookupFunction
+
+Register a function to look up values requested by remote nodes
+
+`libp2p.fetchService.registerLookupFunction(prefix, lookup)`
+
+#### Parameters
+
+| Name | Type | Description |
+|------|------|-------------|
+| prefix | `string` | All queries below this prefix will be passed to the lookup function |
+| lookup | `(key: string) => Promise<Uint8Array | null>` | A function that takes a key and returns a Uint8Array or null |
+
+#### Example
+
+```js
+// ...
+const value = await libp2p.fetchService.registerLookupFunction('/prefix', (key) => { ... })
+```
+
+## fetchService.unregisterLookupFunction
+
+Removes the passed lookup function or any function registered for the passed prefix
+
+`libp2p.fetchService.unregisterLookupFunction(prefix, lookup)`
+
+#### Parameters
+
+| Name | Type | Description |
+|------|------|-------------|
+| prefix | `string` | All queries below this prefix will be passed to the lookup function |
+| lookup | `(key: string) => Promise<Uint8Array | null>` | Optional: A function that takes a key and returns a Uint8Array or null |
+
+#### Example
+
+```js
+// ...
+libp2p.fetchService.unregisterLookupFunction('/prefix')
+```
+
 ## multiaddrs
 
 Gets the multiaddrs the libp2p node announces to the network. This computes the advertising multiaddrs
@@ -2086,7 +2156,7 @@ the NatManager performing NAT hole punching.
 
 [address]: https://github.com/libp2p/js-libp2p/tree/master/src/peer-store/address-book.js
 [cid]: https://github.com/multiformats/js-cid
-[connection]: https://github.com/libp2p/js-interfaces/tree/master/src/connection
+[connection]: https://github.com/libp2p/js-libp2p-interfaces/tree/master/packages/interfaces/src/connection
 [multiaddr]: https://github.com/multiformats/js-multiaddr
 [peer-id]: https://github.com/libp2p/js-peer-id
 [keys]: https://github.com/libp2p/js-libp2p-crypto/tree/master/src/keys

doc/CONFIGURATION.md

@@ -1,37 +1,40 @@
-# Configuration
+#
 
-- [Configuration](#configuration)
-  - [Overview](#overview)
-  - [Modules](#modules)
-    - [Transport](#transport)
-    - [Stream Multiplexing](#stream-multiplexing)
-    - [Connection Encryption](#connection-encryption)
-    - [Peer Discovery](#peer-discovery)
-    - [Content Routing](#content-routing)
-    - [Peer Routing](#peer-routing)
-    - [DHT](#dht)
-    - [Pubsub](#pubsub)
-  - [Customizing libp2p](#customizing-libp2p)
-    - [Examples](#examples)
-      - [Basic setup](#basic-setup)
-      - [Customizing Peer Discovery](#customizing-peer-discovery)
-      - [Setup webrtc transport and discovery](#setup-webrtc-transport-and-discovery)
-      - [Customizing Pubsub](#customizing-pubsub)
-      - [Customizing DHT](#customizing-dht)
-      - [Setup with Content and Peer Routing](#setup-with-content-and-peer-routing)
-      - [Setup with Relay](#setup-with-relay)
-      - [Setup with Auto Relay](#setup-with-auto-relay)
-      - [Setup with Keychain](#setup-with-keychain)
-      - [Configuring Dialing](#configuring-dialing)
-      - [Configuring Connection Manager](#configuring-connection-manager)
-      - [Configuring Transport Manager](#configuring-transport-manager)
-      - [Configuring Metrics](#configuring-metrics)
-      - [Configuring PeerStore](#configuring-peerstore)
-      - [Customizing Transports](#customizing-transports)
-      - [Configuring the NAT Manager](#configuring-the-nat-manager)
-        - [Browser support](#browser-support)
-        - [UPnP and NAT-PMP](#upnp-and-nat-pmp)
-  - [Configuration examples](#configuration-examples)
+- [Overview](#overview)
+- [Modules](#modules)
+  - [Transport](#transport)
+  - [Stream Multiplexing](#stream-multiplexing)
+  - [Connection Encryption](#connection-encryption)
+  - [Peer Discovery](#peer-discovery)
+  - [Content Routing](#content-routing)
+  - [Peer Routing](#peer-routing)
+  - [DHT](#dht)
+  - [Pubsub](#pubsub)
+- [Customizing libp2p](#customizing-libp2p)
+  - [Examples](#examples)
+    - [Basic setup](#basic-setup)
+    - [Customizing Peer Discovery](#customizing-peer-discovery)
+    - [Setup webrtc transport and discovery](#setup-webrtc-transport-and-discovery)
+    - [Customizing Pubsub](#customizing-pubsub)
+    - [Customizing DHT](#customizing-dht)
+    - [Setup with Content and Peer Routing](#setup-with-content-and-peer-routing)
+    - [Setup with Relay](#setup-with-relay)
+    - [Setup with Auto Relay](#setup-with-auto-relay)
+    - [Setup with Keychain](#setup-with-keychain)
+    - [Configuring Dialing](#configuring-dialing)
+    - [Configuring Connection Manager](#configuring-connection-manager)
+    - [Configuring Connection Gater](#configuring-connection-gater)
+      - [Outgoing connections](#outgoing-connections)
+      - [Incoming connections](#incoming-connections)
+    - [Configuring Transport Manager](#configuring-transport-manager)
+    - [Configuring Metrics](#configuring-metrics)
+    - [Configuring PeerStore](#configuring-peerstore)
+    - [Customizing Transports](#customizing-transports)
+    - [Configuring the NAT Manager](#configuring-the-nat-manager)
+      - [Browser support](#browser-support)
+      - [UPnP and NAT-PMP](#upnp-and-nat-pmp)
+    - [Configuring protocol name](#configuring-protocol-name)
+- [Configuration examples](#configuration-examples)
 
 ## Overview
 
@@ -210,7 +213,7 @@ const modules = {
 Moreover, the majority of the modules can be customized via option parameters. This way, it is also possible to provide this options through a `config` object. This config object should have the property name of each building block to configure, the same way as the modules specification.
 
 Besides the `modules` and `config`, libp2p allows other internal options and configurations:
-- `datastore`: an instance of [ipfs/interface-datastore](https://github.com/ipfs/interface-datastore/) modules.
+- `datastore`: an instance of [ipfs/interface-datastore](https://github.com/ipfs/js-ipfs-interfaces/tree/master/packages/interface-datastore) modules.
   - This is used in modules such as the DHT. If it is not provided, `js-libp2p` will use an in memory datastore.
 - `peerId`: the identity of the node, an instance of [libp2p/js-peer-id](https://github.com/libp2p/js-peer-id).
   - This is particularly useful if you want to reuse the same `peer-id`, as well as for modules like `libp2p-delegated-content-routing`, which need a `peer-id` in their instantiation.
@@ -374,11 +377,7 @@ const node = await Libp2p.create({
     dht: {                        // The DHT options (and defaults) can be found in its documentation
       kBucketSize: 20,
       enabled: true,              // This flag is required for DHT to run (disabled by default)
-      randomWalk: {
-        enabled: true,            // Allows to disable discovery (enabled by default)
-        interval: 300e3,
-        timeout: 10e3
-      }
+      clientMode: false           // Whether to run the WAN DHT in client or server mode (default: client mode)
     }
   }
 })
@@ -501,7 +500,10 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
-const LevelStore = require('datastore-level')
+const { LevelDatastore } = require('datastore-level')
+
+const datastore = new LevelDatastore('path/to/store')
+await datastore.open()
 
 const node = await Libp2p.create({
   modules: {
@@ -511,7 +513,7 @@ const node = await Libp2p.create({
   },
   keychain: {
     pass: 'notsafepassword123456789',
-    datastore: new LevelStore('path/to/store')
+    datastore: dsInstant,
   }
 })
 
@@ -591,9 +593,130 @@ const node = await Libp2p.create({
 })
 ```
 
+#### Configuring Connection Gater
+
+The Connection Gater allows us to prevent making incoming and outgoing connections to peers and storing
+multiaddrs in the address book.
+
+The order in which methods are called is as follows:
+
+##### Outgoing connections
+
+1. `connectionGater.denyDialPeer(...)`
+2. `connectionGater.denyDialMultiaddr(...)`
+3. `connectionGater.denyOutboundConnection(...)`
+4. `connectionGater.denyOutboundEncryptedConnection(...)`
+5. `connectionGater.denyOutboundUpgradedConnection(...)`
+
+##### Incoming connections
+
+1. `connectionGater.denyInboundConnection(...)`
+2. `connectionGater.denyInboundEncryptedConnection(...)`
+3. `connectionGater.denyInboundUpgradedConnection(...)`
+
+```js
+const node = await Libp2p.create({
+  // .. other config
+  connectionGater: {
+    /**
+     * denyDialMultiaddr tests whether we're permitted to Dial the
+     * specified peer.
+     *
+     * This is called by the dialer.connectToPeer implementation before
+     * dialling a peer.
+     *
+     * Return true to prevent dialing the passed peer.
+     */
+    denyDialPeer: (peerId: PeerId) => Promise<boolean>
+
+    /**
+     * denyDialMultiaddr tests whether we're permitted to dial the specified
+     * multiaddr for the given peer.
+     *
+     * This is called by the dialer.connectToPeer implementation after it has
+     * resolved the peer's addrs, and prior to dialling each.
+     *
+     * Return true to prevent dialing the passed peer on the passed multiaddr.
+     */
+    denyDialMultiaddr: (peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>
+
+    /**
+     * denyInboundConnection tests whether an incipient inbound connection is allowed.
+     *
+     * This is called by the upgrader, or by the transport directly (e.g. QUIC,
+     * Bluetooth), straight after it has accepted a connection from its socket.
+     *
+     * Return true to deny the incoming passed connection.
+     */
+    denyInboundConnection: (maConn: MultiaddrConnection) => Promise<boolean>
+
+    /**
+     * denyOutboundConnection tests whether an incipient outbound connection is allowed.
+     *
+     * This is called by the upgrader, or by the transport directly (e.g. QUIC,
+     * Bluetooth), straight after it has created a connection with its socket.
+     *
+     * Return true to deny the incoming passed connection.
+     */
+    denyOutboundConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>
+
+    /**
+     * denyInboundEncryptedConnection tests whether a given connection, now encrypted,
+     * is allowed.
+     *
+     * This is called by the upgrader, after it has performed the security
+     * handshake, and before it negotiates the muxer, or by the directly by the
+     * transport, at the exact same checkpoint.
+     *
+     * Return true to deny the passed secured connection.
+     */
+    denyInboundEncryptedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>
+
+    /**
+     * denyOutboundEncryptedConnection tests whether a given connection, now encrypted,
+     * is allowed.
+     *
+     * This is called by the upgrader, after it has performed the security
+     * handshake, and before it negotiates the muxer, or by the directly by the
+     * transport, at the exact same checkpoint.
+     *
+     * Return true to deny the passed secured connection.
+     */
+    denyOutboundEncryptedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>
+
+    /**
+     * denyInboundUpgradedConnection tests whether a fully capable connection is allowed.
+     *
+     * This is called after encryption has been negotiated and the connection has been
+     * multiplexed, if a multiplexer is configured.
+     *
+     * Return true to deny the passed upgraded connection.
+     */
+    denyInboundUpgradedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>
+
+    /**
+     * denyOutboundUpgradedConnection tests whether a fully capable connection is allowed.
+     *
+     * This is called after encryption has been negotiated and the connection has been
+     * multiplexed, if a multiplexer is configured.
+     *
+     * Return true to deny the passed upgraded connection.
+     */
+    denyOutboundUpgradedConnection: (peerId: PeerId, maConn: MultiaddrConnection) => Promise<boolean>
+
+    /**
+     * Used by the address book to filter passed addresses.
+     *
+     * Return true to allow storing the passed multiaddr for the passed peer.
+     */
+    filterMultiaddrForPeer: (peer: PeerId, multiaddr: Multiaddr) => Promise<boolean>
+  }
+})
+```
+
 #### Configuring Transport Manager
 
-The Transport Manager is responsible for managing the libp2p transports life cycle. This includes starting listeners for the provided listen addresses, closing these listeners and dialing using the provided transports. By default, if a libp2p node has a list of multiaddrs for listenning on and there are no valid transports for those multiaddrs, libp2p will throw an error on startup and shutdown. However, for some applications it is perfectly acceptable for libp2p nodes to start in dial only mode if all the listen multiaddrs failed. This error tolerance can be enabled as follows:
+The Transport Manager is responsible for managing the libp2p transports life cycle. This includes starting listeners for the provided listen addresses, closing these listeners and dialing using the provided transports. By default, if a libp2p node has a list of multiaddrs for listening on and there are no valid transports for those multiaddrs, libp2p will throw an error on startup and shutdown. However, for some applications it is perfectly acceptable for libp2p nodes to start in dial only mode if all the listen multiaddrs failed. This error tolerance can be enabled as follows:
 
 ```js
 const Libp2p = require('libp2p')
@@ -673,16 +796,18 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
+const LevelDatastore = require('datastore-level')
 
-const LevelStore = require('datastore-level')
+const datastore = new LevelDatastore('path/to/store')
+await datastore.open() // level database must be ready before node boot
 
 const node = await Libp2p.create({
+  datastore, // pass the opened datastore
   modules: {
     transport: [TCP],
     streamMuxer: [MPLEX],
     connEncryption: [NOISE]
   },
-  datastore: new LevelStore('path/to/store'),
   peerStore: {
     persistence: true,
     threshold: 5
@@ -783,7 +908,7 @@ By default under nodejs libp2p will attempt to use [UPnP](https://en.wikipedia.o
 
 #### Configuring protocol name
 
-Changing the protocol name prefix can isolate default public network (IPFS) for custom purposes. 
+Changing the protocol name prefix can isolate default public network (IPFS) for custom purposes.
 
 ```js
 const node = await Libp2p.create({
@@ -805,8 +930,8 @@ protocols: [
 
 As libp2p is designed to be a modular networking library, its usage will vary based on individual project needs. We've included links to some existing project configurations for your reference, in case you wish to replicate their configuration:
 
-- [libp2p-ipfs-nodejs](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs/src/core/runtime/libp2p-nodejs.js) - libp2p configuration used by js-ipfs when running in Node.js
-- [libp2p-ipfs-browser](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs/src/core/runtime/libp2p-browser.js) - libp2p configuration used by js-ipfs when running in a Browser (that supports WebRTC)
+- [libp2p-ipfs-nodejs](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs-core-config/src/libp2p.js) - libp2p configuration used by js-ipfs when running in Node.js
+- [libp2p-ipfs-browser](https://github.com/ipfs/js-ipfs/blob/master/packages/ipfs-core-config/src/libp2p.browser.js) - libp2p configuration used by js-ipfs when running in a Browser (that supports WebRTC)
 
 If you have developed a project using `js-libp2p`, please consider submitting your configuration to this list so that it can be found easily by other users.
 

doc/migrations/v0.32-v0.33.md

@@ -0,0 +1,14 @@
+<!--Specify versions for migration below-->
+# Migrating to libp2p@33
+
+A migration guide for refactoring your application code from libp2p v0.32.x to v0.33.0.
+
+## Table of Contents
+
+- [Module Updates](#module-updates)
+
+## Module Updates
+
+Libp2p uses a datastore implementation for Peerstore persistence and for the DHT state. While libp2p defaults to a datastore implementation, it can receive any implementation of a datastore compliant with the [interface-datastore](https://github.com/ipfs/js-ipfs-interfaces/tree/master/packages/interface-datastore) via its configuration.
+
+In this release, we updated to `interface-datastore@6.0.0`. As a result, libp2p users relying on a configured datastore should update it to a compliant implementation for updating libp2p.

examples/auto-relay/README.md

@@ -18,7 +18,7 @@ The relay node will need to have its relay subsystem enabled, as well as its HOP
 ```js
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 const node = await Libp2p.create({
@@ -76,7 +76,7 @@ One of the typical use cases for Auto Relay is nodes behind a NAT or browser nod
 ```js
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 const relayAddr = process.argv[2]
@@ -125,7 +125,7 @@ As you can see in the code, we need to provide the relay address, `relayAddr`, a
 You should now run the following to start the node running Auto Relay:
 
 ```sh
-node listener.js /ip4/192.168.1.120/tcp/58941/ws/p2p/QmQKCBm87HQMbFqy14oqC85pMmnRrj6iD46ggM6reqNpsd
+node listener.js /ip4/192.168.1.120/tcp/61592/ws/p2p/QmWDn2LY8nannvSWJzruUYoLZ4vV83vfCBwd8DipvdgQc3
 ```
 
 This should print out something similar to the following:
@@ -147,7 +147,7 @@ Now that you have a relay node and a node bound to that relay, you can test conn
 ```js
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 const autoRelayNodeAddr = process.argv[2]
@@ -173,7 +173,7 @@ console.log(`Connected to the auto relay node via ${conn.remoteAddr.toString()}`
 You should now run the following to start the relay node using the listen address from step 2:
 
 ```sh
-node dialer.js /ip4/192.168.1.120/tcp/58941/ws/p2p/QmQKCBm87HQMbFqy14oqC85pMmnRrj6iD46ggM6reqNpsd
+node dialer.js /ip4/192.168.1.120/tcp/61592/ws/p2p/QmWDn2LY8nannvSWJzruUYoLZ4vV83vfCBwd8DipvdgQc3
 ```
 
 Once you start your test node, it should print out something similar to the following:

examples/auto-relay/dialer.js

@@ -2,7 +2,7 @@
 
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 async function main () {

examples/auto-relay/listener.js

@@ -2,7 +2,7 @@
 
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 async function main () {

examples/auto-relay/relay.js

@@ -2,7 +2,7 @@
 
 const Libp2p = require('libp2p')
 const Websockets = require('libp2p-websockets')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 async function main () {

examples/auto-relay/test.js

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

examples/chat/src/libp2p.js

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

examples/chat/test.js

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

examples/connection-encryption/1.js

@@ -3,7 +3,7 @@
 const Libp2p = require('../..')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const pipe = require('it-pipe')
 
@@ -30,7 +30,7 @@ const createNode = async () => {
     createNode()
   ])
 
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
 
   node2.handle('/a-protocol', ({ stream }) => {
     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 `libp2p-noise` module to complete it, go ahead and `npm install libp2p-noise`.
+We will build this example on top of example for [Protocol and Stream Multiplexing](../protocol-and-stream-multiplexing). You will need the `@chainsafe/libp2p-noise` module to complete it, go ahead and `npm install @chainsafe/libp2p-noise`.
 
 To add them to your libp2p configuration, all you have to do is:
 
 ```JavaScript
 const Libp2p = require('libp2p')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const createNode = () => {
   return Libp2p.create({

examples/connection-encryption/test.js

@@ -1,30 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { waitForOutput } = require('../utils')
 
 async function test () {
-  const messageReceived = pDefer()
   process.stdout.write('1.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
+  await waitForOutput('This information is sent out encrypted to the other peer', 'node', [path.join(__dirname, '1.js')], {
+    cwd: __dirname
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-
-    const s = uint8ArrayToString(data)
-    if (s.includes('This information is sent out encrypted to the other peer')) {
-      messageReceived.resolve()
-    }
-  })
-
-  await messageReceived.promise
-  proc.kill()
 }
 
 module.exports = test

examples/delegated-routing/package.json

@@ -3,16 +3,16 @@
   "version": "0.1.0",
   "private": true,
   "dependencies": {
-    "ipfs": "~0.34.4",
-    "libp2p": "github:libp2p/js-libp2p#master",
-    "libp2p-delegated-content-routing": "~0.2.2",
-    "libp2p-delegated-peer-routing": "~0.2.2",
-    "libp2p-kad-dht": "~0.14.12",
-    "libp2p-mplex": "~0.8.5",
-    "libp2p-secio": "~0.11.1",
-    "libp2p-webrtc-star": "~0.15.8",
-    "libp2p-websocket-star": "~0.10.2",
-    "libp2p-websockets": "~0.12.2",
+    "@chainsafe/libp2p-noise": "^5.0.2",
+    "ipfs-core": "^0.13.0",
+    "libp2p": "../../",
+    "libp2p-delegated-content-routing": "^0.11.0",
+    "libp2p-delegated-peer-routing": "^0.11.1",
+    "libp2p-kad-dht": "^0.28.6",
+    "libp2p-mplex": "^0.10.4",
+    "libp2p-webrtc-star": "^0.25.0",
+    "libp2p-websocket-star": "^0.10.2",
+    "libp2p-websockets": "^0.16.2",
     "react": "^16.8.6",
     "react-dom": "^16.8.6",
     "react-scripts": "2.1.8"

examples/delegated-routing/src/App.js

@@ -2,7 +2,7 @@
 'use strict'
 
 import React from 'react'
-import Ipfs from 'ipfs'
+import Ipfs from 'ipfs-core'
 import libp2pBundle from './libp2p-bundle'
 const Component = React.Component
 
@@ -70,7 +70,7 @@ class App extends Component {
   }
 
   componentDidMount () {
-    window.ipfs = this.ipfs = new Ipfs({
+    window.ipfs = this.ipfs = Ipfs.create({
       config: {
         Addresses: {
           Swarm: []

examples/delegated-routing/src/libp2p-bundle.js

@@ -6,7 +6,7 @@ const Websockets = require('libp2p-websockets')
 const WebSocketStar = require('libp2p-websocket-star')
 const WebRTCStar = require('libp2p-webrtc-star')
 const MPLEX = require('libp2p-mplex')
-const SECIO = require('libp2p-secio')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const KadDHT = require('libp2p-kad-dht')
 const DelegatedPeerRouter = require('libp2p-delegated-peer-routing')
 const DelegatedContentRouter = require('libp2p-delegated-content-routing')
@@ -48,7 +48,7 @@ export default function Libp2pBundle ({peerInfo, peerBook}) {
         MPLEX
       ],
       connEncryption: [
-        SECIO
+        NOISE
       ],
       dht: KadDHT
     },

examples/discovery-mechanisms/1.js

@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const Bootstrap = require('libp2p-bootstrap')
 
 const bootstrapers = require('./bootstrapers')

examples/discovery-mechanisms/2.js

@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MulticastDNS = require('libp2p-mdns')
 
 const createNode = async () => {

examples/discovery-mechanisms/3.js

@@ -4,8 +4,8 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
-const Gossipsub = require('libp2p-gossipsub')
+const { NOISE } = require('@chainsafe/libp2p-noise')
+const Gossipsub = require('@achingbrain/libp2p-gossipsub')
 const Bootstrap = require('libp2p-bootstrap')
 const PubsubPeerDiscovery = require('libp2p-pubsub-peer-discovery')
 

examples/discovery-mechanisms/README.md

@@ -55,7 +55,7 @@ const node = await Libp2p.create({
   peerId,
   addresses: {
     listen: ['/ip4/0.0.0.0/tcp/0']
-  }
+  },
   modules: {
     transport: [ TCP ],
     streamMuxer: [ Mplex ],
@@ -117,7 +117,7 @@ const createNode = () => {
   return Libp2p.create({
     addresses: {
       listen: ['/ip4/0.0.0.0/tcp/0']
-    }
+    },
     modules: {
       transport: [ TCP ],
       streamMuxer: [ Mplex ],
@@ -144,8 +144,13 @@ const [node1, node2] = await Promise.all([
   createNode()
 ])
 
-node1.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String()))
-node2.on('peer:discovery', (peer) => console.log('Discovered:', peer.id.toB58String()))
+node1.on('peer:discovery', (peer) => console.log('Discovered:', peerId.toB58String()))
+node2.on('peer:discovery', (peer) => console.log('Discovered:', peerId.toB58String()))
+
+await Promise.all([
+  node1.start(),
+  node2.start()
+])
 ```
 
 If you run this example, you will see the other peers being discovered.
@@ -168,7 +173,7 @@ You can create your libp2p nodes as follows:
 const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const Gossipsub = require('libp2p-gossipsub')
 const Bootstrap = require('libp2p-bootstrap')
 const PubsubPeerDiscovery = require('libp2p-pubsub-peer-discovery')

examples/discovery-mechanisms/bootstrapers.js

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

examples/discovery-mechanisms/test-1.js

@@ -1,42 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pWaitFor = require('p-wait-for')
-const uint8ArrayToString = require('uint8arrays/to-string')
-const bootstrapers = require('./bootstrapers')
-
-const discoveredCopy = 'Discovered:'
-const connectedCopy = 'Connection established to:'
+const { waitForOutput } = require('../utils')
 
 async function test () {
-  const discoveredNodes = []
-  const connectedNodes = []
-
   process.stdout.write('1.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
+  await waitForOutput('Connection established to:', 'node', [path.join(__dirname, '1.js')], {
+    cwd: __dirname
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-    const line = uint8ArrayToString(data)
-
-    // Discovered or Connected
-    if (line.includes(discoveredCopy)) {
-      const id = line.trim().split(discoveredCopy)[1]
-      discoveredNodes.push(id)
-    } else if (line.includes(connectedCopy)) {
-      const id = line.trim().split(connectedCopy)[1]
-      connectedNodes.push(id)
-    }
-  })
-
-  await pWaitFor(() => discoveredNodes.length === bootstrapers.length && connectedNodes.length === bootstrapers.length)
-
-  proc.kill()
 }
 
 module.exports = test

examples/discovery-mechanisms/test-2.js

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

examples/discovery-mechanisms/test-3.js

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

examples/echo/src/libp2p.js

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

examples/echo/test.js

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

examples/libp2p-in-the-browser/.babelrc

@@ -1,4 +1,3 @@
 {
-  "presets": ["@babel/preset-env"],
   "plugins": ["syntax-async-functions","transform-regenerator"]
 }

examples/libp2p-in-the-browser/index.js

@@ -2,7 +2,7 @@ import 'babel-polyfill'
 import Libp2p from 'libp2p'
 import Websockets from 'libp2p-websockets'
 import WebRTCStar from 'libp2p-webrtc-star'
-import { NOISE } from 'libp2p-noise'
+import { NOISE } from '@chainsafe/libp2p-noise'
 import Mplex from 'libp2p-mplex'
 import Bootstrap from 'libp2p-bootstrap'
 

examples/libp2p-in-the-browser/package.json

@@ -14,12 +14,11 @@
   "author": "",
   "license": "ISC",
   "dependencies": {
-    "@babel/preset-env": "^7.13.0",
+    "@chainsafe/libp2p-noise": "^5.0.2",
     "libp2p": "../../",
-    "libp2p-bootstrap": "^0.13.0",
+    "libp2p-bootstrap": "^0.14.0",
     "libp2p-mplex": "^0.10.4",
-    "libp2p-noise": "^4.0.0",
-    "libp2p-webrtc-star": "^0.23.0",
+    "libp2p-webrtc-star": "^0.25.0",
     "libp2p-websockets": "^0.16.1"
   },
   "devDependencies": {
@@ -28,6 +27,6 @@
     "babel-plugin-syntax-async-functions": "^6.13.0",
     "babel-plugin-transform-regenerator": "^6.26.0",
     "babel-polyfill": "^6.26.0",
-    "parcel": "next"
+    "parcel": "^2.0.1"
   }
 }

examples/libp2p-in-the-browser/test.js

@@ -38,7 +38,7 @@ async function run() {
         )
         await browser.close();
 
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
         console.error(err)
         process.exit(1)
       } finally {

examples/package.json

@@ -8,12 +8,14 @@
   },
   "license": "MIT",
   "dependencies": {
+    "@achingbrain/libp2p-gossipsub": "^0.12.2",
     "execa": "^2.1.0",
     "fs-extra": "^8.1.0",
+    "libp2p": "../src",
     "libp2p-pubsub-peer-discovery": "^4.0.0",
-    "libp2p-relay-server": "^0.2.0",
-    "libp2p-gossipsub": "^0.9.1",
+    "libp2p-relay-server": "^0.3.0",
     "p-defer": "^3.0.0",
+    "uint8arrays": "^3.0.0",
     "which": "^2.0.1"
   },
   "devDependencies": {

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

@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const KadDHT = require('libp2p-kad-dht')
 
 const delay = require('delay')
@@ -38,8 +38,8 @@ const createNode = async () => {
     createNode()
   ])
 
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
 
   await Promise.all([
     node1.dial(node2.peerId),

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

@@ -4,7 +4,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const { CID } = require('multiformats/cid')
 const KadDHT = require('libp2p-kad-dht')
 
@@ -40,8 +40,8 @@ const createNode = async () => {
     createNode()
   ])
 
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
 
   await Promise.all([
     node1.dial(node2.peerId),

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

@@ -43,8 +43,8 @@ const node1 = nodes[0]
 const node2 = nodes[1]
 const node3 = nodes[2]
 
-node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
 
 await Promise.all([
   node1.dial(node2.peerId),

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

@@ -1,36 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pWaitFor = require('p-wait-for')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { waitForOutput } = require('../utils')
 
-async function test() {
+async function test () {
   process.stdout.write('1.js\n')
 
-  const addrs = []
-  let foundIt = false
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
+  await waitForOutput('Found it, multiaddrs are:', 'node', [path.join(__dirname, '1.js')], {
+    cwd: __dirname
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-
-    const line = uint8ArrayToString(data)
-
-    // Discovered peer
-    if (!foundIt && line.includes('Found it, multiaddrs are:')) {
-      foundIt = true
-    }
-
-    addrs.push(line)
-  })
-
-  await pWaitFor(() => addrs.length === 2)
-
-  proc.kill()
 }
 
 module.exports = test

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

@@ -1,40 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { waitForOutput } = require('../utils')
 
-const providedCopy = 'is providing'
-const foundCopy = 'Found provider:'
-
-async function test() {
+async function test () {
   process.stdout.write('2.js\n')
-  const providedDefer = pDefer()
-  const foundDefer = pDefer()
 
-  const proc = execa('node', [path.join(__dirname, '2.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
+  await waitForOutput('Found provider:', 'node', [path.join(__dirname, '2.js')], {
+    cwd: __dirname
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-
-    const line = uint8ArrayToString(data)
-
-    if (line.includes(providedCopy)) {
-      providedDefer.resolve()
-    } else if (line.includes(foundCopy)) {
-      foundDefer.resolve()
-    }
-  })
-
-  await Promise.all([
-    providedDefer.promise,
-    foundDefer.promise
-  ])
-  proc.kill()
 }
 
 module.exports = test

examples/pnet/index.js

@@ -29,7 +29,7 @@ generate(otherSwarmKey)
   console.log('nodes started...')
 
   // Add node 2 data to node1's PeerStore
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
   await node1.dial(node2.peerId)
 
   node2.handle('/private', ({ stream }) => {

examples/pnet/libp2p-node.js

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

examples/pnet/test.js

@@ -1,30 +1,13 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { waitForOutput } = require('../utils')
 
 async function test () {
-  const messageReceived = pDefer()
-  process.stdout.write('index.js\n')
-
-  const proc = execa('node', [path.join(__dirname, 'index.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
+  await waitForOutput('This message is sent on a private network', 'node', [path.join(__dirname, 'index.js')], {
+    cwd: __dirname
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-
-    const s = uint8ArrayToString(data)
-    if (s.includes('This message is sent on a private network')) {
-      messageReceived.resolve()
-    }
-  })
-
-  await messageReceived.promise
-  proc.kill()
 }
 
 module.exports = test
+

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

@@ -3,7 +3,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const pipe = require('it-pipe')
 
@@ -31,7 +31,7 @@ const createNode = async () => {
   ])
 
   // Add node's 2 data to the PeerStore
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
 
   // exact matching
   node2.handle('/your-protocol', ({ stream }) => {

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

@@ -3,7 +3,7 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const pipe = require('it-pipe')
 
@@ -31,7 +31,7 @@ const createNode = async () => {
   ])
 
   // Add node's 2 data to the PeerStore
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
 
   node2.handle(['/a', '/b'], ({ protocol, stream }) => {
     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('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const pipe = require('it-pipe')
 
@@ -32,8 +32,8 @@ const createNode = async () => {
   ])
 
   // Add node's 2 data to the PeerStore
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-  
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+
   node1.handle('/node-1', ({ stream }) => {
     pipe(
       stream,

examples/protocol-and-stream-muxing/README.md

@@ -20,7 +20,7 @@ const node1 = nodes[0]
 const node2 = nodes[1]
 
 // Add node's 2 data to the PeerStore
-node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
 
 // Here we are telling libp2p that if someone dials this node to talk with the `/your-protocol`
 // multicodec, the protocol identifier, please call this handler and give it the stream

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

@@ -1,31 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { waitForOutput } = require('../utils')
 
-async function test() {
-  const messageDefer = pDefer()
+async function test () {
   process.stdout.write('1.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
+  await waitForOutput('my own protocol, wow!', 'node', [path.join(__dirname, '1.js')], {
+    cwd: __dirname
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-
-    const line = uint8ArrayToString(data)
-
-    if (line.includes('my own protocol, wow!')) {
-      messageDefer.resolve()
-    }
-  })
-
-  await messageDefer.promise
-  proc.kill()
 }
 
 module.exports = test

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

@@ -1,38 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pWaitFor = require('p-wait-for')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { waitForOutput } = require('../utils')
 
-const messages = [
-  'protocol (a)',
-  'protocol (b)',
-  'another stream on protocol (b)'
-]
-
-async function test() {
+async function test () {
   process.stdout.write('2.js\n')
 
-  let count = 0
-  const proc = execa('node', [path.join(__dirname, '2.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
+  await waitForOutput('another stream on protocol (b)', 'node', [path.join(__dirname, '2.js')], {
+    cwd: __dirname
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-
-    const line = uint8ArrayToString(data)
-
-    if (messages.find((m) => line.includes(m))) {
-      count += 1
-    }
-  })
-
-  await pWaitFor(() => count === messages.length)
-
-  proc.kill()
 }
 
 module.exports = test

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

@@ -1,37 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pWaitFor = require('p-wait-for')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { waitForOutput } = require('../utils')
 
-const messages = [
-  'from 1 to 2',
-  'from 2 to 1'
-]
-
-async function test() {
+async function test () {
   process.stdout.write('3.js\n')
 
-  let count = 0
-  const proc = execa('node', [path.join(__dirname, '3.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
+  await waitForOutput('from 2 to 1', 'node', [path.join(__dirname, '3.js')], {
+    cwd: __dirname
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-
-    const line = uint8ArrayToString(data)
-
-    if (messages.find((m) => line.includes(m))) {
-      count += 1
-    }
-  })
-
-  await pWaitFor(() => count === messages.length)
-
-  proc.kill()
 }
 
 module.exports = test

examples/pubsub/1.js

@@ -4,10 +4,10 @@
 const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
-const Gossipsub = require('libp2p-gossipsub')
-const uint8ArrayFromString = require('uint8arrays/from-string')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { NOISE } = require('@chainsafe/libp2p-noise')
+const Gossipsub = require('@achingbrain/libp2p-gossipsub')
+const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 const createNode = async () => {
   const node = await Libp2p.create({
@@ -35,19 +35,19 @@ const createNode = async () => {
   ])
 
   // Add node's 2 data to the PeerStore
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
   await node1.dial(node2.peerId)
 
   node1.pubsub.on(topic, (msg) => {
     console.log(`node1 received: ${uint8ArrayToString(msg.data)}`)
   })
-  await node1.pubsub.subscribe(topic)
+  node1.pubsub.subscribe(topic)
 
   // Will not receive own published messages by default
   node2.pubsub.on(topic, (msg) => {
     console.log(`node2 received: ${uint8ArrayToString(msg.data)}`)
   })
-  await node2.pubsub.subscribe(topic)
+  node2.pubsub.subscribe(topic)
 
   // node2 publishes "news" every second
   setInterval(() => {

examples/pubsub/README.md

@@ -41,29 +41,31 @@ const node = await Libp2p.create({
 Once that is done, we only need to create a few libp2p nodes, connect them and everything is ready to start using pubsub.
 
 ```JavaScript
+const { fromString } = require('uint8arrays/from-string')
+const { toString } = require('uint8arrays/to-string')
 const topic = 'news'
 
 const node1 = nodes[0]
 const node2 = nodes[1]
 
 // Add node's 2 data to the PeerStore
-node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
 await node1.dial(node2.peerId)
 
 node1.pubsub.on(topic, (msg) => {
-  console.log(`node1 received: ${uint8ArrayToString(msg.data)}`)
+  console.log(`node1 received: ${toString(msg.data)}`)
 })
 await node1.pubsub.subscribe(topic)
 
 // Will not receive own published messages by default
 node2.pubsub.on(topic, (msg) => {
-  console.log(`node2 received: ${uint8ArrayToString(msg.data)}`)
+  console.log(`node2 received: ${toString(msg.data)}`)
 })
 await node2.pubsub.subscribe(topic)
 
 // node2 publishes "news" every second
 setInterval(() => {
-  node2.pubsub.publish(topic, uint8ArrayFromString('Bird bird bird, bird is the word!'))
+  node2.pubsub.publish(topic, fromString('Bird bird bird, bird is the word!'))
 }, 1000)
 ```
 

examples/pubsub/message-filtering/1.js

@@ -4,10 +4,10 @@
 const Libp2p = require('../../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
-const { NOISE } = require('libp2p-noise')
-const Gossipsub = require('libp2p-gossipsub')
-const uint8ArrayFromString = require('uint8arrays/from-string')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { NOISE } = require('@chainsafe/libp2p-noise')
+const Gossipsub = require('@achingbrain/libp2p-gossipsub')
+const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 const createNode = async () => {
   const node = await Libp2p.create({
@@ -36,10 +36,10 @@ const createNode = async () => {
   ])
 
   // node1 conect to node2 and node2 conect to node3
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
   await node1.dial(node2.peerId)
 
-  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
   await node2.dial(node3.peerId)
 
   //subscribe

examples/pubsub/message-filtering/README.md

@@ -32,10 +32,10 @@ const [node1, node2, node3] = await Promise.all([
   createNode(),
 ])
 
-node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
 await node1.dial(node2.peerId)
 
-node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
 await node2.dial(node3.peerId)
 ```
 

examples/pubsub/message-filtering/test.js

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

examples/pubsub/test-1.js

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

examples/transports/1.js

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

examples/transports/2.js

@@ -3,7 +3,7 @@
 
 const Libp2p = require('../..')
 const TCP = require('libp2p-tcp')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 const pipe = require('it-pipe')
@@ -49,7 +49,7 @@ function printAddrs (node, number) {
     console.log(result.toString())
   })
 
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
   const { stream } = await node1.dialProtocol(node2.peerId, '/print')
 
   await 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('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const MPLEX = require('libp2p-mplex')
 
 const pipe = require('it-pipe')
@@ -60,9 +60,9 @@ function print ({ stream }) {
   node2.handle('/print', print)
   node3.handle('/print', print)
 
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
-  node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  await node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)
 
   // node 1 (TCP) dials to node 2 (TCP+WebSockets)
   const { stream } = await node1.dialProtocol(node2.peerId, '/print')
@@ -81,7 +81,7 @@ function print ({ stream }) {
   // node 3 (listening WebSockets) can dial node 1 (TCP)
   try {
     await node3.dialProtocol(node1.peerId, '/print')
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     console.log('node 3 failed to dial to node 1 with:', err.message)
   }
 })();

examples/transports/4.js

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

examples/transports/README.md

@@ -13,7 +13,7 @@ When using libp2p, you need properly configure it, that is, pick your set of mod
 You will need 4 dependencies total, so go ahead and install all of them with:
 
 ```bash
-> npm install libp2p libp2p-tcp libp2p-noise
+> npm install libp2p libp2p-tcp @chainsafe/libp2p-noise
 ```
 
 Then, in your favorite text editor create a file with the `.js` extension. I've called mine `1.js`.
@@ -25,7 +25,7 @@ First thing is to create our own libp2p node! Insert:
 
 const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
-const { NOISE } = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 
 const createNode = async () => {
   const node = await Libp2p.create({
@@ -91,7 +91,7 @@ const concat = require('it-concat')
 const MPLEX = require('libp2p-mplex')
 ```
 
-We are going to reuse the `createNode` function from step 1, but this time add a stream multiplexer from `libp2p-mplex`. 
+We are going to reuse the `createNode` function from step 1, but this time add a stream multiplexer from `libp2p-mplex`.
 ```js
 const createNode = async () => {
   const node = await Libp2p.create({
@@ -140,7 +140,7 @@ Then add,
     console.log(result.toString())
   })
 
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
   const { stream } = await node1.dialProtocol(node2.peerId, '/print')
 
   await pipe(
@@ -224,9 +224,9 @@ node1.handle('/print', print)
 node2.handle('/print', print)
 node3.handle('/print', print)
 
-node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
-node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)
+await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+await node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)
 
 // node 1 (TCP) dials to node 2 (TCP+WebSockets)
 const { stream } = await node1.dialProtocol(node2.peerId, '/print')

examples/transports/test-1.js

@@ -1,38 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { waitForOutput } = require('../utils')
 
 async function test () {
-  const deferStarted = pDefer()
-  const deferListen = pDefer()
-
   process.stdout.write('1.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
+  await waitForOutput('/p2p/', 'node', [path.join(__dirname, '1.js')], {
+    cwd: __dirname
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-    const line = uint8ArrayToString(data)
-
-
-    if (line.includes('node has started (true/false): true')) {
-      deferStarted.resolve()
-    } else if (line.includes('p2p')) {
-      deferListen.resolve()
-    }
-  })
-
-  await Promise.all([
-    deferStarted.promise,
-    deferListen.promise
-  ])
-  proc.kill()
 }
 
 module.exports = test

examples/transports/test-2.js

@@ -1,30 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { waitForOutput } = require('../utils')
 
 async function test () {
-  const defer = pDefer()
   process.stdout.write('2.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '2.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
+  await waitForOutput('Hello p2p world!', 'node', [path.join(__dirname, '2.js')], {
+    cwd: __dirname
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-    const line = uint8ArrayToString(data)
-
-    if (line.includes('Hello p2p world!')) {
-      defer.resolve()
-    }
-  })
-
-  await defer.promise
-  proc.kill()
 }
 
 module.exports = test

examples/transports/test-3.js

@@ -1,41 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { waitForOutput } = require('../utils')
 
 async function test () {
-  const deferNode1 = pDefer()
-  const deferNode2 = pDefer()
-  const deferNode3 = pDefer()
-
   process.stdout.write('3.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '3.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
+  await waitForOutput('node 3 failed to dial to node 1 with:', 'node', [path.join(__dirname, '3.js')], {
+    cwd: __dirname
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-    const line = uint8ArrayToString(data)
-
-    if (line.includes('node 1 dialed to node 2 successfully')) {
-      deferNode1.resolve()
-    } else if (line.includes('node 2 dialed to node 3 successfully')) {
-      deferNode2.resolve()
-    } else if (line.includes('node 3 failed to dial to node 1 with:')) {
-      deferNode3.resolve()
-    }
-  })
-
-  await Promise.all([
-    deferNode1.promise,
-    deferNode2.promise,
-    deferNode3.promise
-  ])
-  proc.kill()
 }
 
 module.exports = test

examples/transports/test-4.js

@@ -1,33 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
-const pDefer = require('p-defer')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { waitForOutput } = require('../utils')
 
 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
+  await waitForOutput('node 2 dialed to node 1 successfully', 'node', [path.join(__dirname, '4.js')], {
+    cwd: __dirname
   })
-
-  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/utils.js

@@ -9,7 +9,7 @@ async function isExecutable (command) {
     await fs.access(command, fs.constants.X_OK)
 
     return true
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     if (err.code === 'ENOENT') {
       return isExecutable(await which(command))
     }
@@ -30,7 +30,7 @@ async function waitForOutput (expectedOutput, command, args = [], opts = {}) {
 
   const proc = execa(command, args, opts)
   let output = ''
-  let time = 120000
+  let time = 600000
 
   let timeout = setTimeout(() => {
     throw new Error(`Did not see "${expectedOutput}" in output from "${[command].concat(args).join(' ')}" after ${time/1000}s`)
@@ -49,7 +49,7 @@ async function waitForOutput (expectedOutput, command, args = [], opts = {}) {
 
   try {
     await proc
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     if (!err.killed) {
       throw err
     }

examples/webrtc-direct/dialer.js

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

examples/webrtc-direct/index.html

@@ -12,6 +12,6 @@
   <main>
     <pre id="output"></pre>
   </main>
-  <script src="./dialer.js"></script>
+  <script src="./dialer.js" type="module"></script>
 </body>
 </html>

examples/webrtc-direct/listener.js

@@ -2,7 +2,7 @@ const Libp2p = require('libp2p')
 const Bootstrap = require('libp2p-bootstrap')
 const WebRTCDirect = require('libp2p-webrtc-direct')
 const Mplex = require('libp2p-mplex')
-const {NOISE} = require('libp2p-noise')
+const { NOISE } = require('@chainsafe/libp2p-noise')
 const PeerId = require('peer-id')
 
 ;(async () => {
@@ -40,5 +40,4 @@ const PeerId = require('peer-id')
 
   console.log('Listening on:')
   node.multiaddrs.forEach((ma) => console.log(`${ma.toString()}/p2p/${node.peerId.toB58String()}`))
-
 })()

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",
@@ -13,19 +12,20 @@
   "devDependencies": {
     "@babel/cli": "^7.13.10",
     "@babel/core": "^7.13.10",
+    "@mapbox/node-pre-gyp": "^1.0.8",
     "babel-plugin-syntax-async-functions": "^6.13.0",
     "babel-plugin-transform-regenerator": "^6.26.0",
     "babel-polyfill": "^6.26.0",
-    "parcel-bundler": "1.12.3",
+    "parcel": "^2.0.1",
     "util": "^0.12.3"
   },
   "dependencies": {
+    "@chainsafe/libp2p-noise": "^5.0.2",
     "libp2p": "../../",
-    "libp2p-bootstrap": "^0.13.0",
+    "libp2p-bootstrap": "^0.14.0",
     "libp2p-mplex": "^0.10.4",
-    "libp2p-noise": "^4.0.0",
     "libp2p-webrtc-direct": "^0.7.0",
-    "peer-id": "^0.15.0"
+    "peer-id": "^0.16.0"
   },
   "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 uint8ArrayToString = require('uint8arrays/to-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 const { chromium } = require('playwright');
 
 function startNode (name, args = []) {
@@ -72,7 +72,7 @@ async function test () {
                   { timeout: 10000 }
                 )
                 await browser.close();
-            } catch (err) {
+            } catch (/** @type {any} */ err) {
                 console.error(err)
                 process.exit(1)
             } finally {

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.32.2",
+  "version": "0.36.0",
   "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
   "leadMaintainer": "Jacob Heun <jacobheun@gmail.com>",
   "main": "src/index.js",
@@ -20,20 +20,20 @@
   "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": "npm run build:proto:circuit && npm run build:proto:fetch && npm run build:proto:identify && npm run build:proto:plaintext && npm run build:proto:address-book && npm run build:proto:proto-book && npm run build:proto:peer && npm run build:proto:peer-record && npm run build:proto:envelope",
     "build:proto:circuit": "pbjs -t static-module -w commonjs -r libp2p-circuit --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/circuit/protocol/index.js ./src/circuit/protocol/index.proto",
+    "build:proto:fetch": "pbjs -t static-module -w commonjs -r libp2p-fetch --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/fetch/proto.js ./src/fetch/proto.proto",
     "build:proto:identify": "pbjs -t static-module -w commonjs -r libp2p-identify --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/identify/message.js ./src/identify/message.proto",
     "build:proto:plaintext": "pbjs -t static-module -w commonjs -r libp2p-plaintext --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/insecure/proto.js ./src/insecure/proto.proto",
-    "build:proto: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": "pbjs -t static-module -w commonjs -r libp2p-peer --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/peer-store/pb/peer.js ./src/peer-store/pb/peer.proto",
     "build:proto:peer-record": "pbjs -t static-module -w commonjs -r libp2p-peer-record --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/record/peer-record/peer-record.js ./src/record/peer-record/peer-record.proto",
     "build:proto:envelope": "pbjs -t static-module -w commonjs -r libp2p-envelope --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/record/envelope/envelope.js ./src/record/envelope/envelope.proto",
-    "build:proto-types": "npm run build:proto-types:circuit && npm run build:proto-types: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": "npm run build:proto-types:circuit && npm run build:proto-types:fetch && npm run build:proto-types:identify && npm run build:proto-types:plaintext && npm run build:proto-types:address-book && npm run build:proto-types:proto-book && npm run build:proto-types:peer && npm run build:proto-types:peer-record && npm run build:proto-types:envelope",
     "build:proto-types:circuit": "pbts -o src/circuit/protocol/index.d.ts src/circuit/protocol/index.js",
+    "build:proto-types:fetch": "pbts -o src/fetch/proto.d.ts src/fetch/proto.js",
     "build:proto-types:identify": "pbts -o src/identify/message.d.ts src/identify/message.js",
     "build:proto-types:plaintext": "pbts -o src/insecure/proto.d.ts src/insecure/proto.js",
-    "build:proto-types: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": "pbts -o src/peer-store/pb/peer.d.ts src/peer-store/pb/peer.js",
     "build:proto-types:peer-record": "pbts -o src/record/peer-record/peer-record.d.ts src/record/peer-record/peer-record.js",
     "build:proto-types:envelope": "pbts -o src/record/envelope/envelope.d.ts src/record/envelope/envelope.js",
     "test": "aegir test",
@@ -41,10 +41,8 @@
     "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",
+    "test:interop": "LIBP2P_JS=$PWD npx aegir test -t node -f ./node_modules/libp2p-interop/test/*",
+    "prepare": "npm run build",
     "coverage": "nyc --reporter=text --reporter=lcov npm run test:node"
   },
   "repository": {
@@ -65,107 +63,108 @@
   "homepage": "https://libp2p.io",
   "license": "MIT",
   "engines": {
-    "node": ">=14.0.0"
+    "node": ">=15.0.0"
   },
   "browser": {
-    "@motrix/nat-api": false
+    "nat-api": false
   },
   "eslintConfig": {
     "extends": "ipfs",
     "ignorePatterns": [
       "!.aegir.js",
-      "test/ts-use"
+      "test/ts-use",
+      "*.d.ts"
     ]
   },
   "dependencies": {
-    "@motrix/nat-api": "^0.3.1",
     "@vascosantos/moving-average": "^1.1.0",
-    "abort-controller": "^3.0.0",
+    "abortable-iterator": "^3.0.0",
     "aggregate-error": "^3.1.0",
-    "any-signal": "^2.1.1",
+    "any-signal": "^3.0.0",
     "bignumber.js": "^9.0.1",
     "class-is": "^1.1.0",
+    "datastore-core": "^7.0.0",
     "debug": "^4.3.1",
     "err-code": "^3.0.0",
-    "es6-promisify": "^6.1.1",
+    "es6-promisify": "^7.0.0",
     "events": "^3.3.0",
     "hashlru": "^2.3.0",
-    "interface-datastore": "^5.1.1",
+    "interface-datastore": "^6.0.2",
     "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-foreach": "^0.1.1",
     "it-handshake": "^2.0.0",
     "it-length-prefixed": "^5.0.2",
     "it-map": "^1.0.4",
     "it-merge": "^1.0.0",
     "it-pipe": "^1.1.0",
+    "it-sort": "^1.0.1",
     "it-take": "^1.0.0",
-    "libp2p-crypto": "^0.19.4",
-    "libp2p-interfaces": "^1.0.0",
+    "libp2p-crypto": "^0.21.2",
+    "libp2p-interfaces": "^4.0.0",
     "libp2p-utils": "^0.4.0",
     "mafmt": "^10.0.0",
     "merge-options": "^3.0.4",
+    "mortice": "^2.0.1",
     "multiaddr": "^10.0.0",
     "multiformats": "^9.0.0",
-    "multistream-select": "^2.0.0",
+    "multistream-select": "^3.0.0",
     "mutable-proxy": "^1.0.0",
-    "node-forge": "^0.10.0",
+    "nat-api": "^0.3.1",
+    "node-forge": "^1.2.1",
     "p-any": "^3.0.0",
     "p-fifo": "^1.0.0",
     "p-retry": "^4.4.0",
     "p-settle": "^4.1.1",
-    "peer-id": "^0.15.0",
+    "peer-id": "^0.16.0",
     "private-ip": "^2.1.0",
     "protobufjs": "^6.10.2",
     "retimer": "^3.0.0",
     "sanitize-filename": "^1.6.3",
     "set-delayed-interval": "^1.0.0",
     "streaming-iterables": "^6.0.0",
-    "timeout-abort-controller": "^1.1.1",
+    "timeout-abort-controller": "^3.0.0",
+    "uint8arrays": "^3.0.0",
     "varint": "^6.0.0",
     "wherearewe": "^1.0.0",
     "xsalsa20": "^1.1.0"
   },
   "devDependencies": {
+    "@chainsafe/libp2p-noise": "^5.0.0",
     "@nodeutils/defaults-deep": "^1.1.0",
     "@types/es6-promisify": "^6.0.0",
     "@types/node": "^16.0.1",
-    "@types/node-forge": "^0.10.1",
+    "@types/node-forge": "^1.0.0",
     "@types/varint": "^6.0.0",
-    "abortable-iterator": "^3.0.0",
-    "aegir": "^33.1.1",
+    "aegir": "^36.0.0",
     "buffer": "^6.0.3",
     "delay": "^5.0.0",
-    "interop-libp2p": "^0.4.0",
     "into-stream": "^6.0.0",
-    "ipfs-http-client": "^50.1.1",
+    "ipfs-http-client": "^54.0.2",
     "it-concat": "^2.0.0",
     "it-pair": "^1.0.0",
     "it-pushable": "^1.4.0",
     "libp2p": ".",
-    "libp2p-bootstrap": "^0.13.0",
+    "libp2p-bootstrap": "^0.14.0",
     "libp2p-delegated-content-routing": "^0.11.0",
-    "libp2p-delegated-peer-routing": "^0.10.0",
-    "libp2p-floodsub": "^0.27.0",
-    "libp2p-gossipsub": "^0.10.0",
-    "libp2p-interfaces-compliance-tests": "^1.0.0",
-    "libp2p-kad-dht": "^0.23.0",
-    "libp2p-mdns": "^0.17.0",
-    "libp2p-mplex": "^0.10.1",
-    "libp2p-noise": "^4.0.0",
+    "libp2p-delegated-peer-routing": "^0.11.1",
+    "libp2p-interfaces-compliance-tests": "^4.0.8",
+    "libp2p-interop": "^0.7.1",
+    "libp2p-kad-dht": "^0.28.6",
+    "libp2p-mdns": "^0.18.0",
+    "libp2p-mplex": "^0.10.4",
     "libp2p-tcp": "^0.17.0",
-    "libp2p-webrtc-star": "^0.23.0",
+    "libp2p-webrtc-star": "^0.25.0",
     "libp2p-websockets": "^0.16.0",
-    "multihashes": "^4.0.2",
     "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",
-    "uint8arrays": "^2.1.3",
+    "sinon": "^12.0.1",
     "util": "^0.12.3"
   },
   "contributors": [
@@ -179,22 +178,59 @@
     "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
     "Maciej Krüger <mkg20001@gmail.com>",
     "Hugo Dias <mail@hugodias.me>",
+    "dirkmc <dirkmdev@gmail.com>",
     "Volker Mische <volker.mische@gmail.com>",
     "Chris Dostert <chrisdostert@users.noreply.github.com>",
-    "dirkmc <dirkmdev@gmail.com>",
-    "Richard Littauer <richard.littauer@gmail.com>",
     "zeim839 <50573884+zeim839@users.noreply.github.com>",
-    "Ryan Bell <ryan@piing.net>",
+    "Robert Kiel <robert.kiel@hoprnet.org>",
+    "Richard Littauer <richard.littauer@gmail.com>",
     "a1300 <matthias-knopp@gmx.net>",
+    "Ryan Bell <ryan@piing.net>",
     "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
     "Andrew Nesbitt <andrewnez@gmail.com>",
-    "Elven <mon.samuel@qq.com>",
     "Franck Royer <franck@royer.one>",
-    "Giovanni T. Parra <fiatjaf@gmail.com>",
-    "Samlior <samlior@foxmail.com>",
     "Thomas Eizinger <thomas@eizinger.io>",
+    "Vít Habada <vithabada93@gmail.com>",
+    "Giovanni T. Parra <fiatjaf@gmail.com>",
     "acolytec3 <17355484+acolytec3@users.noreply.github.com>",
-    "Didrik Nordström <didrik@betamos.se>",
+    "Alan Smithee <ggnore.alan.smithee@gmail.com>",
+    "Elven <mon.samuel@qq.com>",
+    "Samlior <samlior@foxmail.com>",
+    "Didrik Nordström <didrik.nordstrom@gmail.com>",
+    "Aditya Bose <13054902+adbose@users.noreply.github.com>",
+    "TJKoury <TJKoury@gmail.com>",
+    "TheStarBoys <41286328+TheStarBoys@users.noreply.github.com>",
+    "Tiago Alves <alvesjtiago@gmail.com>",
+    "Tim Daubenschütz <tim@daubenschuetz.de>",
+    "XiaoZhang <zxinmyth@gmail.com>",
+    "Yusef Napora <yusef@napora.org>",
+    "Zane Starr <zcstarr@gmail.com>",
+    "ebinks <elizabethjbinks@gmail.com>",
+    "greenSnot <greenSnot@users.noreply.github.com>",
+    "isan_rivkin <isanrivkin@gmail.com>",
+    "mayerwin <mayerwin@users.noreply.github.com>",
+    "mcclure <andi.m.mcclure@gmail.com>",
+    "patrickwoodhead <91056047+patrickwoodhead@users.noreply.github.com>",
+    "phillmac <phillmac@users.noreply.github.com>",
+    "robertkiel <robert.kiel@validitylabs.org>",
+    "shresthagrawal <34920931+shresthagrawal@users.noreply.github.com>",
+    "swedneck <40505480+swedneck@users.noreply.github.com>",
+    "tuyennhv <vutuyen2636@gmail.com>",
+    "Sönke Hahn <soenkehahn@gmail.com>",
+    "Aleksei <vozhdb@gmail.com>",
+    "Bernd Strehl <bernd.strehl@gmail.com>",
+    "Chris Bratlien <chrisbratlien@gmail.com>",
+    "Cindy Wu <ciindy.wu@gmail.com>",
+    "Daijiro Wachi <daijiro.wachi@gmail.com>",
+    "Diogo Silva <fsdiogo@gmail.com>",
+    "Dmitriy Ryajov <dryajov@gmail.com>",
+    "Ethan Lam <elmemphis2000@gmail.com>",
+    "Fei Liu <liu.feiwood@gmail.com>",
+    "Felipe Martins <felipebrasil93@gmail.com>",
+    "Florian-Merle <florian.david.merle@gmail.com>",
+    "Francis Gulotta <wizard@roborooter.com>",
+    "Guy Sviry <32539816+guysv@users.noreply.github.com>",
+    "Henrique Dias <hacdias@gmail.com>",
     "Irakli Gozalishvili <rfobic@gmail.com>",
     "Joel Gustafson <joelg@mit.edu>",
     "John Rees <johnrees@users.noreply.github.com>",
@@ -203,43 +239,15 @@
     "Kevin Kwok <antimatter15@gmail.com>",
     "Kevin Lacker <lacker@gmail.com>",
     "Lars Gierth <lgierth@users.noreply.github.com>",
-    "Ethan Lam <elmemphis2000@gmail.com>",
+    "Leask Wong <i@leaskh.com>",
     "Marcin Tojek <mtojek@users.noreply.github.com>",
+    "Marston Connell <34043723+TheMarstonConnell@users.noreply.github.com>",
     "Michael Burns <5170+mburns@users.noreply.github.com>",
     "Miguel Mota <miguelmota2@gmail.com>",
     "Nuno Nogueira <nunofmn@gmail.com>",
-    "Dmitriy Ryajov <dryajov@gmail.com>",
     "Philipp Muens <raute1337@gmx.de>",
     "RasmusErik Voel Jensen <github@solsort.com>",
-    "Diogo Silva <fsdiogo@gmail.com>",
-    "Robert Kiel <robert.kiel@hoprnet.org>",
-    "phillmac <phillmac@users.noreply.github.com>",
-    "robertkiel <robert.kiel@validitylabs.org>",
     "Smite Chow <xiaopengyou@live.com>",
-    "Soeren <nikorpoulsen@gmail.com>",
-    "Sönke Hahn <soenkehahn@gmail.com>",
-    "TJKoury <TJKoury@gmail.com>",
-    "shresthagrawal <34920931+shresthagrawal@users.noreply.github.com>",
-    "Tiago Alves <alvesjtiago@gmail.com>",
-    "Daijiro Wachi <daijiro.wachi@gmail.com>",
-    "Yusef Napora <yusef@napora.org>",
-    "Zane Starr <zcstarr@gmail.com>",
-    "swedneck <40505480+swedneck@users.noreply.github.com>",
-    "Aleksei <vozhdb@gmail.com>",
-    "Cindy Wu <ciindy.wu@gmail.com>",
-    "Aditya Bose <13054902+adbose@users.noreply.github.com>",
-    "Chris Bratlien <chrisbratlien@gmail.com>",
-    "ebinks <elizabethjbinks@gmail.com>",
-    "greenSnot <greenSnot@users.noreply.github.com>",
-    "Bernd Strehl <bernd.strehl@gmail.com>",
-    "Francis Gulotta <wizard@roborooter.com>",
-    "isan_rivkin <isanrivkin@gmail.com>",
-    "Florian-Merle <florian.david.merle@gmail.com>",
-    "mayerwin <mayerwin@users.noreply.github.com>",
-    "Guy Sviry <32539816+guysv@users.noreply.github.com>",
-    "Henrique Dias <hacdias@gmail.com>",
-    "mcclure <andi.m.mcclure@gmail.com>",
-    "Felipe Martins <felipebrasil93@gmail.com>",
-    "Fei Liu <liu.feiwood@gmail.com>"
+    "Soeren <nikorpoulsen@gmail.com>"
   ]
 }

src/circuit/auto-relay.js

@@ -5,10 +5,10 @@ const log = Object.assign(debug('libp2p:auto-relay'), {
   error: debug('libp2p:auto-relay:err')
 })
 
-const uint8ArrayFromString = require('uint8arrays/from-string')
-const uint8ArrayToString = require('uint8arrays/to-string')
+const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
+const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 const { Multiaddr } = require('multiaddr')
-const PeerId = require('peer-id')
+const all = require('it-all')
 
 const { relay: multicodec } = require('./multicodec')
 const { canHop } = require('./circuit/hop')
@@ -22,7 +22,8 @@ const {
 
 /**
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- * @typedef {import('../peer-store/address-book').Address} Address
+ * @typedef {import('../peer-store/types').Address} Address
+ * @typedef {import('peer-id')} PeerId
  */
 
 /**
@@ -91,7 +92,7 @@ class AutoRelay {
 
     // If no protocol, check if we were keeping the peer before as a listenRelay
     if (!hasProtocol && this._listenRelays.has(id)) {
-      this._removeListenRelay(id)
+      await this._removeListenRelay(id)
       return
     } else if (!hasProtocol || this._listenRelays.has(id)) {
       return
@@ -113,10 +114,10 @@ class AutoRelay {
       const supportsHop = await canHop({ connection })
 
       if (supportsHop) {
-        this._peerStore.metadataBook.set(peerId, HOP_METADATA_KEY, uint8ArrayFromString(HOP_METADATA_VALUE))
+        await this._peerStore.metadataBook.setValue(peerId, HOP_METADATA_KEY, uint8ArrayFromString(HOP_METADATA_VALUE))
         await this._addListenRelay(connection, id)
       }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._onError(err)
     }
   }
@@ -125,7 +126,6 @@ class AutoRelay {
    * Peer disconnects.
    *
    * @param {Connection} connection - connection to the peer
-   * @returns {void}
    */
   _onPeerDisconnected (connection) {
     const peerId = connection.remotePeer
@@ -136,7 +136,9 @@ class AutoRelay {
       return
     }
 
-    this._removeListenRelay(id)
+    this._removeListenRelay(id).catch(err => {
+      log.error(err)
+    })
   }
 
   /**
@@ -148,28 +150,36 @@ class AutoRelay {
    * @returns {Promise<void>}
    */
   async _addListenRelay (connection, id) {
-    // Check if already listening on enough relays
-    if (this._listenRelays.size >= this.maxListeners) {
-      return
-    }
-
-    // Get peer known addresses and sort them per public addresses first
-    const remoteAddrs = this._peerStore.addressBook.getMultiaddrsForPeer(
-      connection.remotePeer, this._addressSorter
-    )
-
-    if (!remoteAddrs || !remoteAddrs.length) {
-      return
-    }
-
-    const listenAddr = `${remoteAddrs[0].toString()}/p2p-circuit`
-    this._listenRelays.add(id)
-
-    // Attempt to listen on relay
     try {
-      await this._transportManager.listen([new Multiaddr(listenAddr)])
-      // Announce multiaddrs will update on listen success by TransportManager event being triggered
-    } catch (err) {
+      // Check if already listening on enough relays
+      if (this._listenRelays.size >= this.maxListeners) {
+        return
+      }
+
+      // Get peer known addresses and sort them per public addresses first
+      const remoteAddrs = await this._peerStore.addressBook.getMultiaddrsForPeer(
+        connection.remotePeer, this._addressSorter
+      )
+
+      // Attempt to listen on relay
+      const result = await Promise.all(
+        remoteAddrs.map(async addr => {
+          try {
+            // Announce multiaddrs will update on listen success by TransportManager event being triggered
+            await this._transportManager.listen([new Multiaddr(`${addr.toString()}/p2p-circuit`)])
+            return true
+          } catch (/** @type {any} */ err) {
+            this._onError(err)
+          }
+
+          return false
+        })
+      )
+
+      if (result.includes(true)) {
+        this._listenRelays.add(id)
+      }
+    } catch (/** @type {any} */ err) {
       this._onError(err)
       this._listenRelays.delete(id)
     }
@@ -180,12 +190,11 @@ class AutoRelay {
    *
    * @private
    * @param {string} id - peer identifier string.
-   * @returns {void}
    */
-  _removeListenRelay (id) {
+  async _removeListenRelay (id) {
     if (this._listenRelays.delete(id)) {
       // TODO: this should be responsibility of the connMgr
-      this._listenOnAvailableHopRelays([id])
+      await this._listenOnAvailableHopRelays([id])
     }
   }
 
@@ -197,7 +206,6 @@ class AutoRelay {
    * 3. Search the network.
    *
    * @param {string[]} [peersToIgnore]
-   * @returns {Promise<void>}
    */
   async _listenOnAvailableHopRelays (peersToIgnore = []) {
     // TODO: The peer redial issue on disconnect should be handled by connection gating
@@ -207,31 +215,37 @@ class AutoRelay {
     }
 
     const knownHopsToDial = []
+    const peers = await all(this._peerStore.getPeers())
 
     // Check if we have known hop peers to use and attempt to listen on the already connected
-    for (const [id, metadataMap] of this._peerStore.metadataBook.data.entries()) {
+    for await (const { id, metadata } of peers) {
+      const idStr = id.toB58String()
+
       // Continue to next if listening on this or peer to ignore
-      if (this._listenRelays.has(id) || peersToIgnore.includes(id)) {
+      if (this._listenRelays.has(idStr)) {
         continue
       }
 
-      const supportsHop = metadataMap.get(HOP_METADATA_KEY)
+      if (peersToIgnore.includes(idStr)) {
+        continue
+      }
+
+      const supportsHop = metadata.get(HOP_METADATA_KEY)
 
       // Continue to next if it does not support Hop
       if (!supportsHop || uint8ArrayToString(supportsHop) !== HOP_METADATA_VALUE) {
         continue
       }
 
-      const peerId = PeerId.createFromB58String(id)
-      const connection = this._connectionManager.get(peerId)
+      const connection = this._connectionManager.get(id)
 
       // If not connected, store for possible later use.
       if (!connection) {
-        knownHopsToDial.push(peerId)
+        knownHopsToDial.push(id)
         continue
       }
 
-      await this._addListenRelay(connection, id)
+      await this._addListenRelay(connection, idStr)
 
       // Check if already listening on enough relays
       if (this._listenRelays.size >= this.maxListeners) {
@@ -258,7 +272,7 @@ class AutoRelay {
         }
 
         const peerId = provider.id
-        this._peerStore.addressBook.add(peerId, provider.multiaddrs)
+        await this._peerStore.addressBook.add(peerId, provider.multiaddrs)
 
         await this._tryToListenOnRelay(peerId)
 
@@ -267,7 +281,7 @@ class AutoRelay {
           return
         }
       }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._onError(err)
     }
   }
@@ -279,7 +293,7 @@ class AutoRelay {
     try {
       const connection = await this._libp2p.dial(peerId)
       await this._addListenRelay(connection, peerId.toB58String())
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this._onError(err, `could not connect and listen on known hop relay ${peerId.toB58String()}`)
     }
   }

src/circuit/circuit/hop.js

@@ -54,7 +54,7 @@ async function handleHop ({
   // Validate the HOP request has the required input
   try {
     validateAddrs(request, streamHandler)
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     return log.error('invalid hop request via peer %s', connection.remotePeer.toB58String(), err)
   }
 
@@ -93,7 +93,7 @@ async function handleHop ({
       connection: destinationConnection,
       request: stopRequest
     })
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     return log.error(err)
   }
 

src/circuit/circuit/stop.js

@@ -34,7 +34,7 @@ module.exports.handleStop = function handleStop ({
   // Validate the STOP request has the required input
   try {
     validateAddrs(request, streamHandler)
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     return log.error('invalid stop request via peer %s', connection.remotePeer.toB58String(), err)
   }
 

src/circuit/circuit/utils.js

@@ -34,7 +34,7 @@ function validateAddrs (msg, streamHandler) {
         return new Multiaddr(addr)
       })
     }
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
       ? CircuitRelay.Status.HOP_DST_MULTIADDR_INVALID
       : CircuitRelay.Status.STOP_DST_MULTIADDR_INVALID)
@@ -47,7 +47,7 @@ function validateAddrs (msg, streamHandler) {
         return new Multiaddr(addr)
       })
     }
-  } catch (err) {
+  } catch (/** @type {any} */ err) {
     writeResponse(streamHandler, msg.type === CircuitRelay.Type.HOP
       ? CircuitRelay.Status.HOP_SRC_MULTIADDR_INVALID
       : CircuitRelay.Status.STOP_SRC_MULTIADDR_INVALID)

src/circuit/index.js

@@ -4,7 +4,7 @@ const debug = require('debug')
 const log = Object.assign(debug('libp2p:relay'), {
   error: debug('libp2p:relay:err')
 })
-
+const { codes } = require('./../errors')
 const {
   setDelayedInterval,
   clearDelayedInterval
@@ -87,8 +87,8 @@ class Relay {
     try {
       const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
       await this._libp2p.contentRouting.provide(cid)
-    } catch (err) {
-      if (err.code === 'NO_ROUTERS_AVAILABLE') {
+    } catch (/** @type {any} */ err) {
+      if (err.code === codes.ERR_NO_ROUTERS_AVAILABLE) {
         log.error('a content router, such as a DHT, must be provided in order to advertise the relay service', err)
         // Stop the advertise
         this.stop()

src/circuit/transport.js

@@ -171,7 +171,7 @@ class Circuit {
       log('new outbound connection %s', maConn.remoteAddr)
 
       return this._upgrader.upgradeOutbound(maConn)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       log.error('Circuit relay dial failed', err)
       disconnectOnFailure && await relayConnection.close()
       throw err

src/config.js

@@ -13,6 +13,7 @@ const { FaultTolerance } = require('./transport-manager')
 
 /**
  * @typedef {import('multiaddr').Multiaddr} Multiaddr
+ * @typedef {import('./types').ConnectionGater} ConnectionGater
  * @typedef {import('.').Libp2pOptions} Libp2pOptions
  * @typedef {import('.').constructorOptions} constructorOptions
  */
@@ -27,6 +28,7 @@ const DefaultConfig = {
   connectionManager: {
     minConnections: 25
   },
+  connectionGater: /** @type {ConnectionGater} */ {},
   transportManager: {
     faultTolerance: FaultTolerance.FATAL_ALL
   },
@@ -60,13 +62,7 @@ const DefaultConfig = {
     protocolPrefix: 'ipfs',
     dht: {
       enabled: false,
-      kBucketSize: 20,
-      randomWalk: {
-        enabled: false, // disabled waiting for https://github.com/libp2p/js-libp2p-kad-dht/issues/86
-        queriesPerPeriod: 1,
-        interval: 300e3,
-        timeout: 10e3
-      }
+      kBucketSize: 20
     },
     nat: {
       enabled: true,

src/connection-manager/auto-dialler.js

@@ -0,0 +1,132 @@
+'use strict'
+
+const debug = require('debug')
+const mergeOptions = require('merge-options')
+// @ts-ignore retimer does not have types
+const retimer = require('retimer')
+const all = require('it-all')
+const { pipe } = require('it-pipe')
+const filter = require('it-filter')
+const sort = require('it-sort')
+
+const log = Object.assign(debug('libp2p:connection-manager:auto-dialler'), {
+  error: debug('libp2p:connection-manager:auto-dialler:err')
+})
+
+const defaultOptions = {
+  enabled: true,
+  minConnections: 0,
+  autoDialInterval: 10000
+}
+
+/**
+ * @typedef {import('../index')} Libp2p
+ * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
+ */
+
+/**
+ * @typedef {Object} AutoDiallerOptions
+ * @property {boolean} [enabled = true] - Should preemptively guarantee connections are above the low watermark
+ * @property {number} [minConnections = 0] - The minimum number of connections to avoid pruning
+ * @property {number} [autoDialInterval = 10000] - How often, in milliseconds, it should preemptively guarantee connections are above the low watermark
+ */
+
+class AutoDialler {
+  /**
+   * Proactively tries to connect to known peers stored in the PeerStore.
+   * It will keep the number of connections below the upper limit and sort
+   * the peers to connect based on wether we know their keys and protocols.
+   *
+   * @class
+   * @param {Libp2p} libp2p
+   * @param {AutoDiallerOptions} options
+   */
+  constructor (libp2p, options = {}) {
+    this._options = mergeOptions.call({ ignoreUndefined: true }, defaultOptions, options)
+    this._libp2p = libp2p
+    this._running = false
+    this._autoDialTimeout = null
+    this._autoDial = this._autoDial.bind(this)
+
+    log('options: %j', this._options)
+  }
+
+  /**
+   * Starts the auto dialer
+   */
+  async start () {
+    if (!this._options.enabled) {
+      log('not enabled')
+      return
+    }
+
+    this._running = true
+    this._autoDial().catch(err => {
+      log.error('could start autodial', err)
+    })
+    log('started')
+  }
+
+  /**
+   * Stops the auto dialler
+   */
+  async stop () {
+    if (!this._options.enabled) {
+      log('not enabled')
+      return
+    }
+
+    this._running = false
+    this._autoDialTimeout && this._autoDialTimeout.clear()
+    log('stopped')
+  }
+
+  async _autoDial () {
+    const minConnections = this._options.minConnections
+
+    // Already has enough connections
+    if (this._libp2p.connections.size >= minConnections) {
+      this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
+      return
+    }
+
+    // Sort peers on whether we know protocols of public keys for them
+    // TODO: assuming the `peerStore.getPeers()` order is stable this will mean
+    // we keep trying to connect to the same peers?
+    const peers = await pipe(
+      this._libp2p.peerStore.getPeers(),
+      (source) => filter(source, (peer) => !peer.id.equals(this._libp2p.peerId)),
+      (source) => sort(source, (a, b) => {
+        if (b.protocols && b.protocols.length && (!a.protocols || !a.protocols.length)) {
+          return 1
+        } else if (b.id.pubKey && !a.id.pubKey) {
+          return 1
+        }
+        return -1
+      }),
+      (source) => all(source)
+    )
+
+    for (let i = 0; this._running && i < peers.length && this._libp2p.connections.size < minConnections; i++) {
+      const peer = peers[i]
+
+      if (!this._libp2p.connectionManager.get(peer.id)) {
+        log('connecting to a peerStore stored peer %s', peer.id.toB58String())
+        try {
+          await this._libp2p.dialer.connectToPeer(peer.id)
+        } catch (/** @type {any} */ err) {
+          log.error('could not connect to peerStore stored peer', err)
+        }
+      }
+    }
+
+    // Connection Manager was stopped
+    if (!this._running) {
+      return
+    }
+
+    this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
+  }
+}
+
+module.exports = AutoDialler

src/connection-manager/index.js

@@ -12,7 +12,7 @@ const LatencyMonitor = require('./latency-monitor')
 const retimer = require('retimer')
 
 const { EventEmitter } = require('events')
-
+const trackedMap = require('../metrics/tracked-map')
 const PeerId = require('peer-id')
 
 const {
@@ -32,6 +32,10 @@ const defaultOptions = {
   defaultPeerValue: 1
 }
 
+const METRICS_COMPONENT = 'connection-manager'
+const METRICS_PEER_CONNECTIONS = 'peer-connections'
+const METRICS_PEER_VALUES = 'peer-values'
+
 /**
  * @typedef {import('../')} Libp2p
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
@@ -83,25 +87,34 @@ class ConnectionManager extends EventEmitter {
      *
      * @type {Map<string, number>}
      */
-    this._peerValues = new Map()
+    this._peerValues = trackedMap({
+      component: METRICS_COMPONENT,
+      metric: METRICS_PEER_VALUES,
+      metrics: this._libp2p.metrics
+    })
 
     /**
      * Map of connections per peer
      *
      * @type {Map<string, Connection[]>}
      */
-    this.connections = new Map()
+    this.connections = trackedMap({
+      component: METRICS_COMPONENT,
+      metric: METRICS_PEER_CONNECTIONS,
+      metrics: this._libp2p.metrics
+    })
 
     this._started = false
     this._timer = null
-    this._autoDialTimeout = null
     this._checkMetrics = this._checkMetrics.bind(this)
-    this._autoDial = this._autoDial.bind(this)
 
     this._latencyMonitor = new LatencyMonitor({
       latencyCheckIntervalMs: this._options.pollInterval,
       dataEmitIntervalMs: this._options.pollInterval
     })
+
+    // This emitter gets listened to a lot
+    this.setMaxListeners(Infinity)
   }
 
   /**
@@ -128,8 +141,6 @@ class ConnectionManager extends EventEmitter {
 
     this._started = true
     log('started')
-
-    this._options.autoDial && this._autoDial()
   }
 
   /**
@@ -138,7 +149,6 @@ class ConnectionManager extends EventEmitter {
    * @async
    */
   async stop () {
-    this._autoDialTimeout && this._autoDialTimeout.clear()
     this._timer && this._timer.clear()
 
     this._latencyMonitor.removeListener('data', this._onLatencyMeasure)
@@ -188,19 +198,22 @@ class ConnectionManager extends EventEmitter {
    *
    * @private
    */
-  _checkMetrics () {
+  async _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
-      this._checkMaxLimit('maxData', total)
-      log('metrics update', total)
-      this._timer = retimer(this._checkMetrics, this._options.pollInterval)
+      try {
+        const movingAverages = this._libp2p.metrics.global.movingAverages
+        // @ts-ignore moving averages object types
+        const received = movingAverages.dataReceived[this._options.movingAverageInterval].movingAverage()
+        await this._checkMaxLimit('maxReceivedData', received)
+        // @ts-ignore moving averages object types
+        const sent = movingAverages.dataSent[this._options.movingAverageInterval].movingAverage()
+        await this._checkMaxLimit('maxSentData', sent)
+        const total = received + sent
+        await this._checkMaxLimit('maxData', total)
+        log('metrics update', total)
+      } finally {
+        this._timer = retimer(this._checkMetrics, this._options.pollInterval)
+      }
     }
   }
 
@@ -208,27 +221,27 @@ class ConnectionManager extends EventEmitter {
    * Tracks the incoming connection and check the connection limit
    *
    * @param {Connection} connection
-   * @returns {void}
    */
-  onConnect (connection) {
+  async onConnect (connection) {
     const peerId = connection.remotePeer
     const peerIdStr = peerId.toB58String()
     const storedConn = this.connections.get(peerIdStr)
 
     this.emit('peer:connect', connection)
+
     if (storedConn) {
       storedConn.push(connection)
     } else {
       this.connections.set(peerIdStr, [connection])
     }
 
-    this._libp2p.peerStore.keyBook.set(peerId, peerId.pubKey)
+    await this._libp2p.peerStore.keyBook.set(peerId, peerId.pubKey)
 
     if (!this._peerValues.has(peerIdStr)) {
       this._peerValues.set(peerIdStr, this._options.defaultPeerValue)
     }
 
-    this._checkMaxLimit('maxConnections', this.size)
+    await this._checkMaxLimit('maxConnections', this.size)
   }
 
   /**
@@ -248,6 +261,8 @@ class ConnectionManager extends EventEmitter {
       this.connections.delete(peerId)
       this._peerValues.delete(connection.remotePeer.toB58String())
       this.emit('peer:disconnect', connection)
+
+      this._libp2p.metrics && this._libp2p.metrics.onPeerDisconnected(connection.remotePeer)
     }
   }
 
@@ -294,6 +309,9 @@ class ConnectionManager extends EventEmitter {
    */
   _onLatencyMeasure (summary) {
     this._checkMaxLimit('maxEventLoopDelay', summary.avgMs)
+      .catch(err => {
+        log.error(err)
+      })
   }
 
   /**
@@ -303,69 +321,22 @@ class ConnectionManager extends EventEmitter {
    * @param {string} name - The name of the field to check limits for
    * @param {number} value - The current value of the field
    */
-  _checkMaxLimit (name, value) {
+  async _checkMaxLimit (name, value) {
     const limit = this._options[name]
     log('checking limit of %s. current value: %d of %d', name, value, limit)
     if (value > limit) {
       log('%s: limit exceeded: %s, %d', this._peerId, name, value)
-      this._maybeDisconnectOne()
+      await this._maybeDisconnectOne()
     }
   }
 
-  /**
-   * Proactively tries to connect to known peers stored in the PeerStore.
-   * It will keep the number of connections below the upper limit and sort
-   * the peers to connect based on wether we know their keys and protocols.
-   *
-   * @async
-   * @private
-   */
-  async _autoDial () {
-    const minConnections = this._options.minConnections
-
-    // Already has enough connections
-    if (this.size >= minConnections) {
-      this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
-      return
-    }
-
-    // Sort peers on wether we know protocols of public keys for them
-    const peers = Array.from(this._libp2p.peerStore.peers.values())
-      .sort((a, b) => {
-        if (b.protocols && b.protocols.length && (!a.protocols || !a.protocols.length)) {
-          return 1
-        } else if (b.id.pubKey && !a.id.pubKey) {
-          return 1
-        }
-        return -1
-      })
-
-    for (let i = 0; i < peers.length && this.size < minConnections; i++) {
-      if (!this.get(peers[i].id)) {
-        log('connecting to a peerStore stored peer %s', peers[i].id.toB58String())
-        try {
-          await this._libp2p.dialer.connectToPeer(peers[i].id)
-
-          // Connection Manager was stopped
-          if (!this._started) {
-            return
-          }
-        } catch (err) {
-          log.error('could not connect to peerStore stored peer', err)
-        }
-      }
-    }
-
-    this._autoDialTimeout = retimer(this._autoDial, this._options.autoDialInterval)
-  }
-
   /**
    * If we have more connections than our maximum, close a connection
    * to the lowest valued peer.
    *
    * @private
    */
-  _maybeDisconnectOne () {
+  async _maybeDisconnectOne () {
     if (this._options.minConnections < this.connections.size) {
       const peerValues = Array.from(new Map([...this._peerValues.entries()].sort((a, b) => a[1] - b[1])))
       log('%s: sorted peer values: %j', this._peerId, peerValues)
@@ -376,7 +347,11 @@ class ConnectionManager extends EventEmitter {
         log('%s: closing a connection to %j', this._peerId, peerId)
         for (const connections of this.connections.values()) {
           if (connections[0].remotePeer.toB58String() === peerId) {
-            connections[0].close()
+            connections[0].close().catch(err => {
+              log.error(err)
+            })
+            // TODO: should not need to invoke this manually
+            this.onDisconnect(connections[0])
             break
           }
         }

src/content-routing/index.js

@@ -8,9 +8,10 @@ const {
   requirePeers,
   maybeLimitSource
 } = require('./utils')
-
+const drain = require('it-drain')
 const merge = require('it-merge')
 const { pipe } = require('it-pipe')
+const { DHTContentRouting } = require('../dht/dht-content-routing')
 
 /**
  * @typedef {import('peer-id')} PeerId
@@ -38,7 +39,7 @@ class ContentRouting {
 
     // If we have the dht, add it to the available content routers
     if (this.dht && libp2p._config.dht.enabled) {
-      this.routers.push(this.dht)
+      this.routers.push(new DHTContentRouting(this.dht))
     }
   }
 
@@ -53,7 +54,7 @@ class ContentRouting {
    */
   async * findProviders (key, options = {}) {
     if (!this.routers.length) {
-      throw errCode(new Error('No content this.routers available'), 'NO_ROUTERS_AVAILABLE')
+      throw errCode(new Error('No content this.routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
     yield * pipe(
@@ -76,7 +77,7 @@ class ContentRouting {
    */
   async provide (key) {
     if (!this.routers.length) {
-      throw errCode(new Error('No content routers available'), 'NO_ROUTERS_AVAILABLE')
+      throw errCode(new Error('No content routers available'), codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
     await Promise.all(this.routers.map((router) => router.provide(key)))
@@ -91,12 +92,12 @@ class ContentRouting {
    * @param {number} [options.minPeers] - minimum number of peers required to successfully put
    * @returns {Promise<void>}
    */
-  put (key, value, options) {
+  async put (key, value, options) {
     if (!this.libp2p.isStarted() || !this.dht.isStarted) {
       throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
     }
 
-    return this.dht.put(key, value, options)
+    await drain(this.dht.put(key, value, options))
   }
 
   /**
@@ -108,12 +109,18 @@ class ContentRouting {
    * @param {number} [options.timeout] - optional timeout (default: 60000)
    * @returns {Promise<GetData>}
    */
-  get (key, options) {
+  async get (key, options) {
     if (!this.libp2p.isStarted() || !this.dht.isStarted) {
       throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
     }
 
-    return this.dht.get(key, options)
+    for await (const event of this.dht.get(key, options)) {
+      if (event.name === 'VALUE') {
+        return { from: event.peerId, val: event.value }
+      }
+    }
+
+    throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
   }
 
   /**
@@ -123,14 +130,33 @@ class ContentRouting {
    * @param {number} nVals
    * @param {Object} [options] - get options
    * @param {number} [options.timeout] - optional timeout (default: 60000)
-   * @returns {Promise<GetData[]>}
    */
-  async getMany (key, nVals, options) { // eslint-disable-line require-await
+  async * getMany (key, nVals, options) { // eslint-disable-line require-await
     if (!this.libp2p.isStarted() || !this.dht.isStarted) {
       throw errCode(new Error(messages.NOT_STARTED_YET), codes.DHT_NOT_STARTED)
     }
 
-    return this.dht.getMany(key, nVals, options)
+    if (!nVals) {
+      return
+    }
+
+    let gotValues = 0
+
+    for await (const event of this.dht.get(key, options)) {
+      if (event.name === 'VALUE') {
+        yield { from: event.peerId, val: event.value }
+
+        gotValues++
+
+        if (gotValues === nVals) {
+          break
+        }
+      }
+    }
+
+    if (gotValues === 0) {
+      throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
+    }
   }
 }
 

src/content-routing/utils.js

@@ -14,12 +14,12 @@ const take = require('it-take')
  * Store the multiaddrs from every peer in the passed peer store
  *
  * @param {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>} source
- * @param {import('../peer-store')} peerStore
+ * @param {import('../peer-store/types').PeerStore} peerStore
  */
-function storeAddresses (source, peerStore) {
-  return map(source, (peer) => {
+async function * storeAddresses (source, peerStore) {
+  yield * map(source, async (peer) => {
     // ensure we have the addresses for a given peer
-    peerStore.addressBook.add(peer.id, peer.multiaddrs)
+    await peerStore.addressBook.add(peer.id, peer.multiaddrs)
 
     return peer
   })

src/dht/dht-content-routing.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const drain = require('it-drain')
+
+/**
+ * @typedef {import('peer-id')} PeerId
+ * @typedef {import('libp2p-interfaces/src/content-routing/types').ContentRouting} ContentRoutingModule
+ * @typedef {import('multiformats/cid').CID} CID
+ */
+
+/**
+ * Wrapper class to convert events into returned values
+ *
+ * @implements {ContentRoutingModule}
+ */
+class DHTContentRouting {
+  /**
+   * @param {import('libp2p-kad-dht').DHT} dht
+   */
+  constructor (dht) {
+    this._dht = dht
+  }
+
+  /**
+   * @param {CID} cid
+   */
+  async provide (cid) {
+    await drain(this._dht.provide(cid))
+  }
+
+  /**
+   * @param {CID} cid
+   * @param {*} options
+   */
+  async * findProviders (cid, options) {
+    for await (const event of this._dht.findProviders(cid, options)) {
+      if (event.name === 'PROVIDER') {
+        yield * event.providers
+      }
+    }
+  }
+}
+
+module.exports = { DHTContentRouting }

src/dht/dht-peer-routing.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const errCode = require('err-code')
+const { messages, codes } = require('../errors')
+
+/**
+ * @typedef {import('peer-id')} PeerId
+ * @typedef {import('libp2p-interfaces/src/peer-routing/types').PeerRouting} PeerRoutingModule
+ */
+
+/**
+ * Wrapper class to convert events into returned values
+ *
+ * @implements {PeerRoutingModule}
+ */
+class DHTPeerRouting {
+  /**
+   * @param {import('libp2p-kad-dht').DHT} dht
+   */
+  constructor (dht) {
+    this._dht = dht
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {any} options
+   */
+  async findPeer (peerId, options = {}) {
+    for await (const event of this._dht.findPeer(peerId, options)) {
+      if (event.name === 'FINAL_PEER') {
+        return event.peer
+      }
+    }
+
+    throw errCode(new Error(messages.NOT_FOUND), codes.ERR_NOT_FOUND)
+  }
+
+  /**
+   * @param {Uint8Array} key
+   * @param {any} options
+   */
+  async * getClosestPeers (key, options = {}) {
+    for await (const event of this._dht.getClosestPeers(key, options)) {
+      if (event.name === 'PEER_RESPONSE') {
+        yield * event.closer
+      }
+    }
+  }
+}
+
+module.exports = { DHTPeerRouting }

src/dialer/dial-request.js

@@ -1,11 +1,13 @@
 'use strict'
 
 const errCode = require('err-code')
-const AbortController = require('abort-controller').default
 const { anySignal } = require('any-signal')
 // @ts-ignore p-fifo does not export types
 const FIFO = require('p-fifo')
 const pAny = require('p-any')
+// @ts-expect-error setMaxListeners is missing from the types
+const { setMaxListeners } = require('events')
+const { codes } = require('../errors')
 
 /**
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
@@ -54,12 +56,20 @@ class DialRequest {
     const tokens = this.dialer.getTokens(this.addrs.length)
     // If no tokens are available, throw
     if (tokens.length < 1) {
-      throw errCode(new Error('No dial tokens available'), 'ERR_NO_DIAL_TOKENS')
+      throw errCode(new Error('No dial tokens available'), codes.ERR_NO_DIAL_TOKENS)
     }
 
     const tokenHolder = new FIFO()
     tokens.forEach(token => tokenHolder.push(token))
-    const dialAbortControllers = this.addrs.map(() => new AbortController())
+    const dialAbortControllers = this.addrs.map(() => {
+      const controller = new AbortController()
+      try {
+        // fails on node < 15.4
+        setMaxListeners && setMaxListeners(Infinity, controller.signal)
+      } catch {}
+
+      return controller
+    })
     let completedDials = 0
 
     try {

src/dialer/index.js

@@ -1,20 +1,23 @@
 'use strict'
 
 const debug = require('debug')
+const all = require('it-all')
+const filter = require('it-filter')
+const { pipe } = require('it-pipe')
 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 TimeoutController = require('timeout-abort-controller')
+const { TimeoutController } = require('timeout-abort-controller')
 const { AbortError } = require('abortable-iterator')
 const { anySignal } = require('any-signal')
-
+// @ts-expect-error setMaxListeners is missing from the types
+const { setMaxListeners } = require('events')
 const DialRequest = require('./dial-request')
 const { publicAddressesFirst } = require('libp2p-utils/src/address-sort')
 const getPeer = require('../get-peer')
-
+const trackedMap = require('../metrics/tracked-map')
 const { codes } = require('../errors')
 const {
   DIAL_TIMEOUT,
@@ -23,18 +26,24 @@ const {
   MAX_ADDRS_TO_DIAL
 } = require('../constants')
 
+const METRICS_COMPONENT = 'dialler'
+const METRICS_PENDING_DIALS = 'pending-dials'
+const METRICS_PENDING_DIAL_TARGETS = 'pending-dial-targets'
+
 /**
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
  * @typedef {import('peer-id')} PeerId
- * @typedef {import('../peer-store')} PeerStore
- * @typedef {import('../peer-store/address-book').Address} Address
+ * @typedef {import('../peer-store/types').PeerStore} PeerStore
+ * @typedef {import('../peer-store/types').Address} Address
  * @typedef {import('../transport-manager')} TransportManager
+ * @typedef {import('../types').ConnectionGater} ConnectionGater
  */
 
 /**
  * @typedef {Object} DialerProperties
  * @property {PeerStore} peerStore
  * @property {TransportManager} transportManager
+ * @property {ConnectionGater} connectionGater
  *
  * @typedef {(addr:Multiaddr) => Promise<string[]>} Resolver
  *
@@ -45,14 +54,15 @@ const {
  * @property {number} [maxDialsPerPeer = MAX_PER_PEER_DIALS] - Number of max concurrent dials per peer.
  * @property {number} [dialTimeout = DIAL_TIMEOUT] - How long a dial attempt is allowed to take.
  * @property {Record<string, Resolver>} [resolvers = {}] - multiaddr resolvers to use when dialing
+ * @property {import('../metrics')} [metrics]
  *
  * @typedef DialTarget
  * @property {string} id
  * @property {Multiaddr[]} addrs
  *
  * @typedef PendingDial
- * @property {DialRequest} dialRequest
- * @property {TimeoutController} controller
+ * @property {import('./dial-request')} dialRequest
+ * @property {import('timeout-abort-controller').TimeoutController} controller
  * @property {Promise<Connection>} promise
  * @property {function():void} destroy
  */
@@ -65,13 +75,16 @@ class Dialer {
   constructor ({
     transportManager,
     peerStore,
+    connectionGater,
     addressSorter = publicAddressesFirst,
     maxParallelDials = MAX_PARALLEL_DIALS,
     maxAddrsToDial = MAX_ADDRS_TO_DIAL,
     dialTimeout = DIAL_TIMEOUT,
     maxDialsPerPeer = MAX_PER_PEER_DIALS,
-    resolvers = {}
+    resolvers = {},
+    metrics
   }) {
+    this.connectionGater = connectionGater
     this.transportManager = transportManager
     this.peerStore = peerStore
     this.addressSorter = addressSorter
@@ -80,8 +93,20 @@ class Dialer {
     this.timeout = dialTimeout
     this.maxDialsPerPeer = maxDialsPerPeer
     this.tokens = [...new Array(maxParallelDials)].map((_, index) => index)
-    this._pendingDials = new Map()
-    this._pendingDialTargets = new Map()
+
+    /** @type {Map<string, PendingDial>} */
+    this._pendingDials = trackedMap({
+      component: METRICS_COMPONENT,
+      metric: METRICS_PENDING_DIALS,
+      metrics
+    })
+
+    /** @type {Map<string, { resolve: (value: any) => void, reject: (err: Error) => void}>} */
+    this._pendingDialTargets = trackedMap({
+      component: METRICS_COMPONENT,
+      metric: METRICS_PENDING_DIAL_TARGETS,
+      metrics
+    })
 
     for (const [key, value] of Object.entries(resolvers)) {
       Multiaddr.resolvers.set(key, value)
@@ -95,7 +120,7 @@ class Dialer {
     for (const dial of this._pendingDials.values()) {
       try {
         dial.controller.abort()
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
         log.error(err)
       }
     }
@@ -118,6 +143,12 @@ class Dialer {
    * @returns {Promise<Connection>}
    */
   async connectToPeer (peer, options = {}) {
+    const { id } = getPeer(peer)
+
+    if (await this.connectionGater.denyDialPeer(id)) {
+      throw errCode(new Error('The dial request is blocked by gater.allowDialPeer'), codes.ERR_PEER_DIAL_INTERCEPTED)
+    }
+
     const dialTarget = await this._createCancellableDialTarget(peer)
 
     if (!dialTarget.addrs.length) {
@@ -129,7 +160,7 @@ class Dialer {
       const connection = await pendingDial.promise
       log('dial succeeded to %s', dialTarget.id)
       return connection
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       // Error is a timeout
       if (pendingDial.controller.signal.aborted) {
         err.code = codes.ERR_TIMEOUT
@@ -156,14 +187,16 @@ class Dialer {
       this._pendingDialTargets.set(id, { resolve, reject })
     })
 
-    const dialTarget = await Promise.race([
-      this._createDialTarget(peer),
-      cancellablePromise
-    ])
+    try {
+      const dialTarget = await Promise.race([
+        this._createDialTarget(peer),
+        cancellablePromise
+      ])
 
-    this._pendingDialTargets.delete(id)
-
-    return dialTarget
+      return dialTarget
+    } finally {
+      this._pendingDialTargets.delete(id)
+    }
   }
 
   /**
@@ -180,10 +213,16 @@ class Dialer {
     const { id, multiaddrs } = getPeer(peer)
 
     if (multiaddrs) {
-      this.peerStore.addressBook.add(id, multiaddrs)
+      await this.peerStore.addressBook.add(id, multiaddrs)
     }
 
-    let knownAddrs = this.peerStore.addressBook.getMultiaddrsForPeer(id, this.addressSorter) || []
+    let knownAddrs = await pipe(
+      await this.peerStore.addressBook.getMultiaddrsForPeer(id, this.addressSorter),
+      (source) => filter(source, async (multiaddr) => {
+        return !(await this.connectionGater.denyDialMultiaddr(id, multiaddr))
+      }),
+      (source) => all(source)
+    )
 
     // 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.
@@ -203,7 +242,7 @@ class Dialer {
     const supportedAddrs = addrs.filter(a => this.transportManager.transportForMultiaddr(a))
 
     if (supportedAddrs.length > this.maxAddrsToDial) {
-      this.peerStore.delete(id)
+      await this.peerStore.delete(id)
       throw errCode(new Error('dial with more addresses than allowed'), codes.ERR_TOO_MANY_ADDRESSES)
     }
 
@@ -240,10 +279,18 @@ class Dialer {
 
     // Combine the timeout signal and options.signal, if provided
     const timeoutController = new TimeoutController(this.timeout)
+
     const signals = [timeoutController.signal]
     options.signal && signals.push(options.signal)
     const signal = anySignal(signals)
 
+    // this signal will potentially be used while dialing lots of
+    // peers so prevent MaxListenersExceededWarning appearing in the console
+    try {
+      // fails on node < 15.4
+      setMaxListeners && setMaxListeners(Infinity, signal)
+    } catch {}
+
     const pendingDial = {
       dialRequest,
       controller: timeoutController,
@@ -254,6 +301,7 @@ class Dialer {
       }
     }
     this._pendingDials.set(dialTarget.id, pendingDial)
+
     return pendingDial
   }
 

src/errors.js

@@ -3,7 +3,8 @@
 exports.messages = {
   NOT_STARTED_YET: 'The libp2p node is not started yet',
   DHT_DISABLED: 'DHT is not available',
-  CONN_ENCRYPTION_REQUIRED: 'At least one connection encryption module is required'
+  CONN_ENCRYPTION_REQUIRED: 'At least one connection encryption module is required',
+  NOT_FOUND: 'Not found'
 }
 
 exports.codes = {
@@ -11,6 +12,8 @@ exports.codes = {
   PUBSUB_NOT_STARTED: 'ERR_PUBSUB_NOT_STARTED',
   DHT_NOT_STARTED: 'ERR_DHT_NOT_STARTED',
   CONN_ENCRYPTION_REQUIRED: 'ERR_CONN_ENCRYPTION_REQUIRED',
+  ERR_PEER_DIAL_INTERCEPTED: 'ERR_PEER_DIAL_INTERCEPTED',
+  ERR_CONNECTION_INTERCEPTED: 'ERR_CONNECTION_INTERCEPTED',
   ERR_INVALID_PROTOCOLS_FOR_STREAM: 'ERR_INVALID_PROTOCOLS_FOR_STREAM',
   ERR_CONNECTION_ENDED: 'ERR_CONNECTION_ENDED',
   ERR_CONNECTION_FAILED: 'ERR_CONNECTION_FAILED',
@@ -29,10 +32,35 @@ exports.codes = {
   ERR_INVALID_PARAMETERS: 'ERR_INVALID_PARAMETERS',
   ERR_INVALID_PEER: 'ERR_INVALID_PEER',
   ERR_MUXER_UNAVAILABLE: 'ERR_MUXER_UNAVAILABLE',
+  ERR_NOT_FOUND: 'ERR_NOT_FOUND',
   ERR_TIMEOUT: 'ERR_TIMEOUT',
   ERR_TRANSPORT_UNAVAILABLE: 'ERR_TRANSPORT_UNAVAILABLE',
   ERR_TRANSPORT_DIAL_FAILED: 'ERR_TRANSPORT_DIAL_FAILED',
   ERR_UNSUPPORTED_PROTOCOL: 'ERR_UNSUPPORTED_PROTOCOL',
   ERR_INVALID_MULTIADDR: 'ERR_INVALID_MULTIADDR',
-  ERR_SIGNATURE_NOT_VALID: 'ERR_SIGNATURE_NOT_VALID'
+  ERR_SIGNATURE_NOT_VALID: 'ERR_SIGNATURE_NOT_VALID',
+  ERR_FIND_SELF: 'ERR_FIND_SELF',
+  ERR_NO_ROUTERS_AVAILABLE: 'ERR_NO_ROUTERS_AVAILABLE',
+  ERR_CONNECTION_NOT_MULTIPLEXED: 'ERR_CONNECTION_NOT_MULTIPLEXED',
+  ERR_NO_DIAL_TOKENS: 'ERR_NO_DIAL_TOKENS',
+  ERR_KEYCHAIN_REQUIRED: 'ERR_KEYCHAIN_REQUIRED',
+  ERR_INVALID_CMS: 'ERR_INVALID_CMS',
+  ERR_MISSING_KEYS: 'ERR_MISSING_KEYS',
+  ERR_NO_KEY: 'ERR_NO_KEY',
+  ERR_INVALID_KEY_NAME: 'ERR_INVALID_KEY_NAME',
+  ERR_INVALID_KEY_TYPE: 'ERR_INVALID_KEY_TYPE',
+  ERR_KEY_ALREADY_EXISTS: 'ERR_KEY_ALREADY_EXISTS',
+  ERR_INVALID_KEY_SIZE: 'ERR_INVALID_KEY_SIZE',
+  ERR_KEY_NOT_FOUND: 'ERR_KEY_NOT_FOUND',
+  ERR_OLD_KEY_NAME_INVALID: 'ERR_OLD_KEY_NAME_INVALID',
+  ERR_NEW_KEY_NAME_INVALID: 'ERR_NEW_KEY_NAME_INVALID',
+  ERR_PASSWORD_REQUIRED: 'ERR_PASSWORD_REQUIRED',
+  ERR_PEM_REQUIRED: 'ERR_PEM_REQUIRED',
+  ERR_CANNOT_READ_KEY: 'ERR_CANNOT_READ_KEY',
+  ERR_MISSING_PRIVATE_KEY: 'ERR_MISSING_PRIVATE_KEY',
+  ERR_INVALID_OLD_PASS_TYPE: 'ERR_INVALID_OLD_PASS_TYPE',
+  ERR_INVALID_NEW_PASS_TYPE: 'ERR_INVALID_NEW_PASS_TYPE',
+  ERR_INVALID_PASS_LENGTH: 'ERR_INVALID_PASS_LENGTH',
+  ERR_NOT_IMPLEMENTED: 'ERR_NOT_IMPLEMENTED',
+  ERR_WRONG_PING_ACK: 'ERR_WRONG_PING_ACK'
 }

src/fetch/README.md

@@ -0,0 +1,36 @@
+libp2p-fetch JavaScript Implementation
+=====================================
+
+> Libp2p fetch protocol JavaScript implementation
+
+## Overview
+
+An implementation of the Fetch protocol as described here: https://github.com/libp2p/specs/tree/master/fetch
+
+The fetch protocol is a simple protocol for requesting a value corresponding to a key from a peer.
+
+## Usage
+
+```javascript
+const Libp2p = require('libp2p')
+
+/**
+ * Given a key (as a string) returns a value (as a Uint8Array), or null if the key isn't found.
+ * All keys must be prefixed my the same prefix, which will be used to find the appropriate key
+ * lookup function.
+ * @param key - a string
+ * @returns value - a Uint8Array value that corresponds to the given key, or null if the key doesn't
+ *   have a corresponding value.
+ */
+async function my_subsystem_key_lookup(key) {
+    // app specific callback to lookup key-value pairs.
+}
+
+// Enable this peer to respond to fetch requests for keys that begin with '/my_subsystem_key_prefix/'
+const libp2p = Libp2p.create(...)
+libp2p.fetchService.registerLookupFunction('/my_subsystem_key_prefix/', my_subsystem_key_lookup)
+
+const key = '/my_subsystem_key_prefix/{...}'
+const peerDst = PeerId.parse('Qmfoo...') // or Multiaddr instance
+const value = await libp2p.fetch(peerDst, key)
+```

src/fetch/constants.js

@@ -0,0 +1,6 @@
+'use strict'
+
+module.exports = {
+  // https://github.com/libp2p/specs/tree/master/fetch#wire-protocol
+  PROTOCOL: '/libp2p/fetch/0.0.1'
+}

src/fetch/index.js

@@ -0,0 +1,159 @@
+'use strict'
+
+const debug = require('debug')
+const log = Object.assign(debug('libp2p:fetch'), {
+  error: debug('libp2p:fetch:err')
+})
+const errCode = require('err-code')
+const { codes } = require('../errors')
+const lp = require('it-length-prefixed')
+const { FetchRequest, FetchResponse } = require('./proto')
+// @ts-ignore it-handshake does not export types
+const handshake = require('it-handshake')
+const { PROTOCOL } = require('./constants')
+
+/**
+ * @typedef {import('../')} Libp2p
+ * @typedef {import('multiaddr').Multiaddr} Multiaddr
+ * @typedef {import('peer-id')} PeerId
+ * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
+ * @typedef {(key: string) => Promise<Uint8Array | null>} LookupFunction
+ */
+
+/**
+ * A simple libp2p protocol for requesting a value corresponding to a key from a peer.
+ * Developers can register one or more lookup function for retrieving the value corresponding to
+ * a given key.  Each lookup function must act on a distinct part of the overall key space, defined
+ * by a fixed prefix that all keys that should be routed to that lookup function will start with.
+ */
+class FetchProtocol {
+  /**
+   * @param {Libp2p} libp2p
+   */
+  constructor (libp2p) {
+    this._lookupFunctions = new Map() // Maps key prefix to value lookup function
+    this._libp2p = libp2p
+    this.handleMessage = this.handleMessage.bind(this)
+  }
+
+  /**
+   * Sends a request to fetch the value associated with the given key from the given peer.
+   *
+   * @param {PeerId|Multiaddr} peer
+   * @param {string} key
+   * @returns {Promise<Uint8Array | null>}
+   */
+  async fetch (peer, key) {
+    // @ts-ignore multiaddr might not have toB58String
+    log('dialing %s to %s', this._protocol, peer.toB58String ? peer.toB58String() : peer)
+
+    const connection = await this._libp2p.dial(peer)
+    const { stream } = await connection.newStream(FetchProtocol.PROTOCOL)
+    const shake = handshake(stream)
+
+    // send message
+    const request = new FetchRequest({ identifier: key })
+    shake.write(lp.encode.single(FetchRequest.encode(request).finish()))
+
+    // read response
+    const response = FetchResponse.decode((await lp.decode.fromReader(shake.reader).next()).value.slice())
+    switch (response.status) {
+      case (FetchResponse.StatusCode.OK): {
+        return response.data
+      }
+      case (FetchResponse.StatusCode.NOT_FOUND): {
+        return null
+      }
+      case (FetchResponse.StatusCode.ERROR): {
+        const errmsg = (new TextDecoder()).decode(response.data)
+        throw errCode(new Error('Error in fetch protocol response: ' + errmsg), codes.ERR_INVALID_PARAMETERS)
+      }
+      default: {
+        throw errCode(new Error('Unknown response status'), codes.ERR_INVALID_MESSAGE)
+      }
+    }
+  }
+
+  /**
+   * Invoked when a fetch request is received.  Reads the request message off the given stream and
+   * responds based on looking up the key in the request via the lookup callback that corresponds
+   * to the key's prefix.
+   *
+   * @param {object} options
+   * @param {MuxedStream} options.stream
+   * @param {string} options.protocol
+   */
+  async handleMessage (options) {
+    const { stream } = options
+    const shake = handshake(stream)
+    const request = FetchRequest.decode((await lp.decode.fromReader(shake.reader).next()).value.slice())
+
+    let response
+    const lookup = this._getLookupFunction(request.identifier)
+    if (lookup) {
+      const data = await lookup(request.identifier)
+      if (data) {
+        response = new FetchResponse({ status: FetchResponse.StatusCode.OK, data })
+      } else {
+        response = new FetchResponse({ status: FetchResponse.StatusCode.NOT_FOUND })
+      }
+    } else {
+      const errmsg = (new TextEncoder()).encode('No lookup function registered for key: ' + request.identifier)
+      response = new FetchResponse({ status: FetchResponse.StatusCode.ERROR, data: errmsg })
+    }
+
+    shake.write(lp.encode.single(FetchResponse.encode(response).finish()))
+  }
+
+  /**
+   * Given a key, finds the appropriate function for looking up its corresponding value, based on
+   * the key's prefix.
+   *
+   * @param {string} key
+   */
+  _getLookupFunction (key) {
+    for (const prefix of this._lookupFunctions.keys()) {
+      if (key.startsWith(prefix)) {
+        return this._lookupFunctions.get(prefix)
+      }
+    }
+    return null
+  }
+
+  /**
+   * Registers a new lookup callback that can map keys to values, for a given set of keys that
+   * share the same prefix.
+   *
+   * @param {string} prefix
+   * @param {LookupFunction} lookup
+   */
+  registerLookupFunction (prefix, lookup) {
+    if (this._lookupFunctions.has(prefix)) {
+      throw errCode(new Error("Fetch protocol handler for key prefix '" + prefix + "' already registered"), codes.ERR_KEY_ALREADY_EXISTS)
+    }
+    this._lookupFunctions.set(prefix, lookup)
+  }
+
+  /**
+   * Registers a new lookup callback that can map keys to values, for a given set of keys that
+   * share the same prefix.
+   *
+   * @param {string} prefix
+   * @param {LookupFunction} [lookup]
+   */
+  unregisterLookupFunction (prefix, lookup) {
+    if (lookup != null) {
+      const existingLookup = this._lookupFunctions.get(prefix)
+
+      if (existingLookup !== lookup) {
+        return
+      }
+    }
+
+    this._lookupFunctions.delete(prefix)
+  }
+}
+
+FetchProtocol.PROTOCOL = PROTOCOL
+
+exports = module.exports = FetchProtocol

src/fetch/proto.d.ts

@@ -0,0 +1,134 @@
+import * as $protobuf from "protobufjs";
+/** Properties of a FetchRequest. */
+export interface IFetchRequest {
+
+    /** FetchRequest identifier */
+    identifier?: (string|null);
+}
+
+/** Represents a FetchRequest. */
+export class FetchRequest implements IFetchRequest {
+
+    /**
+     * Constructs a new FetchRequest.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IFetchRequest);
+
+    /** FetchRequest identifier. */
+    public identifier: string;
+
+    /**
+     * Encodes the specified FetchRequest message. Does not implicitly {@link FetchRequest.verify|verify} messages.
+     * @param m FetchRequest message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IFetchRequest, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes a FetchRequest message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns FetchRequest
+     * @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): FetchRequest;
+
+    /**
+     * Creates a FetchRequest message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns FetchRequest
+     */
+    public static fromObject(d: { [k: string]: any }): FetchRequest;
+
+    /**
+     * Creates a plain object from a FetchRequest message. Also converts values to other types if specified.
+     * @param m FetchRequest
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: FetchRequest, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this FetchRequest to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+/** Properties of a FetchResponse. */
+export interface IFetchResponse {
+
+    /** FetchResponse status */
+    status?: (FetchResponse.StatusCode|null);
+
+    /** FetchResponse data */
+    data?: (Uint8Array|null);
+}
+
+/** Represents a FetchResponse. */
+export class FetchResponse implements IFetchResponse {
+
+    /**
+     * Constructs a new FetchResponse.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IFetchResponse);
+
+    /** FetchResponse status. */
+    public status: FetchResponse.StatusCode;
+
+    /** FetchResponse data. */
+    public data: Uint8Array;
+
+    /**
+     * Encodes the specified FetchResponse message. Does not implicitly {@link FetchResponse.verify|verify} messages.
+     * @param m FetchResponse message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IFetchResponse, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes a FetchResponse message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns FetchResponse
+     * @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): FetchResponse;
+
+    /**
+     * Creates a FetchResponse message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns FetchResponse
+     */
+    public static fromObject(d: { [k: string]: any }): FetchResponse;
+
+    /**
+     * Creates a plain object from a FetchResponse message. Also converts values to other types if specified.
+     * @param m FetchResponse
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: FetchResponse, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this FetchResponse to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+export namespace FetchResponse {
+
+    /** StatusCode enum. */
+    enum StatusCode {
+        OK = 0,
+        NOT_FOUND = 1,
+        ERROR = 2
+    }
+}

src/fetch/proto.js

@@ -0,0 +1,333 @@
+/*eslint-disable*/
+"use strict";
+
+var $protobuf = require("protobufjs/minimal");
+
+// Common aliases
+var $Reader = $protobuf.Reader, $Writer = $protobuf.Writer, $util = $protobuf.util;
+
+// Exported root namespace
+var $root = $protobuf.roots["libp2p-fetch"] || ($protobuf.roots["libp2p-fetch"] = {});
+
+$root.FetchRequest = (function() {
+
+    /**
+     * Properties of a FetchRequest.
+     * @exports IFetchRequest
+     * @interface IFetchRequest
+     * @property {string|null} [identifier] FetchRequest identifier
+     */
+
+    /**
+     * Constructs a new FetchRequest.
+     * @exports FetchRequest
+     * @classdesc Represents a FetchRequest.
+     * @implements IFetchRequest
+     * @constructor
+     * @param {IFetchRequest=} [p] Properties to set
+     */
+    function FetchRequest(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]];
+    }
+
+    /**
+     * FetchRequest identifier.
+     * @member {string} identifier
+     * @memberof FetchRequest
+     * @instance
+     */
+    FetchRequest.prototype.identifier = "";
+
+    /**
+     * Encodes the specified FetchRequest message. Does not implicitly {@link FetchRequest.verify|verify} messages.
+     * @function encode
+     * @memberof FetchRequest
+     * @static
+     * @param {IFetchRequest} m FetchRequest message or plain object to encode
+     * @param {$protobuf.Writer} [w] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    FetchRequest.encode = function encode(m, w) {
+        if (!w)
+            w = $Writer.create();
+        if (m.identifier != null && Object.hasOwnProperty.call(m, "identifier"))
+            w.uint32(10).string(m.identifier);
+        return w;
+    };
+
+    /**
+     * Decodes a FetchRequest message from the specified reader or buffer.
+     * @function decode
+     * @memberof FetchRequest
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+     * @param {number} [l] Message length if known beforehand
+     * @returns {FetchRequest} FetchRequest
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    FetchRequest.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.FetchRequest();
+        while (r.pos < c) {
+            var t = r.uint32();
+            switch (t >>> 3) {
+            case 1:
+                m.identifier = r.string();
+                break;
+            default:
+                r.skipType(t & 7);
+                break;
+            }
+        }
+        return m;
+    };
+
+    /**
+     * Creates a FetchRequest message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof FetchRequest
+     * @static
+     * @param {Object.<string,*>} d Plain object
+     * @returns {FetchRequest} FetchRequest
+     */
+    FetchRequest.fromObject = function fromObject(d) {
+        if (d instanceof $root.FetchRequest)
+            return d;
+        var m = new $root.FetchRequest();
+        if (d.identifier != null) {
+            m.identifier = String(d.identifier);
+        }
+        return m;
+    };
+
+    /**
+     * Creates a plain object from a FetchRequest message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof FetchRequest
+     * @static
+     * @param {FetchRequest} m FetchRequest
+     * @param {$protobuf.IConversionOptions} [o] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    FetchRequest.toObject = function toObject(m, o) {
+        if (!o)
+            o = {};
+        var d = {};
+        if (o.defaults) {
+            d.identifier = "";
+        }
+        if (m.identifier != null && m.hasOwnProperty("identifier")) {
+            d.identifier = m.identifier;
+        }
+        return d;
+    };
+
+    /**
+     * Converts this FetchRequest to JSON.
+     * @function toJSON
+     * @memberof FetchRequest
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    FetchRequest.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    return FetchRequest;
+})();
+
+$root.FetchResponse = (function() {
+
+    /**
+     * Properties of a FetchResponse.
+     * @exports IFetchResponse
+     * @interface IFetchResponse
+     * @property {FetchResponse.StatusCode|null} [status] FetchResponse status
+     * @property {Uint8Array|null} [data] FetchResponse data
+     */
+
+    /**
+     * Constructs a new FetchResponse.
+     * @exports FetchResponse
+     * @classdesc Represents a FetchResponse.
+     * @implements IFetchResponse
+     * @constructor
+     * @param {IFetchResponse=} [p] Properties to set
+     */
+    function FetchResponse(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]];
+    }
+
+    /**
+     * FetchResponse status.
+     * @member {FetchResponse.StatusCode} status
+     * @memberof FetchResponse
+     * @instance
+     */
+    FetchResponse.prototype.status = 0;
+
+    /**
+     * FetchResponse data.
+     * @member {Uint8Array} data
+     * @memberof FetchResponse
+     * @instance
+     */
+    FetchResponse.prototype.data = $util.newBuffer([]);
+
+    /**
+     * Encodes the specified FetchResponse message. Does not implicitly {@link FetchResponse.verify|verify} messages.
+     * @function encode
+     * @memberof FetchResponse
+     * @static
+     * @param {IFetchResponse} m FetchResponse message or plain object to encode
+     * @param {$protobuf.Writer} [w] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    FetchResponse.encode = function encode(m, w) {
+        if (!w)
+            w = $Writer.create();
+        if (m.status != null && Object.hasOwnProperty.call(m, "status"))
+            w.uint32(8).int32(m.status);
+        if (m.data != null && Object.hasOwnProperty.call(m, "data"))
+            w.uint32(18).bytes(m.data);
+        return w;
+    };
+
+    /**
+     * Decodes a FetchResponse message from the specified reader or buffer.
+     * @function decode
+     * @memberof FetchResponse
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+     * @param {number} [l] Message length if known beforehand
+     * @returns {FetchResponse} FetchResponse
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    FetchResponse.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.FetchResponse();
+        while (r.pos < c) {
+            var t = r.uint32();
+            switch (t >>> 3) {
+            case 1:
+                m.status = r.int32();
+                break;
+            case 2:
+                m.data = r.bytes();
+                break;
+            default:
+                r.skipType(t & 7);
+                break;
+            }
+        }
+        return m;
+    };
+
+    /**
+     * Creates a FetchResponse message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof FetchResponse
+     * @static
+     * @param {Object.<string,*>} d Plain object
+     * @returns {FetchResponse} FetchResponse
+     */
+    FetchResponse.fromObject = function fromObject(d) {
+        if (d instanceof $root.FetchResponse)
+            return d;
+        var m = new $root.FetchResponse();
+        switch (d.status) {
+        case "OK":
+        case 0:
+            m.status = 0;
+            break;
+        case "NOT_FOUND":
+        case 1:
+            m.status = 1;
+            break;
+        case "ERROR":
+        case 2:
+            m.status = 2;
+            break;
+        }
+        if (d.data != null) {
+            if (typeof d.data === "string")
+                $util.base64.decode(d.data, m.data = $util.newBuffer($util.base64.length(d.data)), 0);
+            else if (d.data.length)
+                m.data = d.data;
+        }
+        return m;
+    };
+
+    /**
+     * Creates a plain object from a FetchResponse message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof FetchResponse
+     * @static
+     * @param {FetchResponse} m FetchResponse
+     * @param {$protobuf.IConversionOptions} [o] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    FetchResponse.toObject = function toObject(m, o) {
+        if (!o)
+            o = {};
+        var d = {};
+        if (o.defaults) {
+            d.status = o.enums === String ? "OK" : 0;
+            if (o.bytes === String)
+                d.data = "";
+            else {
+                d.data = [];
+                if (o.bytes !== Array)
+                    d.data = $util.newBuffer(d.data);
+            }
+        }
+        if (m.status != null && m.hasOwnProperty("status")) {
+            d.status = o.enums === String ? $root.FetchResponse.StatusCode[m.status] : m.status;
+        }
+        if (m.data != null && m.hasOwnProperty("data")) {
+            d.data = o.bytes === String ? $util.base64.encode(m.data, 0, m.data.length) : o.bytes === Array ? Array.prototype.slice.call(m.data) : m.data;
+        }
+        return d;
+    };
+
+    /**
+     * Converts this FetchResponse to JSON.
+     * @function toJSON
+     * @memberof FetchResponse
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    FetchResponse.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    /**
+     * StatusCode enum.
+     * @name FetchResponse.StatusCode
+     * @enum {number}
+     * @property {number} OK=0 OK value
+     * @property {number} NOT_FOUND=1 NOT_FOUND value
+     * @property {number} ERROR=2 ERROR value
+     */
+    FetchResponse.StatusCode = (function() {
+        var valuesById = {}, values = Object.create(valuesById);
+        values[valuesById[0] = "OK"] = 0;
+        values[valuesById[1] = "NOT_FOUND"] = 1;
+        values[valuesById[2] = "ERROR"] = 2;
+        return values;
+    })();
+
+    return FetchResponse;
+})();
+
+module.exports = $root;

src/fetch/proto.proto

@@ -0,0 +1,15 @@
+syntax = "proto3";
+
+message FetchRequest {
+	string identifier = 1;
+}
+
+message FetchResponse {
+	StatusCode status = 1;
+	enum StatusCode {
+		OK = 0;
+		NOT_FOUND = 1;
+		ERROR = 2;
+	}
+	bytes data = 2;
+}

src/get-peer.js

@@ -32,7 +32,7 @@ function getPeer (peer) {
 
     try {
       peer = PeerId.createFromB58String(idStr)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       throw errCode(
         new Error(`${peer} is not a valid peer type`),
         codes.ERR_INVALID_MULTIADDR

src/identify/index.js

@@ -8,7 +8,7 @@ const errCode = require('err-code')
 const lp = require('it-length-prefixed')
 const { pipe } = require('it-pipe')
 const { collect, take, consume } = require('streaming-iterables')
-const uint8ArrayFromString = require('uint8arrays/from-string')
+const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
 
 const PeerId = require('peer-id')
 const { Multiaddr } = require('multiaddr')
@@ -77,8 +77,6 @@ class IdentifyService {
       ...libp2p._options.host
     }
 
-    this.peerStore.metadataBook.set(this.peerId, 'AgentVersion', uint8ArrayFromString(this._host.agentVersion))
-    this.peerStore.metadataBook.set(this.peerId, 'ProtocolVersion', uint8ArrayFromString(this._host.protocolVersion))
     // When a new connection happens, trigger identify
     this.connectionManager.on('peer:connect', (connection) => {
       this.identify(connection).catch(log.error)
@@ -87,18 +85,27 @@ class IdentifyService {
     // When self multiaddrs change, trigger identify-push
     this.peerStore.on('change:multiaddrs', ({ peerId }) => {
       if (peerId.toString() === this.peerId.toString()) {
-        this.pushToPeerStore()
+        this.pushToPeerStore().catch(err => log.error(err))
       }
     })
 
     // When self protocols change, trigger identify-push
     this.peerStore.on('change:protocols', ({ peerId }) => {
       if (peerId.toString() === this.peerId.toString()) {
-        this.pushToPeerStore()
+        this.pushToPeerStore().catch(err => log.error(err))
       }
     })
   }
 
+  async start () {
+    await this.peerStore.metadataBook.setValue(this.peerId, 'AgentVersion', uint8ArrayFromString(this._host.agentVersion))
+    await this.peerStore.metadataBook.setValue(this.peerId, 'ProtocolVersion', uint8ArrayFromString(this._host.protocolVersion))
+  }
+
+  async stop () {
+
+  }
+
   /**
    * Send an Identify Push update to the list of connections
    *
@@ -108,7 +115,7 @@ class IdentifyService {
   async push (connections) {
     const signedPeerRecord = await this.peerStore.addressBook.getRawEnvelope(this.peerId)
     const listenAddrs = this._libp2p.multiaddrs.map((ma) => ma.bytes)
-    const protocols = this.peerStore.protoBook.get(this.peerId) || []
+    const protocols = await this.peerStore.protoBook.get(this.peerId)
 
     const pushes = connections.map(async connection => {
       try {
@@ -124,7 +131,7 @@ class IdentifyService {
           stream,
           consume
         )
-      } catch (err) {
+      } catch (/** @type {any} */ err) {
         // Just log errors
         log.error('could not push identify update to peer', err)
       }
@@ -135,10 +142,8 @@ class IdentifyService {
 
   /**
    * Calls `push` for all peers in the `peerStore` that are connected
-   *
-   * @returns {void}
    */
-  pushToPeerStore () {
+  async pushToPeerStore () {
     // Do not try to push if libp2p node is not running
     if (!this._libp2p.isStarted()) {
       return
@@ -146,13 +151,13 @@ class IdentifyService {
 
     const connections = []
     let connection
-    for (const peer of this.peerStore.peers.values()) {
+    for await (const peer of this.peerStore.getPeers()) {
       if (peer.protocols.includes(this.identifyPushProtocolStr) && (connection = this.connectionManager.get(peer.id))) {
         connections.push(connection)
       }
     }
 
-    this.push(connections)
+    await this.push(connections)
   }
 
   /**
@@ -182,7 +187,7 @@ class IdentifyService {
     let message
     try {
       message = Message.Identify.decode(data)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       throw errCode(err, codes.ERR_INVALID_MESSAGE)
     }
 
@@ -205,26 +210,26 @@ class IdentifyService {
 
     try {
       const envelope = await Envelope.openAndCertify(signedPeerRecord, PeerRecord.DOMAIN)
-      if (this.peerStore.addressBook.consumePeerRecord(envelope)) {
-        this.peerStore.protoBook.set(id, protocols)
-        this.peerStore.metadataBook.set(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
-        this.peerStore.metadataBook.set(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
+      if (await this.peerStore.addressBook.consumePeerRecord(envelope)) {
+        await this.peerStore.protoBook.set(id, protocols)
+        await this.peerStore.metadataBook.setValue(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
+        await this.peerStore.metadataBook.setValue(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
         return
       }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       log('received invalid envelope, discard it and fallback to listenAddrs is available', err)
     }
 
     // LEGACY: Update peers data in PeerStore
     try {
-      this.peerStore.addressBook.set(id, listenAddrs.map((addr) => new Multiaddr(addr)))
-    } catch (err) {
+      await this.peerStore.addressBook.set(id, listenAddrs.map((addr) => new Multiaddr(addr)))
+    } catch (/** @type {any} */ err) {
       log.error('received invalid addrs', err)
     }
 
-    this.peerStore.protoBook.set(id, protocols)
-    this.peerStore.metadataBook.set(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
-    this.peerStore.metadataBook.set(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
+    await this.peerStore.protoBook.set(id, protocols)
+    await this.peerStore.metadataBook.setValue(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
+    await this.peerStore.metadataBook.setValue(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
 
     // TODO: Add and score our observed addr
     log('received observed address of %s', cleanObservedAddr)
@@ -262,32 +267,32 @@ class IdentifyService {
    * @returns {Promise<void>}
    */
   async _handleIdentify ({ connection, stream }) {
-    let publicKey = new Uint8Array(0)
-    if (this.peerId.pubKey) {
-      publicKey = this.peerId.pubKey.bytes
-    }
-
-    const signedPeerRecord = await this.peerStore.addressBook.getRawEnvelope(this.peerId)
-    const protocols = this.peerStore.protoBook.get(this.peerId) || []
-
-    const message = Message.Identify.encode({
-      protocolVersion: this._host.protocolVersion,
-      agentVersion: this._host.agentVersion,
-      publicKey,
-      listenAddrs: this._libp2p.multiaddrs.map((ma) => ma.bytes),
-      signedPeerRecord,
-      observedAddr: connection.remoteAddr.bytes,
-      protocols
-    }).finish()
-
     try {
+      let publicKey = new Uint8Array(0)
+      if (this.peerId.pubKey) {
+        publicKey = this.peerId.pubKey.bytes
+      }
+
+      const signedPeerRecord = await this.peerStore.addressBook.getRawEnvelope(this.peerId)
+      const protocols = await this.peerStore.protoBook.get(this.peerId)
+
+      const message = Message.Identify.encode({
+        protocolVersion: this._host.protocolVersion,
+        agentVersion: this._host.agentVersion,
+        publicKey,
+        listenAddrs: this._libp2p.multiaddrs.map((ma) => ma.bytes),
+        signedPeerRecord,
+        observedAddr: connection.remoteAddr.bytes,
+        protocols
+      }).finish()
+
       await pipe(
         [message],
         lp.encode(),
         stream,
         consume
       )
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       log.error('could not respond to identify request', err)
     }
   }
@@ -313,7 +318,7 @@ class IdentifyService {
         collect
       )
       message = Message.Identify.decode(data)
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       return log.error('received invalid message', err)
     }
 
@@ -321,24 +326,28 @@ class IdentifyService {
 
     try {
       const envelope = await Envelope.openAndCertify(message.signedPeerRecord, PeerRecord.DOMAIN)
-      if (this.peerStore.addressBook.consumePeerRecord(envelope)) {
-        this.peerStore.protoBook.set(id, message.protocols)
+      if (await this.peerStore.addressBook.consumePeerRecord(envelope)) {
+        await this.peerStore.protoBook.set(id, message.protocols)
         return
       }
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       log('received invalid envelope, discard it and fallback to listenAddrs is available', err)
     }
 
     // LEGACY: Update peers data in PeerStore
     try {
-      this.peerStore.addressBook.set(id,
+      await this.peerStore.addressBook.set(id,
         message.listenAddrs.map((addr) => new Multiaddr(addr)))
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       log.error('received invalid addrs', err)
     }
 
     // Update the protocols
-    this.peerStore.protoBook.set(id, message.protocols)
+    try {
+      await this.peerStore.protoBook.set(id, message.protocols)
+    } catch (/** @type {any} */ err) {
+      log.error('received invalid protocols', err)
+    }
   }
 
   /**

src/index.js

@@ -9,7 +9,7 @@ const { EventEmitter } = require('events')
 const errCode = require('err-code')
 const PeerId = require('peer-id')
 const { Multiaddr } = require('multiaddr')
-
+const { MemoryDatastore } = require('datastore-core/memory')
 const PeerRouting = require('./peer-routing')
 const ContentRouting = require('./content-routing')
 const getPeer = require('./get-peer')
@@ -18,6 +18,7 @@ const { codes, messages } = require('./errors')
 
 const AddressManager = require('./address-manager')
 const ConnectionManager = require('./connection-manager')
+const AutoDialler = require('./connection-manager/auto-dialler')
 const Circuit = require('./circuit/transport')
 const Relay = require('./circuit')
 const Dialer = require('./dialer')
@@ -27,10 +28,10 @@ const TransportManager = require('./transport-manager')
 const Upgrader = require('./upgrader')
 const PeerStore = require('./peer-store')
 const PubsubAdapter = require('./pubsub-adapter')
-const PersistentPeerStore = require('./peer-store/persistent')
 const Registrar = require('./registrar')
 const ping = require('./ping')
 const IdentifyService = require('./identify')
+const FetchService = require('./fetch')
 const NatManager = require('./nat-manager')
 const { updateSelfPeerRecord } = require('./record/utils')
 
@@ -47,6 +48,9 @@ const { updateSelfPeerRecord } = require('./record/utils')
  * @typedef {import('libp2p-interfaces/src/pubsub').PubsubOptions} PubsubOptions
  * @typedef {import('interface-datastore').Datastore} Datastore
  * @typedef {import('./pnet')} Protector
+ * @typedef {import('./types').ConnectionGater} ConnectionGater
+ * @typedef {Object} PersistentPeerStoreOptions
+ * @property {number} [threshold]
  */
 
 /**
@@ -55,16 +59,9 @@ const { updateSelfPeerRecord } = require('./record/utils')
  * @property {MuxedStream} stream
  * @property {string} protocol
  *
- * @typedef {Object} RandomWalkOptions
- * @property {boolean} [enabled = false]
- * @property {number} [queriesPerPeriod = 1]
- * @property {number} [interval = 300e3]
- * @property {number} [timeout = 10e3]
- *
  * @typedef {Object} DhtOptions
  * @property {boolean} [enabled = false]
  * @property {number} [kBucketSize = 20]
- * @property {RandomWalkOptions} [randomWalk]
  * @property {boolean} [clientMode]
  * @property {import('libp2p-interfaces/src/types').DhtSelectors} [selectors]
  * @property {import('libp2p-interfaces/src/types').DhtValidators} [validators]
@@ -110,13 +107,14 @@ const { updateSelfPeerRecord } = require('./record/utils')
  * @property {Libp2pModules} modules libp2p modules to use
  * @property {import('./address-manager').AddressManagerOptions} [addresses]
  * @property {import('./connection-manager').ConnectionManagerOptions} [connectionManager]
+ * @property {Partial<import('./types').ConnectionGater>} [connectionGater]
  * @property {Datastore} [datastore]
  * @property {import('./dialer').DialerOptions} [dialer]
  * @property {import('./identify/index').HostProperties} [host] libp2p host
  * @property {KeychainOptions & import('./keychain/index').KeychainOptions} [keychain]
  * @property {MetricsOptions & import('./metrics').MetricsOptions} [metrics]
  * @property {import('./peer-routing').PeerRoutingOptions} [peerRouting]
- * @property {PeerStoreOptions & import('./peer-store/persistent').PersistentPeerStoreOptions} [peerStore]
+ * @property {PeerStoreOptions} [peerStore]
  * @property {import('./transport-manager').TransportManagerOptions} [transportManager]
  * @property {Libp2pConfig} [config]
  *
@@ -167,13 +165,35 @@ class Libp2p extends EventEmitter {
     this.peerId = this._options.peerId
     this.datastore = this._options.datastore
 
-    this.peerStore = (this.datastore && this._options.peerStore.persistence)
-      ? new PersistentPeerStore({
-        peerId: this.peerId,
-        datastore: this.datastore,
-        ...this._options.peerStore
+    // Create Metrics
+    if (this._options.metrics.enabled) {
+      const metrics = new Metrics({
+        ...this._options.metrics
       })
-      : new PeerStore({ peerId: this.peerId })
+
+      this.metrics = metrics
+    }
+
+    /** @type {ConnectionGater} */
+    this.connectionGater = {
+      denyDialPeer: async () => Promise.resolve(false),
+      denyDialMultiaddr: async () => Promise.resolve(false),
+      denyInboundConnection: async () => Promise.resolve(false),
+      denyOutboundConnection: async () => Promise.resolve(false),
+      denyInboundEncryptedConnection: async () => Promise.resolve(false),
+      denyOutboundEncryptedConnection: async () => Promise.resolve(false),
+      denyInboundUpgradedConnection: async () => Promise.resolve(false),
+      denyOutboundUpgradedConnection: async () => Promise.resolve(false),
+      filterMultiaddrForPeer: async () => Promise.resolve(true),
+      ...this._options.connectionGater
+    }
+
+    /** @type {import('./peer-store/types').PeerStore} */
+    this.peerStore = new PeerStore({
+      peerId: this.peerId,
+      datastore: (this.datastore && this._options.peerStore.persistence) ? this.datastore : new MemoryDatastore(),
+      addressFilter: this.connectionGater.filterMultiaddrForPeer
+    })
 
     // Addresses {listen, announce, noAnnounce}
     this.addresses = this._options.addresses
@@ -193,17 +213,13 @@ class Libp2p extends EventEmitter {
 
     // Create the Connection Manager
     this.connectionManager = new ConnectionManager(this, {
-      autoDial: this._config.peerDiscovery.autoDial,
       ...this._options.connectionManager
     })
-
-    // Create Metrics
-    if (this._options.metrics.enabled) {
-      this.metrics = new Metrics({
-        ...this._options.metrics,
-        connectionManager: this.connectionManager
-      })
-    }
+    this._autodialler = new AutoDialler(this, {
+      enabled: this._config.peerDiscovery.autoDial,
+      minConnections: this._options.connectionManager.minConnections,
+      autoDialInterval: this._options.connectionManager.autoDialInterval
+    })
 
     // Create keychain
     if (this._options.keychain && this._options.keychain.datastore) {
@@ -221,6 +237,7 @@ class Libp2p extends EventEmitter {
 
     // Setup the Upgrader
     this.upgrader = new Upgrader({
+      connectionGater: this.connectionGater,
       localPeer: this.peerId,
       metrics: this.metrics,
       onConnection: (connection) => this.connectionManager.onConnect(connection),
@@ -263,7 +280,9 @@ class Libp2p extends EventEmitter {
 
     this.dialer = new Dialer({
       transportManager: this.transportManager,
+      connectionGater: this.connectionGater,
       peerStore: this.peerStore,
+      metrics: this.metrics,
       ...this._options.dialer
     })
 
@@ -288,7 +307,6 @@ class Libp2p extends EventEmitter {
 
       // Add the identify service since we can multiplex
       this.identifyService = new IdentifyService({ libp2p: this })
-      this.handle(Object.values(IdentifyService.getProtocolStr(this)), this.identifyService.handleMessage)
     }
 
     // Attach private network protector
@@ -301,14 +319,9 @@ class Libp2p extends EventEmitter {
     // dht provided components (peerRouting, contentRouting, dht)
     if (this._modules.dht) {
       const DHT = this._modules.dht
-      // @ts-ignore Object is not constructable
-      this._dht = new DHT({
+      // @ts-ignore TODO: types need fixing - DHT is an `object` which has no `create` method
+      this._dht = DHT.create({
         libp2p: this,
-        dialer: this.dialer,
-        peerId: this.peerId,
-        peerStore: this.peerStore,
-        registrar: this.registrar,
-        datastore: this.datastore,
         ...this._config.dht
       })
     }
@@ -330,6 +343,8 @@ class Libp2p extends EventEmitter {
     ping.mount(this)
 
     this._onDiscoveryPeer = this._onDiscoveryPeer.bind(this)
+
+    this.fetchService = new FetchService(this)
   }
 
   /**
@@ -359,11 +374,19 @@ class Libp2p extends EventEmitter {
   async start () {
     log('libp2p is starting')
 
+    if (this.identifyService) {
+      await this.handle(Object.values(IdentifyService.getProtocolStr(this)), this.identifyService.handleMessage)
+    }
+
+    if (this.fetchService) {
+      await this.handle(FetchService.PROTOCOL, this.fetchService.handleMessage)
+    }
+
     try {
       await this._onStarting()
       await this._onDidStart()
       log('libp2p has started')
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       this.emit('error', err)
       log.error('An error occurred starting libp2p', err)
       await this.stop()
@@ -383,8 +406,14 @@ class Libp2p extends EventEmitter {
     try {
       this._isStarted = false
 
+      if (this.identifyService) {
+        await this.identifyService.stop()
+      }
+
       this.relay && this.relay.stop()
       this.peerRouting.stop()
+      await this._autodialler.stop()
+      await (this._dht && this._dht.stop())
 
       for (const service of this._discovery.values()) {
         service.removeListener('peer', this._onDiscoveryPeer)
@@ -394,21 +423,21 @@ class Libp2p extends EventEmitter {
 
       this._discovery = new Map()
 
-      await this.peerStore.stop()
       await this.connectionManager.stop()
 
       await Promise.all([
         this.pubsub && this.pubsub.stop(),
-        this._dht && this._dht.stop(),
         this.metrics && this.metrics.stop()
       ])
 
       await this.natManager.stop()
       await this.transportManager.close()
 
+      this.unhandle(FetchService.PROTOCOL)
+
       ping.unmount(this)
       this.dialer.destroy()
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       if (err) {
         log.error(err)
         this.emit('error', err)
@@ -431,7 +460,7 @@ class Libp2p extends EventEmitter {
 
     try {
       await this.keychain.findKeyByName('self')
-    } catch (err) {
+    } catch (/** @type {any} */ err) {
       await this.keychain.importPeer('self', this.peerId)
     }
   }
@@ -501,7 +530,7 @@ class Libp2p extends EventEmitter {
     if (!connection) {
       connection = await this.dialer.connectToPeer(peer, options)
     } else if (multiaddrs) {
-      this.peerStore.addressBook.add(id, multiaddrs)
+      await this.peerStore.addressBook.add(id, multiaddrs)
     }
 
     return connection
@@ -558,6 +587,17 @@ class Libp2p extends EventEmitter {
     )
   }
 
+  /**
+   * Sends a request to fetch the value associated with the given key from the given peer.
+   *
+   * @param {PeerId|Multiaddr} peer
+   * @param {string} key
+   * @returns {Promise<Uint8Array | null>}
+   */
+  fetch (peer, key) {
+    return this.fetchService.fetch(peer, key)
+  }
+
   /**
    * Pings the given peer in order to obtain the operation latency.
    *
@@ -581,14 +621,14 @@ class Libp2p extends EventEmitter {
    * @param {string[]|string} protocols
    * @param {(props: HandlerProps) => void} handler
    */
-  handle (protocols, handler) {
+  async handle (protocols, handler) {
     protocols = Array.isArray(protocols) ? protocols : [protocols]
     protocols.forEach(protocol => {
       this.upgrader.protocols.set(protocol, handler)
     })
 
     // Add new protocols to self protocols in the Protobook
-    this.peerStore.protoBook.add(this.peerId, protocols)
+    await this.peerStore.protoBook.add(this.peerId, protocols)
   }
 
   /**
@@ -597,14 +637,14 @@ class Libp2p extends EventEmitter {
    *
    * @param {string[]|string} protocols
    */
-  unhandle (protocols) {
+  async unhandle (protocols) {
     protocols = Array.isArray(protocols) ? protocols : [protocols]
     protocols.forEach(protocol => {
       this.upgrader.protocols.delete(protocol)
     })
 
     // Remove protocols from self protocols in the Protobook
-    this.peerStore.protoBook.remove(this.peerId, protocols)
+    await this.peerStore.protoBook.remove(this.peerId, protocols)
   }
 
   async _onStarting () {
@@ -615,16 +655,13 @@ class Libp2p extends EventEmitter {
     // Manage your NATs
     this.natManager.start()
 
-    // Start PeerStore
-    await this.peerStore.start()
-
     if (this._config.pubsub.enabled) {
-      this.pubsub && this.pubsub.start()
+      this.pubsub && await this.pubsub.start()
     }
 
     // DHT subsystem
     if (this._config.dht.enabled) {
-      this._dht && this._dht.start()
+      this._dht && await this._dht.start()
 
       // TODO: this should be modified once random-walk is used as
       // the other discovery modules
@@ -633,6 +670,10 @@ class Libp2p extends EventEmitter {
 
     // Start metrics if present
     this.metrics && this.metrics.start()
+
+    if (this.identifyService) {
+      await this.identifyService.start()
+    }
   }
 
   /**
@@ -645,16 +686,19 @@ class Libp2p extends EventEmitter {
 
     this.peerStore.on('peer', peerId => {
       this.emit('peer:discovery', peerId)
-      this._maybeConnect(peerId)
+      this._maybeConnect(peerId).catch(err => {
+        log.error(err)
+      })
     })
 
     // Once we start, emit any peers we may have already discovered
     // TODO: this should be removed, as we already discovered these peers in the past
-    for (const peer of this.peerStore.peers.values()) {
+    for await (const peer of this.peerStore.getPeers()) {
       this.emit('peer:discovery', peer.id)
     }
 
     this.connectionManager.start()
+    await this._autodialler.start()
 
     // Peer discovery
     await this._setupPeerDiscovery()
@@ -678,8 +722,8 @@ class Libp2p extends EventEmitter {
       return
     }
 
-    peer.multiaddrs && this.peerStore.addressBook.add(peer.id, peer.multiaddrs)
-    peer.protocols && this.peerStore.protoBook.set(peer.id, peer.protocols)
+    peer.multiaddrs && this.peerStore.addressBook.add(peer.id, peer.multiaddrs).catch(err => log.error(err))
+    peer.protocols && this.peerStore.protoBook.set(peer.id, peer.protocols).catch(err => log.error(err))
   }
 
   /**
@@ -698,7 +742,7 @@ class Libp2p extends EventEmitter {
         log('connecting to discovered peer %s', peerId.toB58String())
         try {
           await this.dialer.connectToPeer(peerId)
-        } catch (err) {
+        } catch (/** @type {any} */ err) {
           log.error(`could not connect to discovered peer ${peerId.toB58String()} with ${err}`)
         }
       }