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>

.github/workflows/examples.yml

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

.github/workflows/main.yml

@@ -8,23 +8,37 @@ 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: 16
+        node-version: lts/*
-    - run: npm install
+    - uses: ipfs/aegir/actions/cache-node-modules@master
     - run: npx aegir lint
-    - run: npx aegir build
     - run: npx aegir dep-check
-    - uses: ipfs/aegir/actions/bundle-size@v32.1.0
+    - uses: ipfs/aegir/actions/bundle-size@master
       name: size
       with:
         github_token: ${{ secrets.GITHUB_TOKEN }}
+
   test-node:
-    needs: check
+    needs: build
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
@@ -36,46 +50,121 @@ jobs:
       - uses: actions/setup-node@v2
         with:
           node-version: ${{ matrix.node }}
-      - run: npm install
+      - uses: ipfs/aegir/actions/cache-node-modules@master
-      - run: npx aegir test -t node --cov --bail
+      - run: npm run test:node -- --cov --bail
-      - uses: codecov/codecov-action@v1
+      - 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
       - uses: actions/setup-node@v2
         with:
           node-version: lts/*
-      - run: npm install
+      - uses: ipfs/aegir/actions/cache-node-modules@master
-      - run: npx aegir test -t browser -t webworker --bail
+      - 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
       - uses: actions/setup-node@v2
         with:
           node-version: lts/*
-      - run: npm install
+      - uses: ipfs/aegir/actions/cache-node-modules@master
-      - run: npx aegir test -t browser -t webworker --bail -- --browser firefox
+      - 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
       - uses: actions/setup-node@v2
         with:
           node-version: lts/*
-      - run: npm install
+      - 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
       - uses: actions/setup-node@v2
         with:
           node-version: lts/*
-      - run: npm install
+      - 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,124 @@
+## [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)
 
 
@@ -1668,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/npm-%3E%3D7.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/Node.js-%3E%3D15.0.0-orange.svg?style=flat-square" /></a>
   <br>
 </p>
 

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

doc/CONFIGURATION.md

@@ -23,6 +23,9 @@
     - [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)
@@ -497,9 +500,9 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
-const LevelStore = require('datastore-level')
+const { LevelDatastore } = require('datastore-level')
 
-const datastore = new LevelStore('path/to/store')
+const datastore = new LevelDatastore('path/to/store')
 await datastore.open()
 
 const node = await Libp2p.create({
@@ -590,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')
@@ -672,18 +796,18 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
-const LevelStore = require('datastore-level')
+const LevelDatastore = require('datastore-level')
 
-const datastore = new LevelStore('path/to/store')
+const datastore = new LevelDatastore('path/to/store')
-const dsInstant = await datastore.open()
+await datastore.open() // level database must be ready before node boot
 
 const node = await Libp2p.create({
+  datastore, // pass the opened datastore
   modules: {
     transport: [TCP],
     streamMuxer: [MPLEX],
     connEncryption: [NOISE]
   },
-  datastore: dsInstant,
   peerStore: {
     persistence: true,
     threshold: 5
@@ -806,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-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/src/core/runtime/libp2p-browser.js) - libp2p configuration used by js-ipfs when running in a Browser (that supports WebRTC)
+- [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.
 

examples/connection-encryption/1.js

@@ -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/test.js

@@ -1,30 +1,14 @@
 'use strict'
 
 const path = require('path')
-const execa = require('execa')
+const { waitForOutput } = require('../utils')
-const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test () {
-  const messageReceived = pDefer()
   process.stdout.write('1.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
+  await waitForOutput('This information is sent out encrypted to the other peer', 'node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
+    cwd: __dirname
-    all: true
   })
-
-  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",
+    "@chainsafe/libp2p-noise": "^5.0.2",
-    "libp2p": "github:libp2p/js-libp2p#master",
+    "ipfs-core": "^0.13.0",
-    "libp2p-delegated-content-routing": "~0.2.2",
+    "libp2p": "../../",
-    "libp2p-delegated-peer-routing": "~0.2.2",
+    "libp2p-delegated-content-routing": "^0.11.0",
-    "libp2p-kad-dht": "^0.26.5",
+    "libp2p-delegated-peer-routing": "^0.11.1",
-    "libp2p-mplex": "~0.8.5",
+    "libp2p-kad-dht": "^0.28.6",
-    "libp2p-secio": "~0.11.1",
+    "libp2p-mplex": "^0.10.4",
-    "libp2p-webrtc-star": "~0.15.8",
+    "libp2p-webrtc-star": "^0.25.0",
-    "libp2p-websocket-star": "~0.10.2",
+    "libp2p-websocket-star": "^0.10.2",
-    "libp2p-websockets": "~0.12.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/3.js

@@ -5,7 +5,7 @@ const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
 const { NOISE } = require('@chainsafe/libp2p-noise')
-const Gossipsub = require('libp2p-gossipsub')
+const Gossipsub = require('@achingbrain/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 { waitForOutput } = require('../utils')
-const pWaitFor = require('p-wait-for')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
-const bootstrapers = require('./bootstrapers')
-
-const discoveredCopy = 'Discovered:'
-const connectedCopy = 'Connection established to:'
 
 async function test () {
-  const discoveredNodes = []
-  const connectedNodes = []
-
   process.stdout.write('1.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
+  await waitForOutput('Connection established to:', 'node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
+    cwd: __dirname
-    all: true
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-    const line = uint8ArrayToString(data)
-
-    // Discovered or Connected
-    if (line.includes(discoveredCopy)) {
-      const id = line.trim().split(discoveredCopy)[1]
-      discoveredNodes.push(id)
-    } else if (line.includes(connectedCopy)) {
-      const id = line.trim().split(connectedCopy)[1]
-      connectedNodes.push(id)
-    }
-  })
-
-  await pWaitFor(() => discoveredNodes.length === bootstrapers.length && connectedNodes.length === bootstrapers.length)
-
-  proc.kill()
 }
 
 module.exports = test

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/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",
-    "@chainsafe/libp2p-noise": "^4.1.0",
+    "libp2p-webrtc-star": "^0.25.0",
-    "libp2p-webrtc-star": "^0.23.0",
     "libp2p-websockets": "^0.16.1"
   },
   "devDependencies": {

examples/package.json

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

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

@@ -38,8 +38,8 @@ const createNode = async () => {
     createNode()
   ])
 
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
 
   await Promise.all([
     node1.dial(node2.peerId),

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

@@ -40,8 +40,8 @@ const createNode = async () => {
     createNode()
   ])
 
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-  node2.peerStore.addressBook.set(node3.peerId, node3.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)
+await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-node2.peerStore.addressBook.set(node3.peerId, node3.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 { waitForOutput } = require('../utils')
-const pWaitFor = require('p-wait-for')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
-async function test() {
+async function test () {
   process.stdout.write('1.js\n')
 
-  const addrs = []
+  await waitForOutput('Found it, multiaddrs are:', 'node', [path.join(__dirname, '1.js')], {
-  let foundIt = false
+    cwd: __dirname
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
-    all: true
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-
-    const line = uint8ArrayToString(data)
-
-    // Discovered 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 { waitForOutput } = require('../utils')
-const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
-const providedCopy = 'is providing'
+async function test () {
-const foundCopy = 'Found provider:'
-
-async function test() {
   process.stdout.write('2.js\n')
-  const providedDefer = pDefer()
-  const foundDefer = pDefer()
 
-  const proc = execa('node', [path.join(__dirname, '2.js')], {
+  await waitForOutput('Found provider:', 'node', [path.join(__dirname, '2.js')], {
-    cwd: path.resolve(__dirname),
+    cwd: __dirname
-    all: true
   })
-
-  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/test.js

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

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

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

@@ -32,7 +32,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)
 
   node1.handle('/node-1', ({ stream }) => {
     pipe(

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 { waitForOutput } = require('../utils')
-const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
-async function test() {
+async function test () {
-  const messageDefer = pDefer()
   process.stdout.write('1.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
+  await waitForOutput('my own protocol, wow!', 'node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
+    cwd: __dirname
-    all: true
   })
-
-  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 { waitForOutput } = require('../utils')
-const pWaitFor = require('p-wait-for')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
-const messages = [
+async function test () {
-  'protocol (a)',
-  'protocol (b)',
-  'another stream on protocol (b)'
-]
-
-async function test() {
   process.stdout.write('2.js\n')
 
-  let count = 0
+  await waitForOutput('another stream on protocol (b)', 'node', [path.join(__dirname, '2.js')], {
-  const proc = execa('node', [path.join(__dirname, '2.js')], {
+    cwd: __dirname
-    cwd: path.resolve(__dirname),
-    all: true
   })
-
-  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 { waitForOutput } = require('../utils')
-const pWaitFor = require('p-wait-for')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
-const messages = [
+async function test () {
-  'from 1 to 2',
-  'from 2 to 1'
-]
-
-async function test() {
   process.stdout.write('3.js\n')
 
-  let count = 0
+  await waitForOutput('from 2 to 1', 'node', [path.join(__dirname, '3.js')], {
-  const proc = execa('node', [path.join(__dirname, '3.js')], {
+    cwd: __dirname
-    cwd: path.resolve(__dirname),
-    all: true
   })
-
-  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

@@ -5,7 +5,7 @@ const Libp2p = require('../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
 const { NOISE } = require('@chainsafe/libp2p-noise')
-const Gossipsub = require('libp2p-gossipsub')
+const Gossipsub = require('@achingbrain/libp2p-gossipsub')
 const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
 const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
@@ -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

@@ -5,7 +5,7 @@ const Libp2p = require('../../../')
 const TCP = require('libp2p-tcp')
 const Mplex = require('libp2p-mplex')
 const { NOISE } = require('@chainsafe/libp2p-noise')
-const Gossipsub = require('libp2p-gossipsub')
+const Gossipsub = require('@achingbrain/libp2p-gossipsub')
 const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
 const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
@@ -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/transports/2.js

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

@@ -60,9 +60,9 @@ function print ({ stream }) {
   node2.handle('/print', print)
   node3.handle('/print', print)
 
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
-  node3.peerStore.addressBook.set(node1.peerId, node1.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/README.md

@@ -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)
+await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
-node3.peerStore.addressBook.set(node1.peerId, node1.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 { waitForOutput } = require('../utils')
-const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test () {
-  const deferStarted = pDefer()
-  const deferListen = pDefer()
-
   process.stdout.write('1.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '1.js')], {
+  await waitForOutput('/p2p/', 'node', [path.join(__dirname, '1.js')], {
-    cwd: path.resolve(__dirname),
+    cwd: __dirname
-    all: true
   })
-
-  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 { waitForOutput } = require('../utils')
-const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test () {
-  const defer = pDefer()
   process.stdout.write('2.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '2.js')], {
+  await waitForOutput('Hello p2p world!', 'node', [path.join(__dirname, '2.js')], {
-    cwd: path.resolve(__dirname),
+    cwd: __dirname
-    all: true
   })
-
-  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 { waitForOutput } = require('../utils')
-const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 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')], {
+  await waitForOutput('node 3 failed to dial to node 1 with:', 'node', [path.join(__dirname, '3.js')], {
-    cwd: path.resolve(__dirname),
+    cwd: __dirname
-    all: true
   })
-
-  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 { waitForOutput } = require('../utils')
-const pDefer = require('p-defer')
-const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 
 async function test () {
-  const deferNode1 = pDefer()
-
   process.stdout.write('4.js\n')
 
-  const proc = execa('node', [path.join(__dirname, '4.js')], {
+  await waitForOutput('node 2 dialed to node 1 successfully', 'node', [path.join(__dirname, '4.js')], {
-    cwd: path.resolve(__dirname),
+    cwd: __dirname
-    all: true
   })
-
-  proc.all.on('data', async (data) => {
-    process.stdout.write(data)
-    const line = uint8ArrayToString(data)
-
-    if (line.includes('node 2 dialed to node 1 successfully')) {
-      deferNode1.resolve()
-    }
-  })
-
-  await Promise.all([
-    deferNode1.promise,
-  ])
-  proc.kill()
 }
 
 module.exports = test

examples/utils.js

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

examples/webrtc-direct/listener.js

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

@@ -12,6 +12,7 @@
   "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",
@@ -19,10 +20,10 @@
     "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",
-    "@chainsafe/libp2p-noise": "^4.1.0",
     "libp2p-webrtc-direct": "^0.7.0",
     "peer-id": "^0.16.0"
   },

package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "0.35.1",
+  "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: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:proto-book": "pbjs -t static-module -w commonjs -r libp2p-proto-book --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/peer-store/persistent/pb/proto-book.js ./src/peer-store/persistent/pb/proto-book.proto",
     "build:proto:peer-record": "pbjs -t static-module -w commonjs -r libp2p-peer-record --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/record/peer-record/peer-record.js ./src/record/peer-record/peer-record.proto",
     "build:proto:envelope": "pbjs -t static-module -w commonjs -r libp2p-envelope --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/record/envelope/envelope.js ./src/record/envelope/envelope.proto",
-    "build:proto-types": "npm run build:proto-types:circuit && npm run build:proto-types:identify && npm run build:proto-types:plaintext && npm run build:proto-types:address-book && npm run build:proto-types:proto-book && npm run build:proto-types:peer-record && npm run build:proto-types:envelope",
+    "build:proto-types": "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:peer": "pbts -o src/peer-store/pb/peer.d.ts src/peer-store/pb/peer.js",
-    "build:proto-types:proto-book": "pbts -o src/peer-store/persistent/pb/proto-book.d.ts src/peer-store/persistent/pb/proto-book.js",
     "build:proto-types:peer-record": "pbts -o src/record/peer-record/peer-record.d.ts src/record/peer-record/peer-record.js",
     "build:proto-types:envelope": "pbts -o src/record/envelope/envelope.d.ts src/record/envelope/envelope.js",
     "test": "aegir test",
@@ -42,10 +42,7 @@
     "test:browser": "aegir test -t browser",
     "test:examples": "cd examples && npm run test:all",
     "test:interop": "LIBP2P_JS=$PWD npx aegir test -t node -f ./node_modules/libp2p-interop/test/*",
-    "prepare": "aegir build --no-bundle",
+    "prepare": "npm run build",
-    "release": "aegir release -t node -t browser",
-    "release-minor": "aegir release --type minor -t node -t browser",
-    "release-major": "aegir release --type major -t node -t browser",
     "coverage": "nyc --reporter=text --reporter=lcov npm run test:node"
   },
   "repository": {
@@ -69,7 +66,7 @@
     "node": ">=15.0.0"
   },
   "browser": {
-    "@motrix/nat-api": false
+    "nat-api": false
   },
   "eslintConfig": {
     "extends": "ipfs",
@@ -80,14 +77,13 @@
     ]
   },
   "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": "^7.0.0",
@@ -99,22 +95,26 @@
     "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.21.0",
+    "libp2p-crypto": "^0.21.2",
-    "libp2p-interfaces": "^2.0.1",
+    "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",
@@ -126,22 +126,21 @@
     "sanitize-filename": "^1.6.3",
     "set-delayed-interval": "^1.0.0",
     "streaming-iterables": "^6.0.0",
-    "timeout-abort-controller": "^2.0.0",
+    "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": "^4.0.0",
+    "@chainsafe/libp2p-noise": "^5.0.0",
     "@nodeutils/defaults-deep": "^1.1.0",
     "@types/es6-promisify": "^6.0.0",
     "@types/node": "^16.0.1",
-    "@types/node-forge": "^0.10.1",
+    "@types/node-forge": "^1.0.0",
     "@types/varint": "^6.0.0",
     "aegir": "^36.0.0",
     "buffer": "^6.0.3",
-    "datastore-core": "^6.0.7",
     "delay": "^5.0.0",
     "into-stream": "^6.0.0",
     "ipfs-http-client": "^54.0.2",
@@ -151,14 +150,12 @@
     "libp2p": ".",
     "libp2p-bootstrap": "^0.14.0",
     "libp2p-delegated-content-routing": "^0.11.0",
-    "libp2p-delegated-peer-routing": "^0.11.0",
+    "libp2p-delegated-peer-routing": "^0.11.1",
-    "libp2p-floodsub": "^0.27.0",
+    "libp2p-interfaces-compliance-tests": "^4.0.8",
-    "libp2p-gossipsub": "^0.11.0",
+    "libp2p-interop": "^0.7.1",
-    "libp2p-interfaces-compliance-tests": "^2.0.1",
+    "libp2p-kad-dht": "^0.28.6",
-    "libp2p-interop": "^0.5.0",
-    "libp2p-kad-dht": "^0.27.1",
     "libp2p-mdns": "^0.18.0",
-    "libp2p-mplex": "^0.10.1",
+    "libp2p-mplex": "^0.10.4",
     "libp2p-tcp": "^0.17.0",
     "libp2p-webrtc-star": "^0.25.0",
     "libp2p-websockets": "^0.16.0",
@@ -182,33 +179,34 @@
     "Maciej Krüger <mkg20001@gmail.com>",
     "Hugo Dias <mail@hugodias.me>",
     "dirkmc <dirkmdev@gmail.com>",
-    "Chris Dostert <chrisdostert@users.noreply.github.com>",
     "Volker Mische <volker.mische@gmail.com>",
+    "Chris Dostert <chrisdostert@users.noreply.github.com>",
     "zeim839 <50573884+zeim839@users.noreply.github.com>",
+    "Robert Kiel <robert.kiel@hoprnet.org>",
     "Richard Littauer <richard.littauer@gmail.com>",
     "a1300 <matthias-knopp@gmx.net>",
     "Ryan Bell <ryan@piing.net>",
     "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@gmail.com>",
+    "Andrew Nesbitt <andrewnez@gmail.com>",
+    "Franck Royer <franck@royer.one>",
+    "Thomas Eizinger <thomas@eizinger.io>",
+    "Vít Habada <vithabada93@gmail.com>",
     "Giovanni T. Parra <fiatjaf@gmail.com>",
     "acolytec3 <17355484+acolytec3@users.noreply.github.com>",
-    "Franck Royer <franck@royer.one>",
+    "Alan Smithee <ggnore.alan.smithee@gmail.com>",
     "Elven <mon.samuel@qq.com>",
-    "Robert Kiel <robert.kiel@hoprnet.org>",
-    "Andrew Nesbitt <andrewnez@gmail.com>",
     "Samlior <samlior@foxmail.com>",
-    "Thomas Eizinger <thomas@eizinger.io>",
     "Didrik Nordström <didrik.nordstrom@gmail.com>",
-    "Smite Chow <xiaopengyou@live.com>",
+    "Aditya Bose <13054902+adbose@users.noreply.github.com>",
-    "Soeren <nikorpoulsen@gmail.com>",
-    "Sönke Hahn <soenkehahn@gmail.com>",
     "TJKoury <TJKoury@gmail.com>",
     "TheStarBoys <41286328+TheStarBoys@users.noreply.github.com>",
     "Tiago Alves <alvesjtiago@gmail.com>",
+    "Tim Daubenschütz <tim@daubenschuetz.de>",
     "XiaoZhang <zxinmyth@gmail.com>",
     "Yusef Napora <yusef@napora.org>",
     "Zane Starr <zcstarr@gmail.com>",
     "ebinks <elizabethjbinks@gmail.com>",
-    "Aditya Bose <13054902+adbose@users.noreply.github.com>",
+    "greenSnot <greenSnot@users.noreply.github.com>",
     "isan_rivkin <isanrivkin@gmail.com>",
     "mayerwin <mayerwin@users.noreply.github.com>",
     "mcclure <andi.m.mcclure@gmail.com>",
@@ -217,8 +215,8 @@
     "robertkiel <robert.kiel@validitylabs.org>",
     "shresthagrawal <34920931+shresthagrawal@users.noreply.github.com>",
     "swedneck <40505480+swedneck@users.noreply.github.com>",
-    "greenSnot <greenSnot@users.noreply.github.com>",
+    "tuyennhv <vutuyen2636@gmail.com>",
-    "Alan Smithee <ggnore.alan.smithee@gmail.com>",
+    "Sönke Hahn <soenkehahn@gmail.com>",
     "Aleksei <vozhdb@gmail.com>",
     "Bernd Strehl <bernd.strehl@gmail.com>",
     "Chris Bratlien <chrisbratlien@gmail.com>",
@@ -243,10 +241,13 @@
     "Lars Gierth <lgierth@users.noreply.github.com>",
     "Leask Wong <i@leaskh.com>",
     "Marcin Tojek <mtojek@users.noreply.github.com>",
+    "Marston Connell <34043723+TheMarstonConnell@users.noreply.github.com>",
     "Michael Burns <5170+mburns@users.noreply.github.com>",
     "Miguel Mota <miguelmota2@gmail.com>",
     "Nuno Nogueira <nunofmn@gmail.com>",
     "Philipp Muens <raute1337@gmx.de>",
-    "RasmusErik Voel Jensen <github@solsort.com>"
+    "RasmusErik Voel Jensen <github@solsort.com>",
+    "Smite Chow <xiaopengyou@live.com>",
+    "Soeren <nikorpoulsen@gmail.com>"
   ]
 }

src/circuit/auto-relay.js

@@ -8,7 +8,7 @@ const log = Object.assign(debug('libp2p:auto-relay'), {
 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,7 +114,7 @@ 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 (/** @type {any} */ 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,27 +150,35 @@ 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)])
+      // Check if already listening on enough relays
-      // Announce multiaddrs will update on listen success by TransportManager event being triggered
+      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(id)
-      const connection = this._connectionManager.get(peerId)
 
       // 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)
 

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
@@ -88,7 +88,7 @@ class Relay {
       const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
       await this._libp2p.contentRouting.provide(cid)
     } catch (/** @type {any} */ err) {
-      if (err.code === 'NO_ROUTERS_AVAILABLE') {
+      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/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,
+      kBucketSize: 20
-      randomWalk: {
-        enabled: false, // disabled waiting for https://github.com/libp2p/js-libp2p-kad-dht/issues/86
-        queriesPerPeriod: 1,
-        interval: 300e3,
-        timeout: 10e3
-      }
     },
     nat: {
       enabled: true,

src/connection-manager/auto-dialler.js

@@ -4,6 +4,10 @@ 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')
@@ -50,14 +54,16 @@ class AutoDialler {
   /**
    * Starts the auto dialer
    */
-  start () {
+  async start () {
     if (!this._options.enabled) {
       log('not enabled')
       return
     }
 
     this._running = true
-    this._autoDial()
+    this._autoDial().catch(err => {
+      log.error('could start autodial', err)
+    })
     log('started')
   }
 
@@ -84,22 +90,30 @@ class AutoDialler {
       return
     }
 
-    // Sort peers on wether we know protocols of public keys for them
+    // Sort peers on whether we know protocols of public keys for them
-    const peers = Array.from(this._libp2p.peerStore.peers.values())
+    // TODO: assuming the `peerStore.getPeers()` order is stable this will mean
-      .sort((a, b) => {
+    // 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++) {
-      if (!this._libp2p.connectionManager.get(peers[i].id)) {
+      const peer = peers[i]
-        log('connecting to a peerStore stored peer %s', peers[i].id.toB58String())
+
+      if (!this._libp2p.connectionManager.get(peer.id)) {
+        log('connecting to a peerStore stored peer %s', peer.id.toB58String())
         try {
-          await this._libp2p.dialer.connectToPeer(peers[i].id)
+          await this._libp2p.dialer.connectToPeer(peer.id)
         } catch (/** @type {any} */ err) {
           log.error('could not connect to peerStore stored peer', err)
         }

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,14 +87,22 @@ 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
@@ -100,6 +112,9 @@ class ConnectionManager extends EventEmitter {
       latencyCheckIntervalMs: this._options.pollInterval,
       dataEmitIntervalMs: this._options.pollInterval
     })
+
+    // This emitter gets listened to a lot
+    this.setMaxListeners(Infinity)
   }
 
   /**
@@ -183,19 +198,22 @@ class ConnectionManager extends EventEmitter {
    *
    * @private
    */
-  _checkMetrics () {
+  async _checkMetrics () {
     if (this._libp2p.metrics) {
-      const movingAverages = this._libp2p.metrics.global.movingAverages
+      try {
-      // @ts-ignore moving averages object types
+        const movingAverages = this._libp2p.metrics.global.movingAverages
-      const received = movingAverages.dataReceived[this._options.movingAverageInterval].movingAverage()
+        // @ts-ignore moving averages object types
-      this._checkMaxLimit('maxReceivedData', received)
+        const received = movingAverages.dataReceived[this._options.movingAverageInterval].movingAverage()
-      // @ts-ignore moving averages object types
+        await this._checkMaxLimit('maxReceivedData', received)
-      const sent = movingAverages.dataSent[this._options.movingAverageInterval].movingAverage()
+        // @ts-ignore moving averages object types
-      this._checkMaxLimit('maxSentData', sent)
+        const sent = movingAverages.dataSent[this._options.movingAverageInterval].movingAverage()
-      const total = received + sent
+        await this._checkMaxLimit('maxSentData', sent)
-      this._checkMaxLimit('maxData', total)
+        const total = received + sent
-      log('metrics update', total)
+        await this._checkMaxLimit('maxData', total)
-      this._timer = retimer(this._checkMetrics, this._options.pollInterval)
+        log('metrics update', total)
+      } finally {
+        this._timer = retimer(this._checkMetrics, this._options.pollInterval)
+      }
     }
   }
 
@@ -203,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)
   }
 
   /**
@@ -243,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)
     }
   }
 
@@ -289,6 +309,9 @@ class ConnectionManager extends EventEmitter {
    */
   _onLatencyMeasure (summary) {
     this._checkMaxLimit('maxEventLoopDelay', summary.avgMs)
+      .catch(err => {
+        log.error(err)
+      })
   }
 
   /**
@@ -298,12 +321,12 @@ 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()
     }
   }
 
@@ -313,7 +336,7 @@ class ConnectionManager extends EventEmitter {
    *
    * @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)
@@ -324,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

@@ -54,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(
@@ -77,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)))

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) {
+async function * storeAddresses (source, peerStore) {
-  return map(source, (peer) => {
+  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/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,6 +1,9 @@
 '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')
 })
@@ -9,11 +12,12 @@ const { Multiaddr } = require('multiaddr')
 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,
@@ -22,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/types').PeerStore} PeerStore
- * @typedef {import('../peer-store/address-book').Address} Address
+ * @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
  *
@@ -44,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 {import('./dial-request')} dialRequest
- * @property {TimeoutController} controller
+ * @property {import('timeout-abort-controller').TimeoutController} controller
  * @property {Promise<Connection>} promise
  * @property {function():void} destroy
  */
@@ -64,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
@@ -79,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)
@@ -117,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) {
@@ -155,14 +187,16 @@ class Dialer {
       this._pendingDialTargets.set(id, { resolve, reject })
     })
 
-    const dialTarget = await Promise.race([
+    try {
-      this._createDialTarget(peer),
+      const dialTarget = await Promise.race([
-      cancellablePromise
+        this._createDialTarget(peer),
-    ])
+        cancellablePromise
+      ])
 
-    this._pendingDialTargets.delete(id)
+      return dialTarget
-
+    } finally {
-    return dialTarget
+      this._pendingDialTargets.delete(id)
+    }
   }
 
   /**
@@ -179,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.
@@ -202,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)
     }
 
@@ -239,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,
@@ -253,6 +301,7 @@ class Dialer {
       }
     }
     this._pendingDials.set(dialTarget.id, pendingDial)
+
     return pendingDial
   }
 

src/errors.js

@@ -12,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',
@@ -36,5 +38,29 @@ exports.codes = {
   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/identify/index.js

@@ -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 {
@@ -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)
   }
 
   /**
@@ -205,10 +210,10 @@ class IdentifyService {
 
     try {
       const envelope = await Envelope.openAndCertify(signedPeerRecord, PeerRecord.DOMAIN)
-      if (this.peerStore.addressBook.consumePeerRecord(envelope)) {
+      if (await this.peerStore.addressBook.consumePeerRecord(envelope)) {
-        this.peerStore.protoBook.set(id, protocols)
+        await this.peerStore.protoBook.set(id, protocols)
-        this.peerStore.metadataBook.set(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
+        await this.peerStore.metadataBook.setValue(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
-        this.peerStore.metadataBook.set(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
+        await this.peerStore.metadataBook.setValue(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
         return
       }
     } catch (/** @type {any} */ err) {
@@ -217,14 +222,14 @@ class IdentifyService {
 
     // LEGACY: Update peers data in PeerStore
     try {
-      this.peerStore.addressBook.set(id, listenAddrs.map((addr) => new Multiaddr(addr)))
+      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)
+    await this.peerStore.protoBook.set(id, protocols)
-    this.peerStore.metadataBook.set(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
+    await this.peerStore.metadataBook.setValue(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
-    this.peerStore.metadataBook.set(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
+    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,25 +267,25 @@ 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(),
@@ -321,8 +326,8 @@ class IdentifyService {
 
     try {
       const envelope = await Envelope.openAndCertify(message.signedPeerRecord, PeerRecord.DOMAIN)
-      if (this.peerStore.addressBook.consumePeerRecord(envelope)) {
+      if (await this.peerStore.addressBook.consumePeerRecord(envelope)) {
-        this.peerStore.protoBook.set(id, message.protocols)
+        await this.peerStore.protoBook.set(id, message.protocols)
         return
       }
     } catch (/** @type {any} */ err) {
@@ -331,14 +336,18 @@ class IdentifyService {
 
     // 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 (/** @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')
@@ -28,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')
 
@@ -48,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]
  */
 
 /**
@@ -56,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]
@@ -111,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]
  *
@@ -168,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)
+    // Create Metrics
-      ? new PersistentPeerStore({
+    if (this._options.metrics.enabled) {
-        peerId: this.peerId,
+      const metrics = new Metrics({
-        datastore: this.datastore,
+        ...this._options.metrics
-        ...this._options.peerStore
       })
-      : 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
@@ -202,14 +221,6 @@ class Libp2p extends EventEmitter {
       autoDialInterval: this._options.connectionManager.autoDialInterval
     })
 
-    // Create Metrics
-    if (this._options.metrics.enabled) {
-      this.metrics = new Metrics({
-        ...this._options.metrics,
-        connectionManager: this.connectionManager
-      })
-    }
-
     // Create keychain
     if (this._options.keychain && this._options.keychain.datastore) {
       log('creating keychain')
@@ -226,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),
@@ -268,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
     })
 
@@ -293,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
@@ -330,6 +343,8 @@ class Libp2p extends EventEmitter {
     ping.mount(this)
 
     this._onDiscoveryPeer = this._onDiscoveryPeer.bind(this)
+
+    this.fetchService = new FetchService(this)
   }
 
   /**
@@ -359,6 +374,14 @@ 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()
@@ -383,9 +406,13 @@ class Libp2p extends EventEmitter {
     try {
       this._isStarted = false
 
+      if (this.identifyService) {
+        await this.identifyService.stop()
+      }
+
       this.relay && this.relay.stop()
       this.peerRouting.stop()
-      this._autodialler.stop()
+      await this._autodialler.stop()
       await (this._dht && this._dht.stop())
 
       for (const service of this._discovery.values()) {
@@ -396,7 +423,6 @@ class Libp2p extends EventEmitter {
 
       this._discovery = new Map()
 
-      await this.peerStore.stop()
       await this.connectionManager.stop()
 
       await Promise.all([
@@ -407,6 +433,8 @@ class Libp2p extends EventEmitter {
       await this.natManager.stop()
       await this.transportManager.close()
 
+      this.unhandle(FetchService.PROTOCOL)
+
       ping.unmount(this)
       this.dialer.destroy()
     } catch (/** @type {any} */ err) {
@@ -502,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
@@ -559,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.
    *
@@ -582,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)
   }
 
   /**
@@ -598,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 () {
@@ -616,11 +655,8 @@ 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
@@ -634,6 +670,10 @@ class Libp2p extends EventEmitter {
 
     // Start metrics if present
     this.metrics && this.metrics.start()
+
+    if (this.identifyService) {
+      await this.identifyService.start()
+    }
   }
 
   /**
@@ -646,17 +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()
-    this._autodialler.start()
+    await this._autodialler.start()
 
     // Peer discovery
     await this._setupPeerDiscovery()
@@ -680,8 +722,8 @@ class Libp2p extends EventEmitter {
       return
     }
 
-    peer.multiaddrs && this.peerStore.addressBook.add(peer.id, peer.multiaddrs)
+    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)
+    peer.protocols && this.peerStore.protoBook.set(peer.id, peer.protocols).catch(err => log.error(err))
   }
 
   /**

src/keychain/cms.js

@@ -10,6 +10,7 @@ const { certificateForKey, findAsync } = require('./util')
 const errcode = require('err-code')
 const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
 const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
+const { codes } = require('../errors')
 
 const privates = new WeakMap()
 
@@ -31,7 +32,7 @@ class CMS {
    */
   constructor (keychain, dek) {
     if (!keychain) {
-      throw errcode(new Error('keychain is required'), 'ERR_KEYCHAIN_REQUIRED')
+      throw errcode(new Error('keychain is required'), codes.ERR_KEYCHAIN_REQUIRED)
     }
 
     this.keychain = keychain
@@ -49,7 +50,7 @@ class CMS {
    */
   async encrypt (name, plain) {
     if (!(plain instanceof Uint8Array)) {
-      throw errcode(new Error('Plain data must be a Uint8Array'), 'ERR_INVALID_PARAMS')
+      throw errcode(new Error('Plain data must be a Uint8Array'), codes.ERR_INVALID_PARAMETERS)
     }
 
     const key = await this.keychain.findKeyByName(name)
@@ -81,7 +82,7 @@ class CMS {
    */
   async decrypt (cmsData) {
     if (!(cmsData instanceof Uint8Array)) {
-      throw errcode(new Error('CMS data is required'), 'ERR_INVALID_PARAMS')
+      throw errcode(new Error('CMS data is required'), codes.ERR_INVALID_PARAMETERS)
     }
 
     let cms
@@ -91,7 +92,7 @@ class CMS {
       // @ts-ignore not defined
       cms = forge.pkcs7.messageFromAsn1(obj)
     } catch (/** @type {any} */ err) {
-      throw errcode(new Error('Invalid CMS: ' + err.message), 'ERR_INVALID_CMS')
+      throw errcode(new Error('Invalid CMS: ' + err.message), codes.ERR_INVALID_CMS)
     }
 
     // Find a recipient whose key we hold. We only deal with recipient certs
@@ -123,7 +124,7 @@ class CMS {
     if (!r) {
       // @ts-ignore cms types not defined
       const missingKeys = recipients.map(r => r.keyId)
-      throw errcode(new Error('Decryption needs one of the key(s): ' + missingKeys.join(', ')), 'ERR_MISSING_KEYS', {
+      throw errcode(new Error('Decryption needs one of the key(s): ' + missingKeys.join(', ')), codes.ERR_MISSING_KEYS, {
         missingKeys
       })
     }
@@ -131,7 +132,7 @@ class CMS {
     const key = await this.keychain.findKeyById(r.keyId)
 
     if (!key) {
-      throw errcode(new Error('No key available to decrypto'), 'ERR_NO_KEY')
+      throw errcode(new Error('No key available to decrypto'), codes.ERR_NO_KEY)
     }
 
     const pem = await this.keychain._getPrivateKey(key.name)

src/keychain/index.js

@@ -10,6 +10,7 @@ const crypto = require('libp2p-crypto')
 const { Key } = require('interface-datastore/key')
 const CMS = require('./cms')
 const errcode = require('err-code')
+const { codes } = require('../errors')
 const { toString: uint8ArrayToString } = require('uint8arrays/to-string')
 const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
 
@@ -210,21 +211,21 @@ class Keychain {
     const self = this
 
     if (!validateKeyName(name) || name === 'self') {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
     }
 
     if (typeof type !== 'string') {
-      return throwDelayed(errcode(new Error(`Invalid key type '${type}'`), 'ERR_INVALID_KEY_TYPE'))
+      return throwDelayed(errcode(new Error(`Invalid key type '${type}'`), codes.ERR_INVALID_KEY_TYPE))
     }
 
     const dsname = DsName(name)
     const exists = await self.store.has(dsname)
-    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))
 
     switch (type.toLowerCase()) {
       case 'rsa':
         if (!Number.isSafeInteger(size) || size < 2048) {
-          return throwDelayed(errcode(new Error(`Invalid RSA key size ${size}`), 'ERR_INVALID_KEY_SIZE'))
+          return throwDelayed(errcode(new Error(`Invalid RSA key size ${size}`), codes.ERR_INVALID_KEY_SIZE))
         }
         break
       default:
@@ -297,7 +298,7 @@ class Keychain {
    */
   async findKeyByName (name) {
     if (!validateKeyName(name)) {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
     }
 
     const dsname = DsInfoName(name)
@@ -305,7 +306,7 @@ class Keychain {
       const res = await this.store.get(dsname)
       return JSON.parse(uint8ArrayToString(res))
     } catch (/** @type {any} */ err) {
-      return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), 'ERR_KEY_NOT_FOUND'))
+      return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), codes.ERR_KEY_NOT_FOUND))
     }
   }
 
@@ -318,7 +319,7 @@ class Keychain {
   async removeKey (name) {
     const self = this
     if (!validateKeyName(name) || name === 'self') {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
     }
     const dsname = DsName(name)
     const keyInfo = await self.findKeyByName(name)
@@ -339,10 +340,10 @@ class Keychain {
   async renameKey (oldName, newName) {
     const self = this
     if (!validateKeyName(oldName) || oldName === 'self') {
-      return throwDelayed(errcode(new Error(`Invalid old key name '${oldName}'`), 'ERR_OLD_KEY_NAME_INVALID'))
+      return throwDelayed(errcode(new Error(`Invalid old key name '${oldName}'`), codes.ERR_OLD_KEY_NAME_INVALID))
     }
     if (!validateKeyName(newName) || newName === 'self') {
-      return throwDelayed(errcode(new Error(`Invalid new key name '${newName}'`), 'ERR_NEW_KEY_NAME_INVALID'))
+      return throwDelayed(errcode(new Error(`Invalid new key name '${newName}'`), codes.ERR_NEW_KEY_NAME_INVALID))
     }
     const oldDsname = DsName(oldName)
     const newDsname = DsName(newName)
@@ -350,7 +351,7 @@ class Keychain {
     const newInfoName = DsInfoName(newName)
 
     const exists = await self.store.has(newDsname)
-    if (exists) return throwDelayed(errcode(new Error(`Key '${newName}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+    if (exists) return throwDelayed(errcode(new Error(`Key '${newName}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))
 
     try {
       const pem = await self.store.get(oldDsname)
@@ -379,10 +380,10 @@ class Keychain {
    */
   async exportKey (name, password) {
     if (!validateKeyName(name)) {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
     }
     if (!password) {
-      return throwDelayed(errcode(new Error('Password is required'), 'ERR_PASSWORD_REQUIRED'))
+      return throwDelayed(errcode(new Error('Password is required'), codes.ERR_PASSWORD_REQUIRED))
     }
 
     const dsname = DsName(name)
@@ -409,20 +410,20 @@ class Keychain {
   async importKey (name, pem, password) {
     const self = this
     if (!validateKeyName(name) || name === 'self') {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
     }
     if (!pem) {
-      return throwDelayed(errcode(new Error('PEM encoded key is required'), 'ERR_PEM_REQUIRED'))
+      return throwDelayed(errcode(new Error('PEM encoded key is required'), codes.ERR_PEM_REQUIRED))
     }
     const dsname = DsName(name)
     const exists = await self.store.has(dsname)
-    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))
 
     let privateKey
     try {
       privateKey = await crypto.keys.import(pem, password)
     } catch (/** @type {any} */ err) {
-      return throwDelayed(errcode(new Error('Cannot read the key, most likely the password is wrong'), 'ERR_CANNOT_READ_KEY'))
+      return throwDelayed(errcode(new Error('Cannot read the key, most likely the password is wrong'), codes.ERR_CANNOT_READ_KEY))
     }
 
     let kid
@@ -457,16 +458,16 @@ class Keychain {
   async importPeer (name, peer) {
     const self = this
     if (!validateKeyName(name)) {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
     }
     if (!peer || !peer.privKey) {
-      return throwDelayed(errcode(new Error('Peer.privKey is required'), 'ERR_MISSING_PRIVATE_KEY'))
+      return throwDelayed(errcode(new Error('Peer.privKey is required'), codes.ERR_MISSING_PRIVATE_KEY))
     }
 
     const privateKey = peer.privKey
     const dsname = DsName(name)
     const exists = await self.store.has(dsname)
-    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), 'ERR_KEY_ALREADY_EXISTS'))
+    if (exists) return throwDelayed(errcode(new Error(`Key '${name}' already exists`), codes.ERR_KEY_ALREADY_EXISTS))
 
     try {
       const kid = await privateKey.id()
@@ -495,7 +496,7 @@ class Keychain {
    */
   async _getPrivateKey (name) {
     if (!validateKeyName(name)) {
-      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), 'ERR_INVALID_KEY_NAME'))
+      return throwDelayed(errcode(new Error(`Invalid key name '${name}'`), codes.ERR_INVALID_KEY_NAME))
     }
 
     try {
@@ -503,7 +504,7 @@ class Keychain {
       const res = await this.store.get(dsname)
       return uint8ArrayToString(res)
     } catch (/** @type {any} */ err) {
-      return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), 'ERR_KEY_NOT_FOUND'))
+      return throwDelayed(errcode(new Error(`Key '${name}' does not exist. ${err.message}`), codes.ERR_KEY_NOT_FOUND))
     }
   }
 
@@ -515,13 +516,13 @@ class Keychain {
    */
   async rotateKeychainPass (oldPass, newPass) {
     if (typeof oldPass !== 'string') {
-      return throwDelayed(errcode(new Error(`Invalid old pass type '${typeof oldPass}'`), 'ERR_INVALID_OLD_PASS_TYPE'))
+      return throwDelayed(errcode(new Error(`Invalid old pass type '${typeof oldPass}'`), codes.ERR_INVALID_OLD_PASS_TYPE))
     }
     if (typeof newPass !== 'string') {
-      return throwDelayed(errcode(new Error(`Invalid new pass type '${typeof newPass}'`), 'ERR_INVALID_NEW_PASS_TYPE'))
+      return throwDelayed(errcode(new Error(`Invalid new pass type '${typeof newPass}'`), codes.ERR_INVALID_NEW_PASS_TYPE))
     }
     if (newPass.length < 20) {
-      return throwDelayed(errcode(new Error(`Invalid pass length ${newPass.length}`), 'ERR_INVALID_PASS_LENGTH'))
+      return throwDelayed(errcode(new Error(`Invalid pass length ${newPass.length}`), codes.ERR_INVALID_PASS_LENGTH))
     }
     log('recreating keychain')
     const oldDek = privates.get(this).dek

src/metrics/index.js

@@ -24,9 +24,6 @@ const directionToEvent = {
  */
 
 /**
- * @typedef MetricsProperties
- * @property {import('../connection-manager')} connectionManager
- *
  * @typedef MetricsOptions
  * @property {number} [computeThrottleMaxQueueSize = defaultOptions.computeThrottleMaxQueueSize]
  * @property {number} [computeThrottleTimeout = defaultOptions.computeThrottleTimeout]
@@ -37,7 +34,7 @@ const directionToEvent = {
 class Metrics {
   /**
    * @class
-   * @param {MetricsProperties & MetricsOptions} options
+   * @param {MetricsOptions} options
    */
   constructor (options) {
     this._options = mergeOptions(defaultOptions, options)
@@ -47,10 +44,7 @@ class Metrics {
     this._oldPeers = oldPeerLRU(this._options.maxOldPeersRetention)
     this._running = false
     this._onMessage = this._onMessage.bind(this)
-    this._connectionManager = options.connectionManager
+    this._systems = new Map()
-    this._connectionManager.on('peer:disconnect', (connection) => {
-      this.onPeerDisconnected(connection.remotePeer)
-    })
   }
 
   /**
@@ -94,6 +88,29 @@ class Metrics {
     return Array.from(this._peerStats.keys())
   }
 
+  /**
+   * @returns {Map<string, Map<string, Map<string, any>>>}
+   */
+  getComponentMetrics () {
+    return this._systems
+  }
+
+  updateComponentMetric ({ system = 'libp2p', component, metric, value }) {
+    if (!this._systems.has(system)) {
+      this._systems.set(system, new Map())
+    }
+
+    const systemMetrics = this._systems.get(system)
+
+    if (!systemMetrics.has(component)) {
+      systemMetrics.set(component, new Map())
+    }
+
+    const componentMetrics = systemMetrics.get(component)
+
+    componentMetrics.set(metric, value)
+  }
+
   /**
    * Returns the `Stats` object for the given `PeerId` whether it
    * is a live peer, or in the disconnected peer LRU cache.

src/metrics/stats.js

@@ -8,6 +8,7 @@ const retimer = require('retimer')
 
 /**
  * @typedef {import('@vascosantos/moving-average').IMovingAverage} IMovingAverage
+ * @typedef {import('bignumber.js').BigNumber} Big
  */
 
 class Stats extends EventEmitter {

src/metrics/tracked-map.js

@@ -0,0 +1,94 @@
+'use strict'
+
+/**
+ * @template K
+ * @template V
+ */
+class TrackedMap extends Map {
+  /**
+   * @param {object} options
+   * @param {string} options.system
+   * @param {string} options.component
+   * @param {string} options.metric
+   * @param {import('.')} options.metrics
+   */
+  constructor (options) {
+    super()
+
+    const { system, component, metric, metrics } = options
+    this._system = system
+    this._component = component
+    this._metric = metric
+    this._metrics = metrics
+
+    this._metrics.updateComponentMetric({
+      system: this._system,
+      component: this._component,
+      metric: this._metric,
+      value: this.size
+    })
+  }
+
+  /**
+   * @param {K} key
+   * @param {V} value
+   */
+  set (key, value) {
+    super.set(key, value)
+    this._metrics.updateComponentMetric({
+      system: this._system,
+      component: this._component,
+      metric: this._metric,
+      value: this.size
+    })
+    return this
+  }
+
+  /**
+   * @param {K} key
+   */
+  delete (key) {
+    const deleted = super.delete(key)
+    this._metrics.updateComponentMetric({
+      system: this._system,
+      component: this._component,
+      metric: this._metric,
+      value: this.size
+    })
+    return deleted
+  }
+
+  clear () {
+    super.clear()
+
+    this._metrics.updateComponentMetric({
+      system: this._system,
+      component: this._component,
+      metric: this._metric,
+      value: this.size
+    })
+  }
+}
+
+/**
+ * @template K
+ * @template V
+ * @param {object} options
+ * @param {string} [options.system]
+ * @param {string} options.component
+ * @param {string} options.metric
+ * @param {import('.')} [options.metrics]
+ * @returns {Map<K, V>}
+ */
+module.exports = ({ system = 'libp2p', component, metric, metrics }) => {
+  /** @type {Map<K, V>} */
+  let map
+
+  if (metrics) {
+    map = new TrackedMap({ system, component, metric, metrics })
+  } else {
+    map = new Map()
+  }
+
+  return map
+}

src/nat-manager.js

@@ -1,7 +1,7 @@
 'use strict'
 
 // @ts-ignore nat-api does not export types
-const NatAPI = require('@motrix/nat-api')
+const NatAPI = require('nat-api')
 const debug = require('debug')
 const { promisify } = require('es6-promisify')
 const { Multiaddr } = require('multiaddr')

src/peer-routing.js

@@ -5,6 +5,7 @@ const log = Object.assign(debug('libp2p:peer-routing'), {
   error: debug('libp2p:peer-routing:err')
 })
 const errCode = require('err-code')
+const errors = require('./errors')
 const {
   storeAddresses,
   uniquePeers,
@@ -23,6 +24,8 @@ const {
 // @ts-ignore module with no types
 } = require('set-delayed-interval')
 const { DHTPeerRouting } = require('./dht/dht-peer-routing')
+// @ts-expect-error setMaxListeners is missing from the types
+const { setMaxListeners } = require('events')
 
 /**
  * @typedef {import('peer-id')} PeerId
@@ -104,19 +107,24 @@ class PeerRouting {
    */
   async findPeer (id, options) { // eslint-disable-line require-await
     if (!this._routers.length) {
-      throw errCode(new Error('No peer routers available'), 'NO_ROUTERS_AVAILABLE')
+      throw errCode(new Error('No peer routers available'), errors.codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
     if (id.toB58String() === this._peerId.toB58String()) {
-      throw errCode(new Error('Should not try to find self'), 'ERR_FIND_SELF')
+      throw errCode(new Error('Should not try to find self'), errors.codes.ERR_FIND_SELF)
     }
 
     const output = await pipe(
       merge(
-        ...this._routers.map(router => [router.findPeer(id, options)])
+        ...this._routers.map(router => (async function * () {
+          try {
+            yield await router.findPeer(id, options)
+          } catch (err) {
+            log.error(err)
+          }
+        })())
       ),
       (source) => filter(source, Boolean),
-      // @ts-ignore findPeer resolves a Promise
       (source) => storeAddresses(source, this._peerStore),
       (source) => first(source)
     )
@@ -125,7 +133,7 @@ class PeerRouting {
       return output
     }
 
-    throw errCode(new Error('not found'), 'NOT_FOUND')
+    throw errCode(new Error(errors.messages.NOT_FOUND), errors.codes.ERR_NOT_FOUND)
   }
 
   /**
@@ -139,11 +147,19 @@ class PeerRouting {
    */
   async * getClosestPeers (key, options = { timeout: 30e3 }) {
     if (!this._routers.length) {
-      throw errCode(new Error('No peer routers available'), 'NO_ROUTERS_AVAILABLE')
+      throw errCode(new Error('No peer routers available'), errors.codes.ERR_NO_ROUTERS_AVAILABLE)
     }
 
     if (options.timeout) {
-      options.signal = new TimeoutController(options.timeout).signal
+      const controller = new TimeoutController(options.timeout)
+      // this controller 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, controller.signal)
+      } catch {}
+
+      options.signal = controller.signal
     }
 
     yield * pipe(

src/peer-store/address-book.js

@@ -1,74 +1,43 @@
 'use strict'
 
 const debug = require('debug')
+const errcode = require('err-code')
+const { Multiaddr } = require('multiaddr')
+const PeerId = require('peer-id')
+const { codes } = require('../errors')
+const PeerRecord = require('../record/peer-record')
+const Envelope = require('../record/envelope')
+const { pipe } = require('it-pipe')
+const all = require('it-all')
+const filter = require('it-filter')
+const map = require('it-map')
+const each = require('it-foreach')
+
+/**
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').Address} Address
+ * @typedef {import('./types').AddressBook} AddressBook
+ */
+
 const log = Object.assign(debug('libp2p:peer-store:address-book'), {
   error: debug('libp2p:peer-store:address-book:err')
 })
-const errcode = require('err-code')
 
-const { Multiaddr } = require('multiaddr')
+const EVENT_NAME = 'change:multiaddrs'
-const PeerId = require('peer-id')
-
-const Book = require('./book')
-const PeerRecord = require('../record/peer-record')
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
-const Envelope = require('../record/envelope')
 
 /**
- * @typedef {import('./')} PeerStore
+ * @implements {AddressBook}
  */
-
+class PeerStoreAddressBook {
-/**
- * @typedef {Object} Address
- * @property {Multiaddr} multiaddr peer multiaddr.
- * @property {boolean} isCertified obtained from a signed peer record.
- *
- * @typedef {Object} CertifiedRecord
- * @property {Uint8Array} raw raw envelope.
- * @property {number} seqNumber seq counter.
- *
- * @typedef {Object} Entry
- * @property {Address[]} addresses peer Addresses.
- * @property {CertifiedRecord} record certified peer record.
- */
-
-/**
- * @extends {Book}
- */
-class AddressBook extends Book {
   /**
-   * The AddressBook is responsible for keeping the known multiaddrs of a peer.
+   * @param {PeerStore["emit"]} emit
-   *
+   * @param {import('./types').Store} store
-   * @class
+   * @param {(peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>} addressFilter
-   * @param {PeerStore} peerStore
    */
-  constructor (peerStore) {
+  constructor (emit, store, addressFilter) {
-    /**
+    this._emit = emit
-     * PeerStore Event emitter, used by the AddressBook to emit:
+    this._store = store
-     * "peer" - emitted when a peer is discovered by the node.
+    this._addressFilter = addressFilter
-     * "change:multiaddrs" - emitted when the known multiaddrs of a peer change.
-     */
-    super({
-      peerStore,
-      eventName: 'change:multiaddrs',
-      eventProperty: 'multiaddrs',
-      eventTransformer: (data) => {
-        if (!data.addresses) {
-          return []
-        }
-        return data.addresses.map((/** @type {Address} */ address) => address.multiaddr)
-      }
-    })
-
-    /**
-     * Map known peers to their known Address Entries.
-     *
-     * @type {Map<string, Entry>}
-     */
-    this.data = new Map()
   }
 
   /**
@@ -77,69 +46,90 @@ class AddressBook extends Book {
    * into the AddressBook.
    *
    * @param {Envelope} envelope
-   * @returns {boolean}
    */
-  consumePeerRecord (envelope) {
+  async consumePeerRecord (envelope) {
-    let peerRecord
+    log('consumePeerRecord await write lock')
+    const release = await this._store.lock.writeLock()
+    log('consumePeerRecord got write lock')
+
+    let peerId
+    let updatedPeer
+
     try {
-      peerRecord = PeerRecord.createFromProtobuf(envelope.payload)
+      let peerRecord
-    } catch (/** @type {any} */ err) {
+      try {
-      log.error('invalid peer record received')
+        peerRecord = PeerRecord.createFromProtobuf(envelope.payload)
-      return false
+      } catch (/** @type {any} */ err) {
-    }
+        log.error('invalid peer record received')
-
+        return false
-    // Verify peerId
-    if (!peerRecord.peerId.equals(envelope.peerId)) {
-      log('signing key does not match PeerId in the PeerRecord')
-      return false
-    }
-
-    // ensure the record has multiaddrs
-    if (!peerRecord.multiaddrs || !peerRecord.multiaddrs.length) {
-      return false
-    }
-
-    const peerId = peerRecord.peerId
-    const id = peerId.toB58String()
-    const entry = this.data.get(id) || { record: undefined }
-    const storedRecord = entry.record
-
-    // ensure seq is greater than, or equal to, the last received
-    if (storedRecord && storedRecord.seqNumber >= peerRecord.seqNumber) {
-      return false
-    }
-
-    const addresses = this._toAddresses(peerRecord.multiaddrs, true)
-
-    // Replace unsigned addresses by the new ones from the record
-    // TODO: Once we have ttls for the addresses, we should merge these in.
-    this._setData(peerId, {
-      addresses,
-      record: {
-        raw: envelope.marshal(),
-        seqNumber: peerRecord.seqNumber
       }
-    })
+
-    log(`stored provided peer record for ${id}`)
+      peerId = peerRecord.peerId
+      const multiaddrs = peerRecord.multiaddrs
+
+      // Verify peerId
+      if (!peerId.equals(envelope.peerId)) {
+        log('signing key does not match PeerId in the PeerRecord')
+        return false
+      }
+
+      // ensure the record has multiaddrs
+      if (!multiaddrs || !multiaddrs.length) {
+        return false
+      }
+
+      if (await this._store.has(peerId)) {
+        const peer = await this._store.load(peerId)
+
+        if (peer.peerRecordEnvelope) {
+          const storedEnvelope = await Envelope.createFromProtobuf(peer.peerRecordEnvelope)
+          const storedRecord = PeerRecord.createFromProtobuf(storedEnvelope.payload)
+
+          // ensure seq is greater than, or equal to, the last received
+          if (storedRecord.seqNumber >= peerRecord.seqNumber) {
+            return false
+          }
+        }
+      }
+
+      // Replace unsigned addresses by the new ones from the record
+      // TODO: Once we have ttls for the addresses, we should merge these in
+      updatedPeer = await this._store.patchOrCreate(peerId, {
+        addresses: await filterMultiaddrs(peerId, multiaddrs, this._addressFilter, true),
+        peerRecordEnvelope: envelope.marshal()
+      })
+
+      log(`stored provided peer record for ${peerRecord.peerId.toB58String()}`)
+    } finally {
+      log('consumePeerRecord release write lock')
+      release()
+    }
+
+    this._emit(EVENT_NAME, { peerId, multiaddrs: updatedPeer.addresses.map(({ multiaddr }) => multiaddr) })
 
     return true
   }
 
   /**
-   * Get the raw Envelope for a peer. Returns
-   * undefined if no Envelope is found.
-   *
    * @param {PeerId} peerId
-   * @returns {Uint8Array|undefined}
    */
-  getRawEnvelope (peerId) {
+  async getRawEnvelope (peerId) {
-    const entry = this.data.get(peerId.toB58String())
+    log('getRawEnvelope await read lock')
+    const release = await this._store.lock.readLock()
+    log('getRawEnvelope got read lock')
 
-    if (!entry || !entry.record || !entry.record.raw) {
+    try {
-      return undefined
+      const peer = await this._store.load(peerId)
+
+      return peer.peerRecordEnvelope
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('getRawEnvelope release read lock')
+      release()
     }
-
-    return entry.record.raw
   }
 
   /**
@@ -147,10 +137,9 @@ class AddressBook extends Book {
    * Returns undefined if no record exists.
    *
    * @param {PeerId} peerId
-   * @returns {Promise<Envelope|void>|undefined}
    */
-  getPeerRecord (peerId) {
+  async getPeerRecord (peerId) {
-    const raw = this.getRawEnvelope(peerId)
+    const raw = await this.getRawEnvelope(peerId)
 
     if (!raw) {
       return undefined
@@ -160,186 +149,199 @@ class AddressBook extends Book {
   }
 
   /**
-   * Set known multiaddrs of a provided peer.
-   * This will replace previously stored multiaddrs, if available.
-   * Replacing stored multiaddrs might result in losing obtained certified addresses.
-   * If you are not sure, it's recommended to use `add` instead.
-   *
-   * @override
    * @param {PeerId} peerId
-   * @param {Multiaddr[]} multiaddrs
-   * @returns {AddressBook}
    */
-  set (peerId, multiaddrs) {
+  async get (peerId) {
     if (!PeerId.isPeerId(peerId)) {
       log.error('peerId must be an instance of peer-id to store data')
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const addresses = this._toAddresses(multiaddrs)
+    log('get wait for read lock')
+    const release = await this._store.lock.readLock()
+    log('get got read lock')
 
-    // Not replace multiaddrs
+    try {
-    if (!addresses.length) {
+      const peer = await this._store.load(peerId)
-      return this
-    }
 
-    const id = peerId.toB58String()
+      return peer.addresses
-    const entry = this.data.get(id)
+    } catch (/** @type {any} */ err) {
-
+      if (err.code !== codes.ERR_NOT_FOUND) {
-    // Already knows the peer
+        throw err
-    if (entry && entry.addresses && entry.addresses.length === addresses.length) {
-      const intersection = entry.addresses.filter((addr) => addresses.some((newAddr) => addr.multiaddr.equals(newAddr.multiaddr)))
-
-      // Are new addresses equal to the old ones?
-      // If yes, no changes needed!
-      if (intersection.length === entry.addresses.length) {
-        log(`the addresses provided to store are equal to the already stored for ${id}`)
-        return this
       }
+    } finally {
+      log('get release read lock')
+      release()
     }
 
-    this._setData(peerId, {
+    return []
-      addresses,
-      record: entry && entry.record
-    })
-    log(`stored provided multiaddrs for ${id}`)
-
-    // Notify the existance of a new peer
-    if (!entry) {
-      this._ps.emit('peer', peerId)
-    }
-
-    return this
   }
 
   /**
-   * Add known addresses of a provided peer.
-   * If the peer is not known, it is set with the given addresses.
-   *
    * @param {PeerId} peerId
    * @param {Multiaddr[]} multiaddrs
-   * @returns {AddressBook}
    */
-  add (peerId, multiaddrs) {
+  async set (peerId, multiaddrs) {
     if (!PeerId.isPeerId(peerId)) {
       log.error('peerId must be an instance of peer-id to store data')
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const addresses = this._toAddresses(multiaddrs)
+    if (!Array.isArray(multiaddrs)) {
-    const id = peerId.toB58String()
+      log.error('multiaddrs must be an array of Multiaddrs')
-
+      throw errcode(new Error('multiaddrs must be an array of Multiaddrs'), codes.ERR_INVALID_PARAMETERS)
-    // No addresses to be added
-    if (!addresses.length) {
-      return this
     }
 
-    const entry = this.data.get(id)
+    log('set await write lock')
+    const release = await this._store.lock.writeLock()
+    log('set got write lock')
 
-    if (entry && entry.addresses) {
+    let hasPeer = false
-      // Add recorded uniquely to the new array (Union)
+    let updatedPeer
-      entry.addresses.forEach((addr) => {
+
-        if (!addresses.find(r => r.multiaddr.equals(addr.multiaddr))) {
+    try {
-          addresses.push(addr)
+      const addresses = await filterMultiaddrs(peerId, multiaddrs, this._addressFilter)
+
+      // No valid addresses found
+      if (!addresses.length) {
+        return
+      }
+
+      try {
+        const peer = await this._store.load(peerId)
+        hasPeer = true
+
+        if (new Set([
+          ...addresses.map(({ multiaddr }) => multiaddr.toString()),
+          ...peer.addresses.map(({ multiaddr }) => multiaddr.toString())
+        ]).size === peer.addresses.length && addresses.length === peer.addresses.length) {
+          // not changing anything, no need to update
+          return
+        }
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
         }
-      })
-
-      // If the recorded length is equal to the new after the unique union
-      // The content is the same, no need to update.
-      if (entry.addresses.length === addresses.length) {
-        log(`the addresses provided to store are already stored for ${id}`)
-        return this
       }
+
+      updatedPeer = await this._store.patchOrCreate(peerId, { addresses })
+
+      log(`set multiaddrs for ${peerId.toB58String()}`)
+    } finally {
+      log('set release write lock')
+      release()
     }
 
-    this._setData(peerId, {
+    this._emit(EVENT_NAME, { peerId, multiaddrs: updatedPeer.addresses.map(addr => addr.multiaddr) })
-      addresses,
-      record: entry && entry.record
-    })
 
-    log(`added provided multiaddrs for ${id}`)
+    // Notify the existence of a new peer
-
+    if (!hasPeer) {
-    // Notify the existance of a new peer
+      this._emit('peer', peerId)
-    if (!(entry && entry.addresses)) {
-      this._ps.emit('peer', peerId)
     }
-
-    return this
   }
 
   /**
-   * Get the known data of a provided peer.
-   *
-   * @override
    * @param {PeerId} peerId
-   * @returns {Address[]|undefined}
-   */
-  get (peerId) {
-    if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
-    }
-
-    const entry = this.data.get(peerId.toB58String())
-
-    return entry && entry.addresses ? [...entry.addresses] : undefined
-  }
-
-  /**
-   * Transforms received multiaddrs into Address.
-   *
-   * @private
    * @param {Multiaddr[]} multiaddrs
-   * @param {boolean} [isCertified]
-   * @returns {Address[]}
    */
-  _toAddresses (multiaddrs, isCertified = false) {
+  async add (peerId, multiaddrs) {
-    if (!multiaddrs) {
+    if (!PeerId.isPeerId(peerId)) {
-      log.error('multiaddrs must be provided to store data')
+      log.error('peerId must be an instance of peer-id to store data')
-      throw errcode(new Error('multiaddrs must be provided'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    // create Address for each address
+    if (!Array.isArray(multiaddrs)) {
-    /** @type {Address[]} */
+      log.error('multiaddrs must be an array of Multiaddrs')
-    const addresses = []
+      throw errcode(new Error('multiaddrs must be an array of Multiaddrs'), codes.ERR_INVALID_PARAMETERS)
-    multiaddrs.forEach((addr) => {
+    }
-      if (!Multiaddr.isMultiaddr(addr)) {
+
-        log.error(`multiaddr ${addr} must be an instance of multiaddr`)
+    log('add await write lock')
-        throw errcode(new Error(`multiaddr ${addr} must be an instance of multiaddr`), ERR_INVALID_PARAMETERS)
+    const release = await this._store.lock.writeLock()
+    log('add got write lock')
+
+    let hasPeer
+    let updatedPeer
+
+    try {
+      const addresses = await filterMultiaddrs(peerId, multiaddrs, this._addressFilter)
+
+      // No valid addresses found
+      if (!addresses.length) {
+        return
       }
 
-      // Guarantee no replicates
+      try {
-      if (!addresses.find((a) => a.multiaddr.equals(addr))) {
+        const peer = await this._store.load(peerId)
-        addresses.push({
+        hasPeer = true
-          multiaddr: addr,
-          isCertified
-        })
-      }
-    })
 
-    return addresses
+        if (new Set([
+          ...addresses.map(({ multiaddr }) => multiaddr.toString()),
+          ...peer.addresses.map(({ multiaddr }) => multiaddr.toString())
+        ]).size === peer.addresses.length) {
+          return
+        }
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
+
+      updatedPeer = await this._store.mergeOrCreate(peerId, { addresses })
+
+      log(`added multiaddrs for ${peerId}`)
+    } finally {
+      log('set release write lock')
+      release()
+    }
+
+    this._emit(EVENT_NAME, { peerId, multiaddrs: updatedPeer.addresses.map(addr => addr.multiaddr) })
+
+    // Notify the existence of a new peer
+    if (!hasPeer) {
+      this._emit('peer', peerId)
+    }
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  async delete (peerId) {
+    if (!PeerId.isPeerId(peerId)) {
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('delete await write lock')
+    const release = await this._store.lock.writeLock()
+    log('delete got write lock')
+
+    let has
+
+    try {
+      has = await this._store.has(peerId)
+
+      await this._store.patchOrCreate(peerId, {
+        addresses: []
+      })
+    } finally {
+      log('delete release write lock')
+      release()
+    }
+
+    if (has) {
+      this._emit(EVENT_NAME, { peerId, multiaddrs: [] })
+    }
   }
 
   /**
-   * Get the known multiaddrs for a given peer. All returned multiaddrs
-   * will include the encapsulated `PeerId` of the peer.
-   * Returns `undefined` if there are no known multiaddrs for the given peer.
-   *
    * @param {PeerId} peerId
    * @param {(addresses: Address[]) => Address[]} [addressSorter]
-   * @returns {Multiaddr[]|undefined}
    */
-  getMultiaddrsForPeer (peerId, addressSorter = (ms) => ms) {
+  async getMultiaddrsForPeer (peerId, addressSorter = (ms) => ms) {
-    if (!PeerId.isPeerId(peerId)) {
+    const addresses = await this.get(peerId)
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
-    }
-
-    const entry = this.data.get(peerId.toB58String())
-    if (!entry || !entry.addresses) {
-      return undefined
-    }
 
     return addressSorter(
-      entry.addresses || []
+      addresses
     ).map((address) => {
       const multiaddr = address.multiaddr
 
@@ -351,4 +353,30 @@ class AddressBook extends Book {
   }
 }
 
-module.exports = AddressBook
+/**
+ * @param {PeerId} peerId
+ * @param {Multiaddr[]} multiaddrs
+ * @param {(peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>} addressFilter
+ * @param {boolean} isCertified
+ */
+function filterMultiaddrs (peerId, multiaddrs, addressFilter, isCertified = false) {
+  return pipe(
+    multiaddrs,
+    (source) => each(source, (multiaddr) => {
+      if (!Multiaddr.isMultiaddr(multiaddr)) {
+        log.error('multiaddr must be an instance of Multiaddr')
+        throw errcode(new Error('multiaddr must be an instance of Multiaddr'), codes.ERR_INVALID_PARAMETERS)
+      }
+    }),
+    (source) => filter(source, (multiaddr) => addressFilter(peerId, multiaddr)),
+    (source) => map(source, (multiaddr) => {
+      return {
+        multiaddr: new Multiaddr(multiaddr.toString()),
+        isCertified
+      }
+    }),
+    (source) => all(source)
+  )
+}
+
+module.exports = PeerStoreAddressBook

src/peer-store/book.js

@@ -1,127 +0,0 @@
-'use strict'
-
-const errcode = require('err-code')
-const PeerId = require('peer-id')
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
-
-/**
- * @param {any} data
- */
-const passthrough = data => data
-
-/**
- * @typedef {import('./')} PeerStore
- */
-
-class Book {
-  /**
-   * The Book is the skeleton for the PeerStore books.
-   *
-   * @class
-   * @param {Object} properties
-   * @param {PeerStore} properties.peerStore - PeerStore instance.
-   * @param {string} properties.eventName - Name of the event to emit by the PeerStore.
-   * @param {string} properties.eventProperty - Name of the property to emit by the PeerStore.
-   * @param {(data: any) => any[]} [properties.eventTransformer] - Transformer function of the provided data for being emitted.
-   */
-  constructor ({ peerStore, eventName, eventProperty, eventTransformer = passthrough }) {
-    this._ps = peerStore
-    this.eventName = eventName
-    this.eventProperty = eventProperty
-    this.eventTransformer = eventTransformer
-
-    /**
-     * Map known peers to their data.
-     *
-     * @type {Map<string, any[]|any>}
-     */
-    this.data = new Map()
-  }
-
-  /**
-   * Set known data of a provided peer.
-   *
-   * @param {PeerId} peerId
-   * @param {any[]|any} data
-   */
-  set (peerId, data) {
-    throw errcode(new Error('set must be implemented by the subclass'), 'ERR_NOT_IMPLEMENTED')
-  }
-
-  /**
-   * Set data into the datastructure, persistence and emit it using the provided transformers.
-   *
-   * @protected
-   * @param {PeerId} peerId - peerId of the data to store
-   * @param {any} data - data to store.
-   * @param {Object} [options] - storing options.
-   * @param {boolean} [options.emit = true] - emit the provided data.
-   * @returns {void}
-   */
-  _setData (peerId, data, { emit = true } = {}) {
-    const b58key = peerId.toB58String()
-
-    // Store data in memory
-    this.data.set(b58key, data)
-
-    // Emit event
-    emit && this._emit(peerId, data)
-  }
-
-  /**
-   * Emit data.
-   *
-   * @protected
-   * @param {PeerId} peerId
-   * @param {any} [data]
-   */
-  _emit (peerId, data) {
-    this._ps.emit(this.eventName, {
-      peerId,
-      [this.eventProperty]: this.eventTransformer(data)
-    })
-  }
-
-  /**
-   * Get the known data of a provided peer.
-   * Returns `undefined` if there is no available data for the given peer.
-   *
-   * @param {PeerId} peerId
-   * @returns {any[]|any|undefined}
-   */
-  get (peerId) {
-    if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
-    }
-
-    const rec = this.data.get(peerId.toB58String())
-
-    // @ts-ignore
-    return rec ? [...rec] : undefined
-  }
-
-  /**
-   * Deletes the provided peer from the book.
-   *
-   * @param {PeerId} peerId
-   * @returns {boolean}
-   */
-  delete (peerId) {
-    if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
-    }
-
-    if (!this.data.delete(peerId.toB58String())) {
-      return false
-    }
-
-    this._emit(peerId, [])
-
-    return true
-  }
-}
-
-module.exports = Book

src/peer-store/index.js

@@ -1,152 +1,121 @@
 'use strict'
 
-const errcode = require('err-code')
+const debug = require('debug')
-
 const { EventEmitter } = require('events')
-const PeerId = require('peer-id')
-
 const AddressBook = require('./address-book')
 const KeyBook = require('./key-book')
 const MetadataBook = require('./metadata-book')
 const ProtoBook = require('./proto-book')
-
+const Store = require('./store')
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
 
 /**
- * @typedef {import('./address-book').Address} Address
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').Peer} Peer
+ * @typedef {import('peer-id')} PeerId
+ * @typedef {import('multiaddr').Multiaddr} Multiaddr
  */
 
+const log = Object.assign(debug('libp2p:peer-store'), {
+  error: debug('libp2p:peer-store:err')
+})
+
 /**
- * @extends {EventEmitter}
+ * An implementation of PeerStore that stores data in a Datastore
  *
- * @fires PeerStore#peer Emitted when a new peer is added.
+ * @implements {PeerStore}
- * @fires PeerStore#change:protocols Emitted when a known peer supports a different set of protocols.
- * @fires PeerStore#change:multiaddrs Emitted when a known peer has a different set of multiaddrs.
- * @fires PeerStore#change:pubkey Emitted emitted when a peer's public key is known.
- * @fires PeerStore#change:metadata Emitted when the known metadata of a peer change.
  */
-class PeerStore extends EventEmitter {
+class DefaultPeerStore extends EventEmitter {
   /**
-   * Peer object
+   * @param {object} properties
-   *
+   * @param {PeerId} properties.peerId
-   * @typedef {Object} Peer
+   * @param {import('interface-datastore').Datastore} properties.datastore
-   * @property {PeerId} id peer's peer-id instance.
+   * @param {(peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>} properties.addressFilter
-   * @property {Address[]} addresses peer's addresses containing its multiaddrs and metadata.
-   * @property {string[]} protocols peer's supported protocols.
-   * @property {Map<string, Uint8Array>|undefined} metadata peer's metadata map.
    */
-
+  constructor ({ peerId, datastore, addressFilter }) {
-  /**
-   * Responsible for managing known peers, as well as their addresses, protocols and metadata.
-   *
-   * @param {object} options
-   * @param {PeerId} options.peerId
-   * @class
-   */
-  constructor ({ peerId }) {
     super()
 
     this._peerId = peerId
+    this._store = new Store(datastore)
 
-    /**
+    this.addressBook = new AddressBook(this.emit.bind(this), this._store, addressFilter)
-     * AddressBook containing a map of peerIdStr to Address.
+    this.keyBook = new KeyBook(this.emit.bind(this), this._store)
-     */
+    this.metadataBook = new MetadataBook(this.emit.bind(this), this._store)
-    this.addressBook = new AddressBook(this)
+    this.protoBook = new ProtoBook(this.emit.bind(this), this._store)
+  }
 
-    /**
+  async * getPeers () {
-     * KeyBook containing a map of peerIdStr to their PeerId with public keys.
+    log('getPeers await read lock')
-     */
+    const release = await this._store.lock.readLock()
-    this.keyBook = new KeyBook(this)
+    log('getPeers got read lock')
 
-    /**
+    try {
-     * MetadataBook containing a map of peerIdStr to their metadata Map.
+      for await (const peer of this._store.all()) {
-     */
+        if (peer.id.toB58String() === this._peerId.toB58String()) {
-    this.metadataBook = new MetadataBook(this)
+          // Remove self peer if present
+          continue
+        }
 
-    /**
+        yield peer
-     * ProtoBook containing a map of peerIdStr to supported protocols.
+      }
-     */
+    } finally {
-    this.protoBook = new ProtoBook(this)
+      log('getPeers release read lock')
+      release()
+    }
   }
 
   /**
-   * Start the PeerStore.
+   * Delete the information of the given peer in every book
-   */
-  start () {}
-
-  /**
-   * Stop the PeerStore.
-   */
-  stop () {}
-
-  /**
-   * Get all the stored information of every peer known.
-   *
-   * @returns {Map<string, Peer>}
-   */
-  get peers () {
-    const storedPeers = new Set([
-      ...this.addressBook.data.keys(),
-      ...this.keyBook.data.keys(),
-      ...this.protoBook.data.keys(),
-      ...this.metadataBook.data.keys()
-    ])
-
-    // Remove self peer if present
-    this._peerId && storedPeers.delete(this._peerId.toB58String())
-
-    const peersData = new Map()
-    storedPeers.forEach((idStr) => {
-      peersData.set(idStr, this.get(PeerId.createFromB58String(idStr)))
-    })
-
-    return peersData
-  }
-
-  /**
-   * Delete the information of the given peer in every book.
    *
    * @param {PeerId} peerId
-   * @returns {boolean} true if found and removed
    */
-  delete (peerId) {
+  async delete (peerId) {
-    const addressesDeleted = this.addressBook.delete(peerId)
+    log('delete await write lock')
-    const keyDeleted = this.keyBook.delete(peerId)
+    const release = await this._store.lock.writeLock()
-    const protocolsDeleted = this.protoBook.delete(peerId)
+    log('delete got write lock')
-    const metadataDeleted = this.metadataBook.delete(peerId)
 
-    return addressesDeleted || keyDeleted || protocolsDeleted || metadataDeleted
+    try {
+      await this._store.delete(peerId)
+    } finally {
+      log('delete release write lock')
+      release()
+    }
   }
 
   /**
-   * Get the stored information of a given peer.
+   * Get the stored information of a given peer
    *
    * @param {PeerId} peerId
-   * @returns {Peer|undefined}
    */
-  get (peerId) {
+  async get (peerId) {
-    if (!PeerId.isPeerId(peerId)) {
+    log('get await read lock')
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+    const release = await this._store.lock.readLock()
+    log('get got read lock')
+
+    try {
+      return this._store.load(peerId)
+    } finally {
+      log('get release read lock')
+      release()
     }
+  }
 
-    const id = this.keyBook.data.get(peerId.toB58String())
+  /**
-    const addresses = this.addressBook.get(peerId)
+   * Returns true if we have a record of the peer
-    const metadata = this.metadataBook.get(peerId)
+   *
-    const protocols = this.protoBook.get(peerId)
+   * @param {PeerId} peerId
+   */
+  async has (peerId) {
+    log('has await read lock')
+    const release = await this._store.lock.readLock()
+    log('has got read lock')
 
-    if (!id && !addresses && !metadata && !protocols) {
+    try {
-      return undefined
+      return this._store.has(peerId)
-    }
+    } finally {
-
+      log('has release read lock')
-    return {
+      release()
-      id: id || peerId,
-      addresses: addresses || [],
-      protocols: protocols || [],
-      metadata: metadata
     }
   }
 }
 
-module.exports = PeerStore
+module.exports = DefaultPeerStore

src/peer-store/key-book.js

@@ -1,96 +1,141 @@
 'use strict'
 
 const debug = require('debug')
+const errcode = require('err-code')
+const { codes } = require('../errors')
+const PeerId = require('peer-id')
+const { equals: uint8arrayEquals } = require('uint8arrays/equals')
+
+/**
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').KeyBook} KeyBook
+ * @typedef {import('libp2p-interfaces/src/keys/types').PublicKey} PublicKey
+ */
+
 const log = Object.assign(debug('libp2p:peer-store:key-book'), {
   error: debug('libp2p:peer-store:key-book:err')
 })
-const errcode = require('err-code')
 
-const PeerId = require('peer-id')
+const EVENT_NAME = 'change:pubkey'
-
-const Book = require('./book')
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
 
 /**
- * @typedef {import('./')} PeerStore
+ * @implements {KeyBook}
- * @typedef {import('libp2p-crypto').PublicKey} PublicKey
  */
-
+class PeerStoreKeyBook {
-/**
- * @extends {Book}
- */
-class KeyBook extends Book {
   /**
    * The KeyBook is responsible for keeping the known public keys of a peer.
    *
-   * @class
+   * @param {PeerStore["emit"]} emit
-   * @param {PeerStore} peerStore
+   * @param {import('./types').Store} store
    */
-  constructor (peerStore) {
+  constructor (emit, store) {
-    super({
+    this._emit = emit
-      peerStore,
+    this._store = store
-      eventName: 'change:pubkey',
-      eventProperty: 'pubkey',
-      eventTransformer: (data) => data.pubKey
-    })
-
-    /**
-     * Map known peers to their known Public Key.
-     *
-     * @type {Map<string, PeerId>}
-     */
-    this.data = new Map()
   }
 
   /**
-   * Set the Peer public key.
+   * Set the Peer public key
    *
-   * @override
    * @param {PeerId} peerId
    * @param {PublicKey} publicKey
-   * @returns {KeyBook}
    */
-  set (peerId, publicKey) {
+  async set (peerId, publicKey) {
     if (!PeerId.isPeerId(peerId)) {
       log.error('peerId must be an instance of peer-id to store data')
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const id = peerId.toB58String()
+    if (!publicKey) {
-    const recPeerId = this.data.get(id)
+      log.error('publicKey must be an instance of PublicKey to store data')
-
+      throw errcode(new Error('publicKey must be an instance of PublicKey'), codes.ERR_INVALID_PARAMETERS)
-    // If no record available, and this is valid
-    if (!recPeerId && publicKey) {
-      // This might be unecessary, but we want to store the PeerId
-      // to avoid an async operation when reconstructing the PeerId
-      peerId.pubKey = publicKey
-
-      this._setData(peerId, peerId)
-      log(`stored provided public key for ${id}`)
     }
 
-    return this
+    log('set await write lock')
+    const release = await this._store.lock.writeLock()
+    log('set got write lock')
+
+    let updatedKey = false
+
+    try {
+      try {
+        const existing = await this._store.load(peerId)
+
+        if (existing.pubKey && uint8arrayEquals(existing.pubKey.bytes, publicKey.bytes)) {
+          return
+        }
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
+
+      await this._store.patchOrCreate(peerId, {
+        pubKey: publicKey
+      })
+      updatedKey = true
+    } finally {
+      log('set release write lock')
+      release()
+    }
+
+    if (updatedKey) {
+      this._emit(EVENT_NAME, { peerId, pubKey: publicKey })
+    }
   }
 
   /**
-   * Get Public key of the given PeerId, if stored.
+   * Get Public key of the given PeerId, if stored
    *
-   * @override
    * @param {PeerId} peerId
-   * @returns {PublicKey | undefined}
    */
-  get (peerId) {
+  async get (peerId) {
     if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const rec = this.data.get(peerId.toB58String())
+    log('get await write lock')
+    const release = await this._store.lock.readLock()
+    log('get got write lock')
 
-    return rec ? rec.pubKey : undefined
+    try {
+      const peer = await this._store.load(peerId)
+
+      return peer.pubKey
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('get release write lock')
+      release()
+    }
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  async delete (peerId) {
+    if (!PeerId.isPeerId(peerId)) {
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('delete await write lock')
+    const release = await this._store.lock.writeLock()
+    log('delete got write lock')
+
+    try {
+      await this._store.patchOrCreate(peerId, {
+        pubKey: undefined
+      })
+    } finally {
+      log('delete release write lock')
+      release()
+    }
+
+    this._emit(EVENT_NAME, { peerId, pubKey: undefined })
   }
 }
 
-module.exports = KeyBook
+module.exports = PeerStoreKeyBook

src/peer-store/metadata-book.js

@@ -1,120 +1,67 @@
 'use strict'
 
 const debug = require('debug')
-const log = Object.assign(debug('libp2p:peer-store:proto-book'), {
-  error: debug('libp2p:peer-store:proto-book:err')
-})
 const errcode = require('err-code')
+const { codes } = require('../errors')
+const PeerId = require('peer-id')
 const { equals: uint8ArrayEquals } = require('uint8arrays/equals')
 
-const PeerId = require('peer-id')
+const log = Object.assign(debug('libp2p:peer-store:metadata-book'), {
-
+  error: debug('libp2p:peer-store:metadata-book:err')
-const Book = require('./book')
+})
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
 
 /**
- * @typedef {import('./')} PeerStore
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').MetadataBook} MetadataBook
  */
 
+const EVENT_NAME = 'change:metadata'
+
 /**
- * @extends {Book}
+ * @implements {MetadataBook}
- *
- * @fires MetadataBook#change:metadata
  */
-class MetadataBook extends Book {
+class PeerStoreMetadataBook {
   /**
    * The MetadataBook is responsible for keeping the known supported
-   * protocols of a peer.
+   * protocols of a peer
    *
-   * @class
+   * @param {PeerStore["emit"]} emit
-   * @param {PeerStore} peerStore
+   * @param {import('./types').Store} store
    */
-  constructor (peerStore) {
+  constructor (emit, store) {
-    /**
+    this._emit = emit
-     * PeerStore Event emitter, used by the MetadataBook to emit:
+    this._store = store
-     * "change:metadata" - emitted when the known metadata of a peer change.
-     */
-    super({
-      peerStore,
-      eventName: 'change:metadata',
-      eventProperty: 'metadata'
-    })
-
-    /**
-     * Map known peers to their known protocols.
-     *
-     * @type {Map<string, Map<string, Uint8Array>>}
-     */
-    this.data = new Map()
   }
 
   /**
-   * Set metadata key and value of a provided peer.
+   * Get the known data of a provided peer
    *
-   * @override
    * @param {PeerId} peerId
-   * @param {string} key - metadata key
-   * @param {Uint8Array} value - metadata value
-   * @returns {MetadataBook}
    */
-  // @ts-ignore override with more then the parameters expected in Book
+  async get (peerId) {
-  set (peerId, key, value) {
     if (!PeerId.isPeerId(peerId)) {
       log.error('peerId must be an instance of peer-id to store data')
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    if (typeof key !== 'string' || !(value instanceof Uint8Array)) {
+    log('get await read lock')
-      log.error('valid key and value must be provided to store data')
+    const release = await this._store.lock.readLock()
-      throw errcode(new Error('valid key and value must be provided'), ERR_INVALID_PARAMETERS)
+    log('get got read lock')
+
+    try {
+      const peer = await this._store.load(peerId)
+
+      return peer.metadata
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('get release read lock')
+      release()
     }
 
-    this._setValue(peerId, key, value)
+    return new Map()
-
-    return this
-  }
-
-  /**
-   * Set data into the datastructure
-   *
-   * @param {PeerId} peerId
-   * @param {string} key
-   * @param {Uint8Array} value
-   * @param {object} [opts]
-   * @param {boolean} [opts.emit]
-   */
-  _setValue (peerId, key, value, { emit = true } = {}) {
-    const id = peerId.toB58String()
-    const rec = this.data.get(id) || new Map()
-    const recMap = rec.get(key)
-
-    // Already exists and is equal
-    if (recMap && uint8ArrayEquals(value, recMap)) {
-      log(`the metadata provided to store is equal to the already stored for ${id} on ${key}`)
-      return
-    }
-
-    rec.set(key, value)
-    this.data.set(id, rec)
-
-    emit && this._emit(peerId, key)
-  }
-
-  /**
-   * Get the known data of a provided peer.
-   *
-   * @param {PeerId} peerId
-   * @returns {Map<string, Uint8Array>|undefined}
-   */
-  get (peerId) {
-    if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
-    }
-
-    return this.data.get(peerId.toB58String())
   }
 
   /**
@@ -122,59 +69,182 @@ class MetadataBook extends Book {
    *
    * @param {PeerId} peerId
    * @param {string} key
-   * @returns {Uint8Array | undefined}
    */
-  getValue (peerId, key) {
+  async getValue (peerId, key) {
     if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const rec = this.data.get(peerId.toB58String())
+    log('getValue await read lock')
-    return rec && rec.get(key)
+    const release = await this._store.lock.readLock()
+    log('getValue got read lock')
+
+    try {
+      const peer = await this._store.load(peerId)
+
+      return peer.metadata.get(key)
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('getValue release write lock')
+      release()
+    }
   }
 
   /**
-   * Deletes the provided peer from the book.
+   * @param {PeerId} peerId
+   * @param {Map<string, Uint8Array>} metadata
+   */
+  async set (peerId, metadata) {
+    if (!PeerId.isPeerId(peerId)) {
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    if (!metadata || !(metadata instanceof Map)) {
+      log.error('valid metadata must be provided to store data')
+      throw errcode(new Error('valid metadata must be provided'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('set await write lock')
+    const release = await this._store.lock.writeLock()
+    log('set got write lock')
+
+    try {
+      await this._store.mergeOrCreate(peerId, {
+        metadata
+      })
+    } finally {
+      log('set release write lock')
+      release()
+    }
+
+    this._emit(EVENT_NAME, { peerId, metadata })
+  }
+
+  /**
+   * Set metadata key and value of a provided peer
    *
    * @param {PeerId} peerId
-   * @returns {boolean}
+   * @param {string} key - metadata key
+   * @param {Uint8Array} value - metadata value
    */
-  delete (peerId) {
+  async setValue (peerId, key, value) {
     if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    if (!this.data.delete(peerId.toB58String())) {
+    if (typeof key !== 'string' || !(value instanceof Uint8Array)) {
-      return false
+      log.error('valid key and value must be provided to store data')
+      throw errcode(new Error('valid key and value must be provided'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    this._emit(peerId)
+    log('setValue await write lock')
+    const release = await this._store.lock.writeLock()
+    log('setValue got write lock')
 
-    return true
+    let updatedPeer
+
+    try {
+      try {
+        const existingPeer = await this._store.load(peerId)
+        const existingValue = existingPeer.metadata.get(key)
+
+        if (existingValue != null && uint8ArrayEquals(value, existingValue)) {
+          return
+        }
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
+
+      updatedPeer = await this._store.mergeOrCreate(peerId, {
+        metadata: new Map([[key, value]])
+      })
+    } finally {
+      log('setValue release write lock')
+      release()
+    }
+
+    this._emit(EVENT_NAME, { peerId, metadata: updatedPeer.metadata })
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  async delete (peerId) {
+    if (!PeerId.isPeerId(peerId)) {
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('delete await write lock')
+    const release = await this._store.lock.writeLock()
+    log('delete got write lock')
+
+    let has
+
+    try {
+      has = await this._store.has(peerId)
+
+      if (has) {
+        await this._store.patch(peerId, {
+          metadata: new Map()
+        })
+      }
+    } finally {
+      log('delete release write lock')
+      release()
+    }
+
+    if (has) {
+      this._emit(EVENT_NAME, { peerId, metadata: new Map() })
+    }
   }
 
   /**
-   * Deletes the provided peer metadata key from the book.
-   *
    * @param {PeerId} peerId
    * @param {string} key
-   * @returns {boolean}
    */
-  deleteValue (peerId, key) {
+  async deleteValue (peerId, key) {
     if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const rec = this.data.get(peerId.toB58String())
+    log('deleteValue await write lock')
+    const release = await this._store.lock.writeLock()
+    log('deleteValue got write lock')
 
-    if (!rec || !rec.delete(key)) {
+    let metadata
-      return false
+
+    try {
+      const peer = await this._store.load(peerId)
+      metadata = peer.metadata
+
+      metadata.delete(key)
+
+      await this._store.patch(peerId, {
+        metadata
+      })
+    } catch (/** @type {any} **/ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('deleteValue release write lock')
+      release()
     }
 
-    this._emit(peerId, key)
+    if (metadata) {
-
+      this._emit(EVENT_NAME, { peerId, metadata })
-    return true
+    }
   }
 }
 
-module.exports = MetadataBook
+module.exports = PeerStoreMetadataBook

src/peer-store/pb/peer.d.ts

@@ -0,0 +1,222 @@
+import * as $protobuf from "protobufjs";
+/** Properties of a Peer. */
+export interface IPeer {
+
+    /** Peer addresses */
+    addresses?: (IAddress[]|null);
+
+    /** Peer protocols */
+    protocols?: (string[]|null);
+
+    /** Peer metadata */
+    metadata?: (IMetadata[]|null);
+
+    /** Peer pubKey */
+    pubKey?: (Uint8Array|null);
+
+    /** Peer peerRecordEnvelope */
+    peerRecordEnvelope?: (Uint8Array|null);
+}
+
+/** Represents a Peer. */
+export class Peer implements IPeer {
+
+    /**
+     * Constructs a new Peer.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IPeer);
+
+    /** Peer addresses. */
+    public addresses: IAddress[];
+
+    /** Peer protocols. */
+    public protocols: string[];
+
+    /** Peer metadata. */
+    public metadata: IMetadata[];
+
+    /** Peer pubKey. */
+    public pubKey?: (Uint8Array|null);
+
+    /** Peer peerRecordEnvelope. */
+    public peerRecordEnvelope?: (Uint8Array|null);
+
+    /** Peer _pubKey. */
+    public _pubKey?: "pubKey";
+
+    /** Peer _peerRecordEnvelope. */
+    public _peerRecordEnvelope?: "peerRecordEnvelope";
+
+    /**
+     * Encodes the specified Peer message. Does not implicitly {@link Peer.verify|verify} messages.
+     * @param m Peer message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IPeer, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes a Peer message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns Peer
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): Peer;
+
+    /**
+     * Creates a Peer message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns Peer
+     */
+    public static fromObject(d: { [k: string]: any }): Peer;
+
+    /**
+     * Creates a plain object from a Peer message. Also converts values to other types if specified.
+     * @param m Peer
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: Peer, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this Peer to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+/** Properties of an Address. */
+export interface IAddress {
+
+    /** Address multiaddr */
+    multiaddr?: (Uint8Array|null);
+
+    /** Address isCertified */
+    isCertified?: (boolean|null);
+}
+
+/** Represents an Address. */
+export class Address implements IAddress {
+
+    /**
+     * Constructs a new Address.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IAddress);
+
+    /** Address multiaddr. */
+    public multiaddr: Uint8Array;
+
+    /** Address isCertified. */
+    public isCertified?: (boolean|null);
+
+    /** Address _isCertified. */
+    public _isCertified?: "isCertified";
+
+    /**
+     * Encodes the specified Address message. Does not implicitly {@link Address.verify|verify} messages.
+     * @param m Address message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IAddress, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes an Address message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns Address
+     * @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): Address;
+
+    /**
+     * Creates an Address message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns Address
+     */
+    public static fromObject(d: { [k: string]: any }): Address;
+
+    /**
+     * Creates a plain object from an Address message. Also converts values to other types if specified.
+     * @param m Address
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: Address, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this Address to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+/** Properties of a Metadata. */
+export interface IMetadata {
+
+    /** Metadata key */
+    key?: (string|null);
+
+    /** Metadata value */
+    value?: (Uint8Array|null);
+}
+
+/** Represents a Metadata. */
+export class Metadata implements IMetadata {
+
+    /**
+     * Constructs a new Metadata.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IMetadata);
+
+    /** Metadata key. */
+    public key: string;
+
+    /** Metadata value. */
+    public value: Uint8Array;
+
+    /**
+     * Encodes the specified Metadata message. Does not implicitly {@link Metadata.verify|verify} messages.
+     * @param m Metadata message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IMetadata, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes a Metadata message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns Metadata
+     * @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): Metadata;
+
+    /**
+     * Creates a Metadata message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns Metadata
+     */
+    public static fromObject(d: { [k: string]: any }): Metadata;
+
+    /**
+     * Creates a plain object from a Metadata message. Also converts values to other types if specified.
+     * @param m Metadata
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: Metadata, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this Metadata to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}

src/peer-store/pb/peer.js

@@ -0,0 +1,643 @@
+/*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-peer"] || ($protobuf.roots["libp2p-peer"] = {});
+
+$root.Peer = (function() {
+
+    /**
+     * Properties of a Peer.
+     * @exports IPeer
+     * @interface IPeer
+     * @property {Array.<IAddress>|null} [addresses] Peer addresses
+     * @property {Array.<string>|null} [protocols] Peer protocols
+     * @property {Array.<IMetadata>|null} [metadata] Peer metadata
+     * @property {Uint8Array|null} [pubKey] Peer pubKey
+     * @property {Uint8Array|null} [peerRecordEnvelope] Peer peerRecordEnvelope
+     */
+
+    /**
+     * Constructs a new Peer.
+     * @exports Peer
+     * @classdesc Represents a Peer.
+     * @implements IPeer
+     * @constructor
+     * @param {IPeer=} [p] Properties to set
+     */
+    function Peer(p) {
+        this.addresses = [];
+        this.protocols = [];
+        this.metadata = [];
+        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]];
+    }
+
+    /**
+     * Peer addresses.
+     * @member {Array.<IAddress>} addresses
+     * @memberof Peer
+     * @instance
+     */
+    Peer.prototype.addresses = $util.emptyArray;
+
+    /**
+     * Peer protocols.
+     * @member {Array.<string>} protocols
+     * @memberof Peer
+     * @instance
+     */
+    Peer.prototype.protocols = $util.emptyArray;
+
+    /**
+     * Peer metadata.
+     * @member {Array.<IMetadata>} metadata
+     * @memberof Peer
+     * @instance
+     */
+    Peer.prototype.metadata = $util.emptyArray;
+
+    /**
+     * Peer pubKey.
+     * @member {Uint8Array|null|undefined} pubKey
+     * @memberof Peer
+     * @instance
+     */
+    Peer.prototype.pubKey = null;
+
+    /**
+     * Peer peerRecordEnvelope.
+     * @member {Uint8Array|null|undefined} peerRecordEnvelope
+     * @memberof Peer
+     * @instance
+     */
+    Peer.prototype.peerRecordEnvelope = null;
+
+    // OneOf field names bound to virtual getters and setters
+    var $oneOfFields;
+
+    /**
+     * Peer _pubKey.
+     * @member {"pubKey"|undefined} _pubKey
+     * @memberof Peer
+     * @instance
+     */
+    Object.defineProperty(Peer.prototype, "_pubKey", {
+        get: $util.oneOfGetter($oneOfFields = ["pubKey"]),
+        set: $util.oneOfSetter($oneOfFields)
+    });
+
+    /**
+     * Peer _peerRecordEnvelope.
+     * @member {"peerRecordEnvelope"|undefined} _peerRecordEnvelope
+     * @memberof Peer
+     * @instance
+     */
+    Object.defineProperty(Peer.prototype, "_peerRecordEnvelope", {
+        get: $util.oneOfGetter($oneOfFields = ["peerRecordEnvelope"]),
+        set: $util.oneOfSetter($oneOfFields)
+    });
+
+    /**
+     * Encodes the specified Peer message. Does not implicitly {@link Peer.verify|verify} messages.
+     * @function encode
+     * @memberof Peer
+     * @static
+     * @param {IPeer} m Peer message or plain object to encode
+     * @param {$protobuf.Writer} [w] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    Peer.encode = function encode(m, w) {
+        if (!w)
+            w = $Writer.create();
+        if (m.addresses != null && m.addresses.length) {
+            for (var i = 0; i < m.addresses.length; ++i)
+                $root.Address.encode(m.addresses[i], w.uint32(10).fork()).ldelim();
+        }
+        if (m.protocols != null && m.protocols.length) {
+            for (var i = 0; i < m.protocols.length; ++i)
+                w.uint32(18).string(m.protocols[i]);
+        }
+        if (m.metadata != null && m.metadata.length) {
+            for (var i = 0; i < m.metadata.length; ++i)
+                $root.Metadata.encode(m.metadata[i], w.uint32(26).fork()).ldelim();
+        }
+        if (m.pubKey != null && Object.hasOwnProperty.call(m, "pubKey"))
+            w.uint32(34).bytes(m.pubKey);
+        if (m.peerRecordEnvelope != null && Object.hasOwnProperty.call(m, "peerRecordEnvelope"))
+            w.uint32(42).bytes(m.peerRecordEnvelope);
+        return w;
+    };
+
+    /**
+     * Decodes a Peer message from the specified reader or buffer.
+     * @function decode
+     * @memberof Peer
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+     * @param {number} [l] Message length if known beforehand
+     * @returns {Peer} Peer
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    Peer.decode = function decode(r, l) {
+        if (!(r instanceof $Reader))
+            r = $Reader.create(r);
+        var c = l === undefined ? r.len : r.pos + l, m = new $root.Peer();
+        while (r.pos < c) {
+            var t = r.uint32();
+            switch (t >>> 3) {
+            case 1:
+                if (!(m.addresses && m.addresses.length))
+                    m.addresses = [];
+                m.addresses.push($root.Address.decode(r, r.uint32()));
+                break;
+            case 2:
+                if (!(m.protocols && m.protocols.length))
+                    m.protocols = [];
+                m.protocols.push(r.string());
+                break;
+            case 3:
+                if (!(m.metadata && m.metadata.length))
+                    m.metadata = [];
+                m.metadata.push($root.Metadata.decode(r, r.uint32()));
+                break;
+            case 4:
+                m.pubKey = r.bytes();
+                break;
+            case 5:
+                m.peerRecordEnvelope = r.bytes();
+                break;
+            default:
+                r.skipType(t & 7);
+                break;
+            }
+        }
+        return m;
+    };
+
+    /**
+     * Creates a Peer message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof Peer
+     * @static
+     * @param {Object.<string,*>} d Plain object
+     * @returns {Peer} Peer
+     */
+    Peer.fromObject = function fromObject(d) {
+        if (d instanceof $root.Peer)
+            return d;
+        var m = new $root.Peer();
+        if (d.addresses) {
+            if (!Array.isArray(d.addresses))
+                throw TypeError(".Peer.addresses: array expected");
+            m.addresses = [];
+            for (var i = 0; i < d.addresses.length; ++i) {
+                if (typeof d.addresses[i] !== "object")
+                    throw TypeError(".Peer.addresses: object expected");
+                m.addresses[i] = $root.Address.fromObject(d.addresses[i]);
+            }
+        }
+        if (d.protocols) {
+            if (!Array.isArray(d.protocols))
+                throw TypeError(".Peer.protocols: array expected");
+            m.protocols = [];
+            for (var i = 0; i < d.protocols.length; ++i) {
+                m.protocols[i] = String(d.protocols[i]);
+            }
+        }
+        if (d.metadata) {
+            if (!Array.isArray(d.metadata))
+                throw TypeError(".Peer.metadata: array expected");
+            m.metadata = [];
+            for (var i = 0; i < d.metadata.length; ++i) {
+                if (typeof d.metadata[i] !== "object")
+                    throw TypeError(".Peer.metadata: object expected");
+                m.metadata[i] = $root.Metadata.fromObject(d.metadata[i]);
+            }
+        }
+        if (d.pubKey != null) {
+            if (typeof d.pubKey === "string")
+                $util.base64.decode(d.pubKey, m.pubKey = $util.newBuffer($util.base64.length(d.pubKey)), 0);
+            else if (d.pubKey.length)
+                m.pubKey = d.pubKey;
+        }
+        if (d.peerRecordEnvelope != null) {
+            if (typeof d.peerRecordEnvelope === "string")
+                $util.base64.decode(d.peerRecordEnvelope, m.peerRecordEnvelope = $util.newBuffer($util.base64.length(d.peerRecordEnvelope)), 0);
+            else if (d.peerRecordEnvelope.length)
+                m.peerRecordEnvelope = d.peerRecordEnvelope;
+        }
+        return m;
+    };
+
+    /**
+     * Creates a plain object from a Peer message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof Peer
+     * @static
+     * @param {Peer} m Peer
+     * @param {$protobuf.IConversionOptions} [o] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    Peer.toObject = function toObject(m, o) {
+        if (!o)
+            o = {};
+        var d = {};
+        if (o.arrays || o.defaults) {
+            d.addresses = [];
+            d.protocols = [];
+            d.metadata = [];
+        }
+        if (m.addresses && m.addresses.length) {
+            d.addresses = [];
+            for (var j = 0; j < m.addresses.length; ++j) {
+                d.addresses[j] = $root.Address.toObject(m.addresses[j], o);
+            }
+        }
+        if (m.protocols && m.protocols.length) {
+            d.protocols = [];
+            for (var j = 0; j < m.protocols.length; ++j) {
+                d.protocols[j] = m.protocols[j];
+            }
+        }
+        if (m.metadata && m.metadata.length) {
+            d.metadata = [];
+            for (var j = 0; j < m.metadata.length; ++j) {
+                d.metadata[j] = $root.Metadata.toObject(m.metadata[j], o);
+            }
+        }
+        if (m.pubKey != null && m.hasOwnProperty("pubKey")) {
+            d.pubKey = o.bytes === String ? $util.base64.encode(m.pubKey, 0, m.pubKey.length) : o.bytes === Array ? Array.prototype.slice.call(m.pubKey) : m.pubKey;
+            if (o.oneofs)
+                d._pubKey = "pubKey";
+        }
+        if (m.peerRecordEnvelope != null && m.hasOwnProperty("peerRecordEnvelope")) {
+            d.peerRecordEnvelope = o.bytes === String ? $util.base64.encode(m.peerRecordEnvelope, 0, m.peerRecordEnvelope.length) : o.bytes === Array ? Array.prototype.slice.call(m.peerRecordEnvelope) : m.peerRecordEnvelope;
+            if (o.oneofs)
+                d._peerRecordEnvelope = "peerRecordEnvelope";
+        }
+        return d;
+    };
+
+    /**
+     * Converts this Peer to JSON.
+     * @function toJSON
+     * @memberof Peer
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    Peer.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    return Peer;
+})();
+
+$root.Address = (function() {
+
+    /**
+     * Properties of an Address.
+     * @exports IAddress
+     * @interface IAddress
+     * @property {Uint8Array|null} [multiaddr] Address multiaddr
+     * @property {boolean|null} [isCertified] Address isCertified
+     */
+
+    /**
+     * Constructs a new Address.
+     * @exports Address
+     * @classdesc Represents an Address.
+     * @implements IAddress
+     * @constructor
+     * @param {IAddress=} [p] Properties to set
+     */
+    function Address(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]];
+    }
+
+    /**
+     * Address multiaddr.
+     * @member {Uint8Array} multiaddr
+     * @memberof Address
+     * @instance
+     */
+    Address.prototype.multiaddr = $util.newBuffer([]);
+
+    /**
+     * Address isCertified.
+     * @member {boolean|null|undefined} isCertified
+     * @memberof Address
+     * @instance
+     */
+    Address.prototype.isCertified = null;
+
+    // OneOf field names bound to virtual getters and setters
+    var $oneOfFields;
+
+    /**
+     * Address _isCertified.
+     * @member {"isCertified"|undefined} _isCertified
+     * @memberof Address
+     * @instance
+     */
+    Object.defineProperty(Address.prototype, "_isCertified", {
+        get: $util.oneOfGetter($oneOfFields = ["isCertified"]),
+        set: $util.oneOfSetter($oneOfFields)
+    });
+
+    /**
+     * Encodes the specified Address message. Does not implicitly {@link Address.verify|verify} messages.
+     * @function encode
+     * @memberof Address
+     * @static
+     * @param {IAddress} m Address message or plain object to encode
+     * @param {$protobuf.Writer} [w] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    Address.encode = function encode(m, w) {
+        if (!w)
+            w = $Writer.create();
+        if (m.multiaddr != null && Object.hasOwnProperty.call(m, "multiaddr"))
+            w.uint32(10).bytes(m.multiaddr);
+        if (m.isCertified != null && Object.hasOwnProperty.call(m, "isCertified"))
+            w.uint32(16).bool(m.isCertified);
+        return w;
+    };
+
+    /**
+     * Decodes an Address message from the specified reader or buffer.
+     * @function decode
+     * @memberof Address
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+     * @param {number} [l] Message length if known beforehand
+     * @returns {Address} Address
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    Address.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.Address();
+        while (r.pos < c) {
+            var t = r.uint32();
+            switch (t >>> 3) {
+            case 1:
+                m.multiaddr = r.bytes();
+                break;
+            case 2:
+                m.isCertified = r.bool();
+                break;
+            default:
+                r.skipType(t & 7);
+                break;
+            }
+        }
+        return m;
+    };
+
+    /**
+     * Creates an Address message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof Address
+     * @static
+     * @param {Object.<string,*>} d Plain object
+     * @returns {Address} Address
+     */
+    Address.fromObject = function fromObject(d) {
+        if (d instanceof $root.Address)
+            return d;
+        var m = new $root.Address();
+        if (d.multiaddr != null) {
+            if (typeof d.multiaddr === "string")
+                $util.base64.decode(d.multiaddr, m.multiaddr = $util.newBuffer($util.base64.length(d.multiaddr)), 0);
+            else if (d.multiaddr.length)
+                m.multiaddr = d.multiaddr;
+        }
+        if (d.isCertified != null) {
+            m.isCertified = Boolean(d.isCertified);
+        }
+        return m;
+    };
+
+    /**
+     * Creates a plain object from an Address message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof Address
+     * @static
+     * @param {Address} m Address
+     * @param {$protobuf.IConversionOptions} [o] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    Address.toObject = function toObject(m, o) {
+        if (!o)
+            o = {};
+        var d = {};
+        if (o.defaults) {
+            if (o.bytes === String)
+                d.multiaddr = "";
+            else {
+                d.multiaddr = [];
+                if (o.bytes !== Array)
+                    d.multiaddr = $util.newBuffer(d.multiaddr);
+            }
+        }
+        if (m.multiaddr != null && m.hasOwnProperty("multiaddr")) {
+            d.multiaddr = o.bytes === String ? $util.base64.encode(m.multiaddr, 0, m.multiaddr.length) : o.bytes === Array ? Array.prototype.slice.call(m.multiaddr) : m.multiaddr;
+        }
+        if (m.isCertified != null && m.hasOwnProperty("isCertified")) {
+            d.isCertified = m.isCertified;
+            if (o.oneofs)
+                d._isCertified = "isCertified";
+        }
+        return d;
+    };
+
+    /**
+     * Converts this Address to JSON.
+     * @function toJSON
+     * @memberof Address
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    Address.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    return Address;
+})();
+
+$root.Metadata = (function() {
+
+    /**
+     * Properties of a Metadata.
+     * @exports IMetadata
+     * @interface IMetadata
+     * @property {string|null} [key] Metadata key
+     * @property {Uint8Array|null} [value] Metadata value
+     */
+
+    /**
+     * Constructs a new Metadata.
+     * @exports Metadata
+     * @classdesc Represents a Metadata.
+     * @implements IMetadata
+     * @constructor
+     * @param {IMetadata=} [p] Properties to set
+     */
+    function Metadata(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]];
+    }
+
+    /**
+     * Metadata key.
+     * @member {string} key
+     * @memberof Metadata
+     * @instance
+     */
+    Metadata.prototype.key = "";
+
+    /**
+     * Metadata value.
+     * @member {Uint8Array} value
+     * @memberof Metadata
+     * @instance
+     */
+    Metadata.prototype.value = $util.newBuffer([]);
+
+    /**
+     * Encodes the specified Metadata message. Does not implicitly {@link Metadata.verify|verify} messages.
+     * @function encode
+     * @memberof Metadata
+     * @static
+     * @param {IMetadata} m Metadata message or plain object to encode
+     * @param {$protobuf.Writer} [w] Writer to encode to
+     * @returns {$protobuf.Writer} Writer
+     */
+    Metadata.encode = function encode(m, w) {
+        if (!w)
+            w = $Writer.create();
+        if (m.key != null && Object.hasOwnProperty.call(m, "key"))
+            w.uint32(10).string(m.key);
+        if (m.value != null && Object.hasOwnProperty.call(m, "value"))
+            w.uint32(18).bytes(m.value);
+        return w;
+    };
+
+    /**
+     * Decodes a Metadata message from the specified reader or buffer.
+     * @function decode
+     * @memberof Metadata
+     * @static
+     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
+     * @param {number} [l] Message length if known beforehand
+     * @returns {Metadata} Metadata
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    Metadata.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.Metadata();
+        while (r.pos < c) {
+            var t = r.uint32();
+            switch (t >>> 3) {
+            case 1:
+                m.key = r.string();
+                break;
+            case 2:
+                m.value = r.bytes();
+                break;
+            default:
+                r.skipType(t & 7);
+                break;
+            }
+        }
+        return m;
+    };
+
+    /**
+     * Creates a Metadata message from a plain object. Also converts values to their respective internal types.
+     * @function fromObject
+     * @memberof Metadata
+     * @static
+     * @param {Object.<string,*>} d Plain object
+     * @returns {Metadata} Metadata
+     */
+    Metadata.fromObject = function fromObject(d) {
+        if (d instanceof $root.Metadata)
+            return d;
+        var m = new $root.Metadata();
+        if (d.key != null) {
+            m.key = String(d.key);
+        }
+        if (d.value != null) {
+            if (typeof d.value === "string")
+                $util.base64.decode(d.value, m.value = $util.newBuffer($util.base64.length(d.value)), 0);
+            else if (d.value.length)
+                m.value = d.value;
+        }
+        return m;
+    };
+
+    /**
+     * Creates a plain object from a Metadata message. Also converts values to other types if specified.
+     * @function toObject
+     * @memberof Metadata
+     * @static
+     * @param {Metadata} m Metadata
+     * @param {$protobuf.IConversionOptions} [o] Conversion options
+     * @returns {Object.<string,*>} Plain object
+     */
+    Metadata.toObject = function toObject(m, o) {
+        if (!o)
+            o = {};
+        var d = {};
+        if (o.defaults) {
+            d.key = "";
+            if (o.bytes === String)
+                d.value = "";
+            else {
+                d.value = [];
+                if (o.bytes !== Array)
+                    d.value = $util.newBuffer(d.value);
+            }
+        }
+        if (m.key != null && m.hasOwnProperty("key")) {
+            d.key = m.key;
+        }
+        if (m.value != null && m.hasOwnProperty("value")) {
+            d.value = o.bytes === String ? $util.base64.encode(m.value, 0, m.value.length) : o.bytes === Array ? Array.prototype.slice.call(m.value) : m.value;
+        }
+        return d;
+    };
+
+    /**
+     * Converts this Metadata to JSON.
+     * @function toJSON
+     * @memberof Metadata
+     * @instance
+     * @returns {Object.<string,*>} JSON object
+     */
+    Metadata.prototype.toJSON = function toJSON() {
+        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
+    };
+
+    return Metadata;
+})();
+
+module.exports = $root;

src/peer-store/pb/peer.proto

@@ -0,0 +1,31 @@
+syntax = "proto3";
+
+message Peer {
+  // Multiaddrs we know about
+  repeated Address addresses = 1;
+
+  // The protocols the peer supports
+  repeated string protocols = 2;
+
+  // Any peer metadata
+  repeated Metadata metadata = 3;
+
+  // The public key of the peer
+  optional bytes pub_key = 4;
+
+  // The most recently received signed PeerRecord
+  optional bytes peer_record_envelope = 5;
+}
+
+// Address represents a single multiaddr
+message Address {
+  bytes multiaddr = 1;
+
+  // Flag to indicate if the address comes from a certified source
+  optional bool isCertified = 2;
+}
+
+message Metadata {
+  string key = 1;
+  bytes value = 2;
+}

src/peer-store/persistent/consts.js

@@ -1,15 +0,0 @@
-'use strict'
-
-module.exports.NAMESPACE_COMMON = '/peers/'
-
-// /peers/protos/<b32 peer id no padding>
-module.exports.NAMESPACE_ADDRESS = '/peers/addrs/'
-
-// /peers/keys/<b32 peer id no padding>
-module.exports.NAMESPACE_KEYS = '/peers/keys/'
-
-// /peers/metadata/<b32 peer id no padding>/<key>
-module.exports.NAMESPACE_METADATA = '/peers/metadata/'
-
-// /peers/addrs/<b32 peer id no padding>
-module.exports.NAMESPACE_PROTOCOL = '/peers/protos/'

src/peer-store/persistent/index.js

@@ -1,408 +0,0 @@
-'use strict'
-
-const debug = require('debug')
-const log = Object.assign(debug('libp2p:persistent-peer-store'), {
-  error: debug('libp2p:persistent-peer-store:err')
-})
-const { Key } = require('interface-datastore/key')
-const { Multiaddr } = require('multiaddr')
-const PeerId = require('peer-id')
-const { base32 } = require('multiformats/bases/base32')
-
-const PeerStore = require('..')
-
-const {
-  NAMESPACE_ADDRESS,
-  NAMESPACE_COMMON,
-  NAMESPACE_KEYS,
-  NAMESPACE_METADATA,
-  NAMESPACE_PROTOCOL
-} = require('./consts')
-
-const { Addresses } = require('./pb/address-book')
-const { Protocols } = require('./pb/proto-book')
-
-/**
- * @typedef {import('interface-datastore').Batch} Batch
- * @typedef {import('../address-book.js').Address} Address
- */
-
-/**
- * @typedef {Object} PersistentPeerStoreProperties
- * @property {PeerId} peerId
- * @property {import('interface-datastore').Datastore} datastore
- *
- * @typedef {Object} PersistentPeerStoreOptions
- * @property {number} [threshold = 5] - Number of dirty peers allowed before commit data.
- */
-
-/**
- * Responsible for managing the persistence of data in the PeerStore.
- */
-class PersistentPeerStore extends PeerStore {
-  /**
-   * @class
-   * @param {PersistentPeerStoreProperties & PersistentPeerStoreOptions} properties
-   */
-  constructor ({ peerId, datastore, threshold = 5 }) {
-    super({ peerId })
-
-    /**
-     * Backend datastore used to persist data.
-     */
-    this._datastore = datastore
-
-    /**
-     * Peers modified after the latest data persisted.
-     */
-    this._dirtyPeers = new Set()
-
-    /**
-     * Peers metadata changed mapping peer identifers to metadata changed.
-     *
-     * @type {Map<string, Set<string>>}
-     */
-    this._dirtyMetadata = new Map()
-
-    this.threshold = threshold
-    this._addDirtyPeer = this._addDirtyPeer.bind(this)
-  }
-
-  /**
-   * Start Persistent PeerStore.
-   *
-   * @returns {Promise<void>}
-   */
-  async start () {
-    log('PeerStore is starting')
-
-    // Handlers for dirty peers
-    this.on('change:protocols', this._addDirtyPeer)
-    this.on('change:multiaddrs', this._addDirtyPeer)
-    this.on('change:pubkey', this._addDirtyPeerKey)
-    this.on('change:metadata', this._addDirtyPeerMetadata)
-
-    // Load data
-    for await (const entry of this._datastore.query({ prefix: NAMESPACE_COMMON })) {
-      await this._processDatastoreEntry(entry)
-    }
-
-    log('PeerStore started')
-  }
-
-  /**
-   * Stop Persistent PeerStore.
-   *
-   * @returns {Promise<void>}
-   */
-  async stop () {
-    log('PeerStore is stopping')
-    this.removeAllListeners()
-    await this._commitData()
-    log('PeerStore stopped')
-  }
-
-  /**
-   * Add modified peer to the dirty set
-   *
-   * @private
-   * @param {Object} params
-   * @param {PeerId} params.peerId
-   */
-  _addDirtyPeer ({ peerId }) {
-    const peerIdstr = peerId.toB58String()
-
-    log('add dirty peer', peerIdstr)
-    this._dirtyPeers.add(peerIdstr)
-
-    if (this._dirtyPeers.size >= this.threshold) {
-      // Commit current data
-      this._commitData().catch(err => {
-        log.error('error committing data', err)
-      })
-    }
-  }
-
-  /**
-   * Add modified peer key to the dirty set
-   *
-   * @private
-   * @param {Object} params
-   * @param {PeerId} params.peerId
-   */
-  _addDirtyPeerKey ({ peerId }) {
-    // Not add if inline key available
-    if (peerId.hasInlinePublicKey()) {
-      return
-    }
-
-    const peerIdstr = peerId.toB58String()
-
-    log('add dirty peer key', peerIdstr)
-    this._dirtyPeers.add(peerIdstr)
-
-    if (this._dirtyPeers.size >= this.threshold) {
-      // Commit current data
-      this._commitData().catch(err => {
-        log.error('error committing data', err)
-      })
-    }
-  }
-
-  /**
-   * Add modified metadata peer to the set.
-   *
-   * @private
-   * @param {Object} params
-   * @param {PeerId} params.peerId
-   * @param {string} params.metadata
-   */
-  _addDirtyPeerMetadata ({ peerId, metadata }) {
-    const peerIdstr = peerId.toB58String()
-
-    log('add dirty metadata peer', peerIdstr)
-    this._dirtyPeers.add(peerIdstr)
-
-    // Add dirty metadata key
-    const mData = this._dirtyMetadata.get(peerIdstr) || new Set()
-    mData.add(metadata)
-    this._dirtyMetadata.set(peerIdstr, mData)
-
-    if (this._dirtyPeers.size >= this.threshold) {
-      // Commit current data
-      this._commitData().catch(err => {
-        log.error('error committing data', err)
-      })
-    }
-  }
-
-  /**
-   * Add all the peers current data to a datastore batch and commit it.
-   *
-   * @private
-   * @returns {Promise<void>}
-   */
-  async _commitData () {
-    const commitPeers = Array.from(this._dirtyPeers)
-
-    if (!commitPeers.length) {
-      return
-    }
-
-    // Clear Dirty Peers set
-    this._dirtyPeers.clear()
-
-    log('create batch commit')
-    const batch = this._datastore.batch()
-    for (const peerIdStr of commitPeers) {
-      // PeerId
-      const peerId = this.keyBook.data.get(peerIdStr) || PeerId.createFromB58String(peerIdStr)
-
-      // Address Book
-      this._batchAddressBook(peerId, batch)
-
-      // Key Book
-      !peerId.hasInlinePublicKey() && this._batchKeyBook(peerId, batch)
-
-      // Metadata Book
-      this._batchMetadataBook(peerId, batch)
-
-      // Proto Book
-      this._batchProtoBook(peerId, batch)
-    }
-
-    await batch.commit()
-    log('batch committed')
-  }
-
-  /**
-   * Add address book data of the peer to the batch.
-   *
-   * @private
-   * @param {PeerId} peerId
-   * @param {Batch} batch
-   */
-  _batchAddressBook (peerId, batch) {
-    const b32key = peerId.toString()
-    const key = new Key(`${NAMESPACE_ADDRESS}${b32key}`)
-
-    const entry = this.addressBook.data.get(peerId.toB58String())
-
-    try {
-      // Deleted from the book
-      if (!entry) {
-        batch.delete(key)
-        return
-      }
-
-      const encodedData = Addresses.encode({
-        addrs: entry.addresses.map((address) => ({
-          multiaddr: address.multiaddr.bytes,
-          isCertified: address.isCertified
-        })),
-        certifiedRecord: entry.record
-          ? {
-              seq: entry.record.seqNumber,
-              raw: entry.record.raw
-            }
-          : undefined
-      }).finish()
-
-      batch.put(key, encodedData)
-    } catch (/** @type {any} */ err) {
-      log.error(err)
-    }
-  }
-
-  /**
-   * Add Key book data of the peer to the batch.
-   *
-   * @private
-   * @param {PeerId} peerId
-   * @param {Batch} batch
-   */
-  _batchKeyBook (peerId, batch) {
-    const b32key = peerId.toString()
-    const key = new Key(`${NAMESPACE_KEYS}${b32key}`)
-
-    try {
-      // Deleted from the book
-      if (!peerId.pubKey) {
-        batch.delete(key)
-        return
-      }
-
-      const encodedData = peerId.marshalPubKey()
-
-      batch.put(key, encodedData)
-    } catch (/** @type {any} */ err) {
-      log.error(err)
-    }
-  }
-
-  /**
-   * Add metadata book data of the peer to the batch.
-   *
-   * @private
-   * @param {PeerId} peerId
-   * @param {Batch} batch
-   */
-  _batchMetadataBook (peerId, batch) {
-    const b32key = peerId.toString()
-    const dirtyMetada = this._dirtyMetadata.get(peerId.toB58String()) || []
-
-    try {
-      dirtyMetada.forEach((/** @type {string} */ dirtyKey) => {
-        const key = new Key(`${NAMESPACE_METADATA}${b32key}/${dirtyKey}`)
-        const dirtyValue = this.metadataBook.getValue(peerId, dirtyKey)
-
-        if (dirtyValue) {
-          batch.put(key, dirtyValue)
-        } else {
-          batch.delete(key)
-        }
-      })
-    } catch (/** @type {any} */ err) {
-      log.error(err)
-    }
-  }
-
-  /**
-   * Add proto book data of the peer to the batch.
-   *
-   * @private
-   * @param {PeerId} peerId
-   * @param {Batch} batch
-   */
-  _batchProtoBook (peerId, batch) {
-    const b32key = peerId.toString()
-    const key = new Key(`${NAMESPACE_PROTOCOL}${b32key}`)
-
-    const protocols = this.protoBook.get(peerId)
-
-    try {
-      // Deleted from the book
-      if (!protocols) {
-        batch.delete(key)
-        return
-      }
-
-      const encodedData = Protocols.encode({ protocols }).finish()
-
-      batch.put(key, encodedData)
-    } catch (/** @type {any} */ err) {
-      log.error(err)
-    }
-  }
-
-  /**
-   * Process datastore entry and add its data to the correct book.
-   *
-   * @private
-   * @param {Object} params
-   * @param {Key} params.key - datastore key
-   * @param {Uint8Array} params.value - datastore value stored
-   * @returns {Promise<void>}
-   */
-  async _processDatastoreEntry ({ key, value }) {
-    try {
-      const keyParts = key.toString().split('/')
-      const peerId = PeerId.createFromBytes(base32.decode(keyParts[3]))
-
-      let decoded
-      switch (keyParts[2]) {
-        case 'addrs':
-          decoded = Addresses.decode(value)
-
-          // @ts-ignore protected function
-          this.addressBook._setData(
-            peerId,
-            {
-              addresses: decoded.addrs.map((address) => ({
-                multiaddr: new Multiaddr(address.multiaddr),
-                isCertified: Boolean(address.isCertified)
-              })),
-              record: decoded.certifiedRecord
-                ? {
-                    raw: decoded.certifiedRecord.raw,
-                    seqNumber: decoded.certifiedRecord.seq
-                  }
-                : undefined
-            },
-            { emit: false })
-          break
-        case 'keys':
-          decoded = await PeerId.createFromPubKey(value)
-
-          // @ts-ignore protected function
-          this.keyBook._setData(
-            decoded,
-            decoded,
-            { emit: false })
-          break
-        case 'metadata':
-          this.metadataBook._setValue(
-            peerId,
-            keyParts[4],
-            value,
-            { emit: false })
-          break
-        case 'protos':
-          decoded = Protocols.decode(value)
-
-          // @ts-ignore protected function
-          this.protoBook._setData(
-            peerId,
-            new Set(decoded.protocols),
-            { emit: false })
-          break
-        default:
-          log('invalid data persisted for: ', key.toString())
-      }
-    } catch (/** @type {any} */ err) {
-      log.error(err)
-    }
-  }
-}
-
-module.exports = PersistentPeerStore

src/peer-store/persistent/pb/address-book.d.ts

@@ -1,198 +0,0 @@
-import * as $protobuf from "protobufjs";
-/** Properties of an Addresses. */
-export interface IAddresses {
-
-    /** Addresses addrs */
-    addrs?: (Addresses.IAddress[]|null);
-
-    /** Addresses certifiedRecord */
-    certifiedRecord?: (Addresses.ICertifiedRecord|null);
-}
-
-/** Represents an Addresses. */
-export class Addresses implements IAddresses {
-
-    /**
-     * Constructs a new Addresses.
-     * @param [p] Properties to set
-     */
-    constructor(p?: IAddresses);
-
-    /** Addresses addrs. */
-    public addrs: Addresses.IAddress[];
-
-    /** Addresses certifiedRecord. */
-    public certifiedRecord?: (Addresses.ICertifiedRecord|null);
-
-    /**
-     * Encodes the specified Addresses message. Does not implicitly {@link Addresses.verify|verify} messages.
-     * @param m Addresses message or plain object to encode
-     * @param [w] Writer to encode to
-     * @returns Writer
-     */
-    public static encode(m: IAddresses, w?: $protobuf.Writer): $protobuf.Writer;
-
-    /**
-     * Decodes an Addresses message from the specified reader or buffer.
-     * @param r Reader or buffer to decode from
-     * @param [l] Message length if known beforehand
-     * @returns Addresses
-     * @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): Addresses;
-
-    /**
-     * Creates an Addresses message from a plain object. Also converts values to their respective internal types.
-     * @param d Plain object
-     * @returns Addresses
-     */
-    public static fromObject(d: { [k: string]: any }): Addresses;
-
-    /**
-     * Creates a plain object from an Addresses message. Also converts values to other types if specified.
-     * @param m Addresses
-     * @param [o] Conversion options
-     * @returns Plain object
-     */
-    public static toObject(m: Addresses, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-    /**
-     * Converts this Addresses to JSON.
-     * @returns JSON object
-     */
-    public toJSON(): { [k: string]: any };
-}
-
-export namespace Addresses {
-
-    /** Properties of an Address. */
-    interface IAddress {
-
-        /** Address multiaddr */
-        multiaddr?: (Uint8Array|null);
-
-        /** Address isCertified */
-        isCertified?: (boolean|null);
-    }
-
-    /** Represents an Address. */
-    class Address implements IAddress {
-
-        /**
-         * Constructs a new Address.
-         * @param [p] Properties to set
-         */
-        constructor(p?: Addresses.IAddress);
-
-        /** Address multiaddr. */
-        public multiaddr: Uint8Array;
-
-        /** Address isCertified. */
-        public isCertified: boolean;
-
-        /**
-         * Encodes the specified Address message. Does not implicitly {@link Addresses.Address.verify|verify} messages.
-         * @param m Address message or plain object to encode
-         * @param [w] Writer to encode to
-         * @returns Writer
-         */
-        public static encode(m: Addresses.IAddress, w?: $protobuf.Writer): $protobuf.Writer;
-
-        /**
-         * Decodes an Address message from the specified reader or buffer.
-         * @param r Reader or buffer to decode from
-         * @param [l] Message length if known beforehand
-         * @returns Address
-         * @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): Addresses.Address;
-
-        /**
-         * Creates an Address message from a plain object. Also converts values to their respective internal types.
-         * @param d Plain object
-         * @returns Address
-         */
-        public static fromObject(d: { [k: string]: any }): Addresses.Address;
-
-        /**
-         * Creates a plain object from an Address message. Also converts values to other types if specified.
-         * @param m Address
-         * @param [o] Conversion options
-         * @returns Plain object
-         */
-        public static toObject(m: Addresses.Address, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-        /**
-         * Converts this Address to JSON.
-         * @returns JSON object
-         */
-        public toJSON(): { [k: string]: any };
-    }
-
-    /** Properties of a CertifiedRecord. */
-    interface ICertifiedRecord {
-
-        /** CertifiedRecord seq */
-        seq?: (number|null);
-
-        /** CertifiedRecord raw */
-        raw?: (Uint8Array|null);
-    }
-
-    /** Represents a CertifiedRecord. */
-    class CertifiedRecord implements ICertifiedRecord {
-
-        /**
-         * Constructs a new CertifiedRecord.
-         * @param [p] Properties to set
-         */
-        constructor(p?: Addresses.ICertifiedRecord);
-
-        /** CertifiedRecord seq. */
-        public seq: number;
-
-        /** CertifiedRecord raw. */
-        public raw: Uint8Array;
-
-        /**
-         * Encodes the specified CertifiedRecord message. Does not implicitly {@link Addresses.CertifiedRecord.verify|verify} messages.
-         * @param m CertifiedRecord message or plain object to encode
-         * @param [w] Writer to encode to
-         * @returns Writer
-         */
-        public static encode(m: Addresses.ICertifiedRecord, w?: $protobuf.Writer): $protobuf.Writer;
-
-        /**
-         * Decodes a CertifiedRecord message from the specified reader or buffer.
-         * @param r Reader or buffer to decode from
-         * @param [l] Message length if known beforehand
-         * @returns CertifiedRecord
-         * @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): Addresses.CertifiedRecord;
-
-        /**
-         * Creates a CertifiedRecord message from a plain object. Also converts values to their respective internal types.
-         * @param d Plain object
-         * @returns CertifiedRecord
-         */
-        public static fromObject(d: { [k: string]: any }): Addresses.CertifiedRecord;
-
-        /**
-         * Creates a plain object from a CertifiedRecord message. Also converts values to other types if specified.
-         * @param m CertifiedRecord
-         * @param [o] Conversion options
-         * @returns Plain object
-         */
-        public static toObject(m: Addresses.CertifiedRecord, o?: $protobuf.IConversionOptions): { [k: string]: any };
-
-        /**
-         * Converts this CertifiedRecord to JSON.
-         * @returns JSON object
-         */
-        public toJSON(): { [k: string]: any };
-    }
-}

src/peer-store/persistent/pb/address-book.js

@@ -1,522 +0,0 @@
-/*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-address-book"] || ($protobuf.roots["libp2p-address-book"] = {});
-
-$root.Addresses = (function() {
-
-    /**
-     * Properties of an Addresses.
-     * @exports IAddresses
-     * @interface IAddresses
-     * @property {Array.<Addresses.IAddress>|null} [addrs] Addresses addrs
-     * @property {Addresses.ICertifiedRecord|null} [certifiedRecord] Addresses certifiedRecord
-     */
-
-    /**
-     * Constructs a new Addresses.
-     * @exports Addresses
-     * @classdesc Represents an Addresses.
-     * @implements IAddresses
-     * @constructor
-     * @param {IAddresses=} [p] Properties to set
-     */
-    function Addresses(p) {
-        this.addrs = [];
-        if (p)
-            for (var ks = Object.keys(p), i = 0; i < ks.length; ++i)
-                if (p[ks[i]] != null)
-                    this[ks[i]] = p[ks[i]];
-    }
-
-    /**
-     * Addresses addrs.
-     * @member {Array.<Addresses.IAddress>} addrs
-     * @memberof Addresses
-     * @instance
-     */
-    Addresses.prototype.addrs = $util.emptyArray;
-
-    /**
-     * Addresses certifiedRecord.
-     * @member {Addresses.ICertifiedRecord|null|undefined} certifiedRecord
-     * @memberof Addresses
-     * @instance
-     */
-    Addresses.prototype.certifiedRecord = null;
-
-    /**
-     * Encodes the specified Addresses message. Does not implicitly {@link Addresses.verify|verify} messages.
-     * @function encode
-     * @memberof Addresses
-     * @static
-     * @param {IAddresses} m Addresses message or plain object to encode
-     * @param {$protobuf.Writer} [w] Writer to encode to
-     * @returns {$protobuf.Writer} Writer
-     */
-    Addresses.encode = function encode(m, w) {
-        if (!w)
-            w = $Writer.create();
-        if (m.addrs != null && m.addrs.length) {
-            for (var i = 0; i < m.addrs.length; ++i)
-                $root.Addresses.Address.encode(m.addrs[i], w.uint32(10).fork()).ldelim();
-        }
-        if (m.certifiedRecord != null && Object.hasOwnProperty.call(m, "certifiedRecord"))
-            $root.Addresses.CertifiedRecord.encode(m.certifiedRecord, w.uint32(18).fork()).ldelim();
-        return w;
-    };
-
-    /**
-     * Decodes an Addresses message from the specified reader or buffer.
-     * @function decode
-     * @memberof Addresses
-     * @static
-     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
-     * @param {number} [l] Message length if known beforehand
-     * @returns {Addresses} Addresses
-     * @throws {Error} If the payload is not a reader or valid buffer
-     * @throws {$protobuf.util.ProtocolError} If required fields are missing
-     */
-    Addresses.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.Addresses();
-        while (r.pos < c) {
-            var t = r.uint32();
-            switch (t >>> 3) {
-            case 1:
-                if (!(m.addrs && m.addrs.length))
-                    m.addrs = [];
-                m.addrs.push($root.Addresses.Address.decode(r, r.uint32()));
-                break;
-            case 2:
-                m.certifiedRecord = $root.Addresses.CertifiedRecord.decode(r, r.uint32());
-                break;
-            default:
-                r.skipType(t & 7);
-                break;
-            }
-        }
-        return m;
-    };
-
-    /**
-     * Creates an Addresses message from a plain object. Also converts values to their respective internal types.
-     * @function fromObject
-     * @memberof Addresses
-     * @static
-     * @param {Object.<string,*>} d Plain object
-     * @returns {Addresses} Addresses
-     */
-    Addresses.fromObject = function fromObject(d) {
-        if (d instanceof $root.Addresses)
-            return d;
-        var m = new $root.Addresses();
-        if (d.addrs) {
-            if (!Array.isArray(d.addrs))
-                throw TypeError(".Addresses.addrs: array expected");
-            m.addrs = [];
-            for (var i = 0; i < d.addrs.length; ++i) {
-                if (typeof d.addrs[i] !== "object")
-                    throw TypeError(".Addresses.addrs: object expected");
-                m.addrs[i] = $root.Addresses.Address.fromObject(d.addrs[i]);
-            }
-        }
-        if (d.certifiedRecord != null) {
-            if (typeof d.certifiedRecord !== "object")
-                throw TypeError(".Addresses.certifiedRecord: object expected");
-            m.certifiedRecord = $root.Addresses.CertifiedRecord.fromObject(d.certifiedRecord);
-        }
-        return m;
-    };
-
-    /**
-     * Creates a plain object from an Addresses message. Also converts values to other types if specified.
-     * @function toObject
-     * @memberof Addresses
-     * @static
-     * @param {Addresses} m Addresses
-     * @param {$protobuf.IConversionOptions} [o] Conversion options
-     * @returns {Object.<string,*>} Plain object
-     */
-    Addresses.toObject = function toObject(m, o) {
-        if (!o)
-            o = {};
-        var d = {};
-        if (o.arrays || o.defaults) {
-            d.addrs = [];
-        }
-        if (o.defaults) {
-            d.certifiedRecord = null;
-        }
-        if (m.addrs && m.addrs.length) {
-            d.addrs = [];
-            for (var j = 0; j < m.addrs.length; ++j) {
-                d.addrs[j] = $root.Addresses.Address.toObject(m.addrs[j], o);
-            }
-        }
-        if (m.certifiedRecord != null && m.hasOwnProperty("certifiedRecord")) {
-            d.certifiedRecord = $root.Addresses.CertifiedRecord.toObject(m.certifiedRecord, o);
-        }
-        return d;
-    };
-
-    /**
-     * Converts this Addresses to JSON.
-     * @function toJSON
-     * @memberof Addresses
-     * @instance
-     * @returns {Object.<string,*>} JSON object
-     */
-    Addresses.prototype.toJSON = function toJSON() {
-        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
-    };
-
-    Addresses.Address = (function() {
-
-        /**
-         * Properties of an Address.
-         * @memberof Addresses
-         * @interface IAddress
-         * @property {Uint8Array|null} [multiaddr] Address multiaddr
-         * @property {boolean|null} [isCertified] Address isCertified
-         */
-
-        /**
-         * Constructs a new Address.
-         * @memberof Addresses
-         * @classdesc Represents an Address.
-         * @implements IAddress
-         * @constructor
-         * @param {Addresses.IAddress=} [p] Properties to set
-         */
-        function Address(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]];
-        }
-
-        /**
-         * Address multiaddr.
-         * @member {Uint8Array} multiaddr
-         * @memberof Addresses.Address
-         * @instance
-         */
-        Address.prototype.multiaddr = $util.newBuffer([]);
-
-        /**
-         * Address isCertified.
-         * @member {boolean} isCertified
-         * @memberof Addresses.Address
-         * @instance
-         */
-        Address.prototype.isCertified = false;
-
-        /**
-         * Encodes the specified Address message. Does not implicitly {@link Addresses.Address.verify|verify} messages.
-         * @function encode
-         * @memberof Addresses.Address
-         * @static
-         * @param {Addresses.IAddress} m Address message or plain object to encode
-         * @param {$protobuf.Writer} [w] Writer to encode to
-         * @returns {$protobuf.Writer} Writer
-         */
-        Address.encode = function encode(m, w) {
-            if (!w)
-                w = $Writer.create();
-            if (m.multiaddr != null && Object.hasOwnProperty.call(m, "multiaddr"))
-                w.uint32(10).bytes(m.multiaddr);
-            if (m.isCertified != null && Object.hasOwnProperty.call(m, "isCertified"))
-                w.uint32(16).bool(m.isCertified);
-            return w;
-        };
-
-        /**
-         * Decodes an Address message from the specified reader or buffer.
-         * @function decode
-         * @memberof Addresses.Address
-         * @static
-         * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
-         * @param {number} [l] Message length if known beforehand
-         * @returns {Addresses.Address} Address
-         * @throws {Error} If the payload is not a reader or valid buffer
-         * @throws {$protobuf.util.ProtocolError} If required fields are missing
-         */
-        Address.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.Addresses.Address();
-            while (r.pos < c) {
-                var t = r.uint32();
-                switch (t >>> 3) {
-                case 1:
-                    m.multiaddr = r.bytes();
-                    break;
-                case 2:
-                    m.isCertified = r.bool();
-                    break;
-                default:
-                    r.skipType(t & 7);
-                    break;
-                }
-            }
-            return m;
-        };
-
-        /**
-         * Creates an Address message from a plain object. Also converts values to their respective internal types.
-         * @function fromObject
-         * @memberof Addresses.Address
-         * @static
-         * @param {Object.<string,*>} d Plain object
-         * @returns {Addresses.Address} Address
-         */
-        Address.fromObject = function fromObject(d) {
-            if (d instanceof $root.Addresses.Address)
-                return d;
-            var m = new $root.Addresses.Address();
-            if (d.multiaddr != null) {
-                if (typeof d.multiaddr === "string")
-                    $util.base64.decode(d.multiaddr, m.multiaddr = $util.newBuffer($util.base64.length(d.multiaddr)), 0);
-                else if (d.multiaddr.length)
-                    m.multiaddr = d.multiaddr;
-            }
-            if (d.isCertified != null) {
-                m.isCertified = Boolean(d.isCertified);
-            }
-            return m;
-        };
-
-        /**
-         * Creates a plain object from an Address message. Also converts values to other types if specified.
-         * @function toObject
-         * @memberof Addresses.Address
-         * @static
-         * @param {Addresses.Address} m Address
-         * @param {$protobuf.IConversionOptions} [o] Conversion options
-         * @returns {Object.<string,*>} Plain object
-         */
-        Address.toObject = function toObject(m, o) {
-            if (!o)
-                o = {};
-            var d = {};
-            if (o.defaults) {
-                if (o.bytes === String)
-                    d.multiaddr = "";
-                else {
-                    d.multiaddr = [];
-                    if (o.bytes !== Array)
-                        d.multiaddr = $util.newBuffer(d.multiaddr);
-                }
-                d.isCertified = false;
-            }
-            if (m.multiaddr != null && m.hasOwnProperty("multiaddr")) {
-                d.multiaddr = o.bytes === String ? $util.base64.encode(m.multiaddr, 0, m.multiaddr.length) : o.bytes === Array ? Array.prototype.slice.call(m.multiaddr) : m.multiaddr;
-            }
-            if (m.isCertified != null && m.hasOwnProperty("isCertified")) {
-                d.isCertified = m.isCertified;
-            }
-            return d;
-        };
-
-        /**
-         * Converts this Address to JSON.
-         * @function toJSON
-         * @memberof Addresses.Address
-         * @instance
-         * @returns {Object.<string,*>} JSON object
-         */
-        Address.prototype.toJSON = function toJSON() {
-            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
-        };
-
-        return Address;
-    })();
-
-    Addresses.CertifiedRecord = (function() {
-
-        /**
-         * Properties of a CertifiedRecord.
-         * @memberof Addresses
-         * @interface ICertifiedRecord
-         * @property {number|null} [seq] CertifiedRecord seq
-         * @property {Uint8Array|null} [raw] CertifiedRecord raw
-         */
-
-        /**
-         * Constructs a new CertifiedRecord.
-         * @memberof Addresses
-         * @classdesc Represents a CertifiedRecord.
-         * @implements ICertifiedRecord
-         * @constructor
-         * @param {Addresses.ICertifiedRecord=} [p] Properties to set
-         */
-        function CertifiedRecord(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]];
-        }
-
-        /**
-         * CertifiedRecord seq.
-         * @member {number} seq
-         * @memberof Addresses.CertifiedRecord
-         * @instance
-         */
-        CertifiedRecord.prototype.seq = $util.Long ? $util.Long.fromBits(0,0,true) : 0;
-
-        /**
-         * CertifiedRecord raw.
-         * @member {Uint8Array} raw
-         * @memberof Addresses.CertifiedRecord
-         * @instance
-         */
-        CertifiedRecord.prototype.raw = $util.newBuffer([]);
-
-        /**
-         * Encodes the specified CertifiedRecord message. Does not implicitly {@link Addresses.CertifiedRecord.verify|verify} messages.
-         * @function encode
-         * @memberof Addresses.CertifiedRecord
-         * @static
-         * @param {Addresses.ICertifiedRecord} m CertifiedRecord message or plain object to encode
-         * @param {$protobuf.Writer} [w] Writer to encode to
-         * @returns {$protobuf.Writer} Writer
-         */
-        CertifiedRecord.encode = function encode(m, w) {
-            if (!w)
-                w = $Writer.create();
-            if (m.seq != null && Object.hasOwnProperty.call(m, "seq"))
-                w.uint32(8).uint64(m.seq);
-            if (m.raw != null && Object.hasOwnProperty.call(m, "raw"))
-                w.uint32(18).bytes(m.raw);
-            return w;
-        };
-
-        /**
-         * Decodes a CertifiedRecord message from the specified reader or buffer.
-         * @function decode
-         * @memberof Addresses.CertifiedRecord
-         * @static
-         * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
-         * @param {number} [l] Message length if known beforehand
-         * @returns {Addresses.CertifiedRecord} CertifiedRecord
-         * @throws {Error} If the payload is not a reader or valid buffer
-         * @throws {$protobuf.util.ProtocolError} If required fields are missing
-         */
-        CertifiedRecord.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.Addresses.CertifiedRecord();
-            while (r.pos < c) {
-                var t = r.uint32();
-                switch (t >>> 3) {
-                case 1:
-                    m.seq = r.uint64();
-                    break;
-                case 2:
-                    m.raw = r.bytes();
-                    break;
-                default:
-                    r.skipType(t & 7);
-                    break;
-                }
-            }
-            return m;
-        };
-
-        /**
-         * Creates a CertifiedRecord message from a plain object. Also converts values to their respective internal types.
-         * @function fromObject
-         * @memberof Addresses.CertifiedRecord
-         * @static
-         * @param {Object.<string,*>} d Plain object
-         * @returns {Addresses.CertifiedRecord} CertifiedRecord
-         */
-        CertifiedRecord.fromObject = function fromObject(d) {
-            if (d instanceof $root.Addresses.CertifiedRecord)
-                return d;
-            var m = new $root.Addresses.CertifiedRecord();
-            if (d.seq != null) {
-                if ($util.Long)
-                    (m.seq = $util.Long.fromValue(d.seq)).unsigned = true;
-                else if (typeof d.seq === "string")
-                    m.seq = parseInt(d.seq, 10);
-                else if (typeof d.seq === "number")
-                    m.seq = d.seq;
-                else if (typeof d.seq === "object")
-                    m.seq = new $util.LongBits(d.seq.low >>> 0, d.seq.high >>> 0).toNumber(true);
-            }
-            if (d.raw != null) {
-                if (typeof d.raw === "string")
-                    $util.base64.decode(d.raw, m.raw = $util.newBuffer($util.base64.length(d.raw)), 0);
-                else if (d.raw.length)
-                    m.raw = d.raw;
-            }
-            return m;
-        };
-
-        /**
-         * Creates a plain object from a CertifiedRecord message. Also converts values to other types if specified.
-         * @function toObject
-         * @memberof Addresses.CertifiedRecord
-         * @static
-         * @param {Addresses.CertifiedRecord} m CertifiedRecord
-         * @param {$protobuf.IConversionOptions} [o] Conversion options
-         * @returns {Object.<string,*>} Plain object
-         */
-        CertifiedRecord.toObject = function toObject(m, o) {
-            if (!o)
-                o = {};
-            var d = {};
-            if (o.defaults) {
-                if ($util.Long) {
-                    var n = new $util.Long(0, 0, true);
-                    d.seq = o.longs === String ? n.toString() : o.longs === Number ? n.toNumber() : n;
-                } else
-                    d.seq = o.longs === String ? "0" : 0;
-                if (o.bytes === String)
-                    d.raw = "";
-                else {
-                    d.raw = [];
-                    if (o.bytes !== Array)
-                        d.raw = $util.newBuffer(d.raw);
-                }
-            }
-            if (m.seq != null && m.hasOwnProperty("seq")) {
-                if (typeof m.seq === "number")
-                    d.seq = o.longs === String ? String(m.seq) : m.seq;
-                else
-                    d.seq = o.longs === String ? $util.Long.prototype.toString.call(m.seq) : o.longs === Number ? new $util.LongBits(m.seq.low >>> 0, m.seq.high >>> 0).toNumber(true) : m.seq;
-            }
-            if (m.raw != null && m.hasOwnProperty("raw")) {
-                d.raw = o.bytes === String ? $util.base64.encode(m.raw, 0, m.raw.length) : o.bytes === Array ? Array.prototype.slice.call(m.raw) : m.raw;
-            }
-            return d;
-        };
-
-        /**
-         * Converts this CertifiedRecord to JSON.
-         * @function toJSON
-         * @memberof Addresses.CertifiedRecord
-         * @instance
-         * @returns {Object.<string,*>} JSON object
-         */
-        CertifiedRecord.prototype.toJSON = function toJSON() {
-            return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
-        };
-
-        return CertifiedRecord;
-    })();
-
-    return Addresses;
-})();
-
-module.exports = $root;

src/peer-store/persistent/pb/address-book.proto

@@ -1,27 +0,0 @@
-syntax = "proto3";
-
-message Addresses {
-  // Address represents a single multiaddr.
-  message Address {
-    bytes multiaddr = 1;
-
-    // Flag to indicate if the address comes from a certified source.
-    optional bool isCertified = 2;
-  }
-
-  // CertifiedRecord contains a serialized signed PeerRecord used to
-  // populate the signedAddrs list.
-  message CertifiedRecord {
-    // The Seq counter from the signed PeerRecord envelope
-    uint64 seq = 1;
-
-    // The serialized bytes of the SignedEnvelope containing the PeerRecord.
-    bytes raw = 2;
-  }
-
-  // The known multiaddrs.
-  repeated Address addrs = 1;
-
-  // The most recently received signed PeerRecord.
-  CertifiedRecord certified_record = 2;
-}

src/peer-store/persistent/pb/proto-book.d.ts

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

src/peer-store/persistent/pb/proto-book.js

@@ -1,157 +0,0 @@
-/*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-proto-book"] || ($protobuf.roots["libp2p-proto-book"] = {});
-
-$root.Protocols = (function() {
-
-    /**
-     * Properties of a Protocols.
-     * @exports IProtocols
-     * @interface IProtocols
-     * @property {Array.<string>|null} [protocols] Protocols protocols
-     */
-
-    /**
-     * Constructs a new Protocols.
-     * @exports Protocols
-     * @classdesc Represents a Protocols.
-     * @implements IProtocols
-     * @constructor
-     * @param {IProtocols=} [p] Properties to set
-     */
-    function Protocols(p) {
-        this.protocols = [];
-        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]];
-    }
-
-    /**
-     * Protocols protocols.
-     * @member {Array.<string>} protocols
-     * @memberof Protocols
-     * @instance
-     */
-    Protocols.prototype.protocols = $util.emptyArray;
-
-    /**
-     * Encodes the specified Protocols message. Does not implicitly {@link Protocols.verify|verify} messages.
-     * @function encode
-     * @memberof Protocols
-     * @static
-     * @param {IProtocols} m Protocols message or plain object to encode
-     * @param {$protobuf.Writer} [w] Writer to encode to
-     * @returns {$protobuf.Writer} Writer
-     */
-    Protocols.encode = function encode(m, w) {
-        if (!w)
-            w = $Writer.create();
-        if (m.protocols != null && m.protocols.length) {
-            for (var i = 0; i < m.protocols.length; ++i)
-                w.uint32(10).string(m.protocols[i]);
-        }
-        return w;
-    };
-
-    /**
-     * Decodes a Protocols message from the specified reader or buffer.
-     * @function decode
-     * @memberof Protocols
-     * @static
-     * @param {$protobuf.Reader|Uint8Array} r Reader or buffer to decode from
-     * @param {number} [l] Message length if known beforehand
-     * @returns {Protocols} Protocols
-     * @throws {Error} If the payload is not a reader or valid buffer
-     * @throws {$protobuf.util.ProtocolError} If required fields are missing
-     */
-    Protocols.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.Protocols();
-        while (r.pos < c) {
-            var t = r.uint32();
-            switch (t >>> 3) {
-            case 1:
-                if (!(m.protocols && m.protocols.length))
-                    m.protocols = [];
-                m.protocols.push(r.string());
-                break;
-            default:
-                r.skipType(t & 7);
-                break;
-            }
-        }
-        return m;
-    };
-
-    /**
-     * Creates a Protocols message from a plain object. Also converts values to their respective internal types.
-     * @function fromObject
-     * @memberof Protocols
-     * @static
-     * @param {Object.<string,*>} d Plain object
-     * @returns {Protocols} Protocols
-     */
-    Protocols.fromObject = function fromObject(d) {
-        if (d instanceof $root.Protocols)
-            return d;
-        var m = new $root.Protocols();
-        if (d.protocols) {
-            if (!Array.isArray(d.protocols))
-                throw TypeError(".Protocols.protocols: array expected");
-            m.protocols = [];
-            for (var i = 0; i < d.protocols.length; ++i) {
-                m.protocols[i] = String(d.protocols[i]);
-            }
-        }
-        return m;
-    };
-
-    /**
-     * Creates a plain object from a Protocols message. Also converts values to other types if specified.
-     * @function toObject
-     * @memberof Protocols
-     * @static
-     * @param {Protocols} m Protocols
-     * @param {$protobuf.IConversionOptions} [o] Conversion options
-     * @returns {Object.<string,*>} Plain object
-     */
-    Protocols.toObject = function toObject(m, o) {
-        if (!o)
-            o = {};
-        var d = {};
-        if (o.arrays || o.defaults) {
-            d.protocols = [];
-        }
-        if (m.protocols && m.protocols.length) {
-            d.protocols = [];
-            for (var j = 0; j < m.protocols.length; ++j) {
-                d.protocols[j] = m.protocols[j];
-            }
-        }
-        return d;
-    };
-
-    /**
-     * Converts this Protocols to JSON.
-     * @function toJSON
-     * @memberof Protocols
-     * @instance
-     * @returns {Object.<string,*>} JSON object
-     */
-    Protocols.prototype.toJSON = function toJSON() {
-        return this.constructor.toObject(this, $protobuf.util.toJSONOptions);
-    };
-
-    return Protocols;
-})();
-
-module.exports = $root;

src/peer-store/persistent/pb/proto-book.proto

@@ -1,5 +0,0 @@
-syntax = "proto3";
-
-message Protocols {
-  repeated string protocols = 1;
-}

src/peer-store/proto-book.js

@@ -1,171 +1,237 @@
 'use strict'
 
 const debug = require('debug')
+const errcode = require('err-code')
+const { codes } = require('../errors')
+const PeerId = require('peer-id')
+
+/**
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').ProtoBook} ProtoBook
+ */
+
 const log = Object.assign(debug('libp2p:peer-store:proto-book'), {
   error: debug('libp2p:peer-store:proto-book:err')
 })
-const errcode = require('err-code')
-const PeerId = require('peer-id')
 
-const Book = require('./book')
+const EVENT_NAME = 'change:protocols'
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
 
 /**
- * @typedef {import('./')} PeerStore
+ * @implements {ProtoBook}
  */
-
+class PersistentProtoBook {
-/**
- * @extends {Book}
- *
- * @fires ProtoBook#change:protocols
- */
-class ProtoBook extends Book {
   /**
-   * The ProtoBook is responsible for keeping the known supported
+   * @param {PeerStore["emit"]} emit
-   * protocols of a peer.
+   * @param {import('./types').Store} store
-   *
-   * @class
-   * @param {PeerStore} peerStore
    */
-  constructor (peerStore) {
+  constructor (emit, store) {
-    /**
+    this._emit = emit
-     * PeerStore Event emitter, used by the ProtoBook to emit:
+    this._store = store
-     * "change:protocols" - emitted when the known protocols of a peer change.
-     */
-    super({
-      peerStore,
-      eventName: 'change:protocols',
-      eventProperty: 'protocols',
-      eventTransformer: (data) => Array.from(data)
-    })
-
-    /**
-     * Map known peers to their known protocols.
-     *
-     * @type {Map<string, Set<string>>}
-     */
-    this.data = new Map()
   }
 
   /**
-   * Set known protocols of a provided peer.
-   * If the peer was not known before, it will be added.
-   *
-   * @override
    * @param {PeerId} peerId
-   * @param {string[]} protocols
-   * @returns {ProtoBook}
    */
-  set (peerId, protocols) {
+  async get (peerId) {
-    if (!PeerId.isPeerId(peerId)) {
+    log('get wait for read lock')
-      log.error('peerId must be an instance of peer-id to store data')
+    const release = await this._store.lock.readLock()
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+    log('get got read lock')
+
+    try {
+      const peer = await this._store.load(peerId)
+
+      return peer.protocols
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('get release read lock')
+      release()
     }
 
-    if (!protocols) {
+    return []
-      log.error('protocols must be provided to store data')
-      throw errcode(new Error('protocols must be provided'), ERR_INVALID_PARAMETERS)
-    }
-
-    const id = peerId.toB58String()
-    const recSet = this.data.get(id)
-    const newSet = new Set(protocols)
-
-    /**
-     * @param {Set<string>} a
-     * @param {Set<string>} b
-     */
-    const isSetEqual = (a, b) => a.size === b.size && [...a].every(value => b.has(value))
-
-    // Already knows the peer and the recorded protocols are the same?
-    // If yes, no changes needed!
-    if (recSet && isSetEqual(recSet, newSet)) {
-      log(`the protocols provided to store are equal to the already stored for ${id}`)
-      return this
-    }
-
-    this._setData(peerId, newSet)
-    log(`stored provided protocols for ${id}`)
-
-    return this
   }
 
   /**
-   * Adds known protocols of a provided peer.
-   * If the peer was not known before, it will be added.
-   *
    * @param {PeerId} peerId
    * @param {string[]} protocols
-   * @returns {ProtoBook}
    */
-  add (peerId, protocols) {
+  async set (peerId, protocols) {
     if (!PeerId.isPeerId(peerId)) {
       log.error('peerId must be an instance of peer-id to store data')
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    if (!protocols) {
+    if (!Array.isArray(protocols)) {
       log.error('protocols must be provided to store data')
-      throw errcode(new Error('protocols must be provided'), ERR_INVALID_PARAMETERS)
+      throw errcode(new Error('protocols must be provided'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    const id = peerId.toB58String()
+    log('set await write lock')
-    const recSet = this.data.get(id) || new Set()
+    const release = await this._store.lock.writeLock()
-    const newSet = new Set([...recSet, ...protocols]) // Set Union
+    log('set got write lock')
 
-    // Any new protocol added?
+    let updatedPeer
-    if (recSet.size === newSet.size) {
-      log(`the protocols provided to store are already stored for ${id}`)
-      return this
-    }
 
-    this._setData(peerId, newSet)
+    try {
-    log(`added provided protocols for ${id}`)
+      try {
+        const peer = await this._store.load(peerId)
 
-    return this
+        if (new Set([
-  }
+          ...protocols
-
+        ]).size === peer.protocols.length) {
-  /**
+          return
-   * Removes known protocols of a provided peer.
+        }
-   * If the protocols did not exist before, nothing will be done.
+      } catch (/** @type {any} */ err) {
-   *
+        if (err.code !== codes.ERR_NOT_FOUND) {
-   * @param {PeerId} peerId
+          throw err
-   * @param {string[]} protocols
+        }
-   * @returns {ProtoBook}
-   */
-  remove (peerId, protocols) {
-    if (!PeerId.isPeerId(peerId)) {
-      log.error('peerId must be an instance of peer-id to store data')
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
-    }
-
-    if (!protocols) {
-      log.error('protocols must be provided to store data')
-      throw errcode(new Error('protocols must be provided'), ERR_INVALID_PARAMETERS)
-    }
-
-    const id = peerId.toB58String()
-    const recSet = this.data.get(id)
-
-    if (recSet) {
-      const newSet = new Set([
-        ...recSet
-      ].filter((p) => !protocols.includes(p)))
-
-      // Any protocol removed?
-      if (recSet.size === newSet.size) {
-        return this
       }
 
-      this._setData(peerId, newSet)
+      updatedPeer = await this._store.patchOrCreate(peerId, {
-      log(`removed provided protocols for ${id}`)
+        protocols
+      })
+
+      log(`stored provided protocols for ${peerId.toB58String()}`)
+    } finally {
+      log('set release write lock')
+      release()
     }
 
-    return this
+    this._emit(EVENT_NAME, { peerId, protocols: updatedPeer.protocols })
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {string[]} protocols
+   */
+  async add (peerId, protocols) {
+    if (!PeerId.isPeerId(peerId)) {
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    if (!Array.isArray(protocols)) {
+      log.error('protocols must be provided to store data')
+      throw errcode(new Error('protocols must be provided'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('add await write lock')
+    const release = await this._store.lock.writeLock()
+    log('add got write lock')
+
+    let updatedPeer
+
+    try {
+      try {
+        const peer = await this._store.load(peerId)
+
+        if (new Set([
+          ...peer.protocols,
+          ...protocols
+        ]).size === peer.protocols.length) {
+          return
+        }
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
+
+      updatedPeer = await this._store.mergeOrCreate(peerId, {
+        protocols
+      })
+
+      log(`added provided protocols for ${peerId.toB58String()}`)
+    } finally {
+      log('add release write lock')
+      release()
+    }
+
+    this._emit(EVENT_NAME, { peerId, protocols: updatedPeer.protocols })
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {string[]} protocols
+   */
+  async remove (peerId, protocols) {
+    if (!PeerId.isPeerId(peerId)) {
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    if (!Array.isArray(protocols)) {
+      log.error('protocols must be provided to store data')
+      throw errcode(new Error('protocols must be provided'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('remove await write lock')
+    const release = await this._store.lock.writeLock()
+    log('remove got write lock')
+
+    let updatedPeer
+
+    try {
+      try {
+        const peer = await this._store.load(peerId)
+        const protocolSet = new Set(peer.protocols)
+
+        for (const protocol of protocols) {
+          protocolSet.delete(protocol)
+        }
+
+        if (peer.protocols.length === protocolSet.size) {
+          return
+        }
+
+        protocols = Array.from(protocolSet)
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
+      }
+
+      updatedPeer = await this._store.patchOrCreate(peerId, {
+        protocols
+      })
+    } finally {
+      log('remove release write lock')
+      release()
+    }
+
+    this._emit(EVENT_NAME, { peerId, protocols: updatedPeer.protocols })
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  async delete (peerId) {
+    log('delete await write lock')
+    const release = await this._store.lock.writeLock()
+    log('delete got write lock')
+    let has
+
+    try {
+      has = await this._store.has(peerId)
+
+      await this._store.patchOrCreate(peerId, {
+        protocols: []
+      })
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+    } finally {
+      log('delete release write lock')
+      release()
+    }
+
+    if (has) {
+      this._emit(EVENT_NAME, { peerId, protocols: [] })
+    }
   }
 }
 
-module.exports = ProtoBook
+module.exports = PersistentProtoBook

src/peer-store/store.js

@@ -0,0 +1,263 @@
+'use strict'
+
+const debug = require('debug')
+const PeerId = require('peer-id')
+const errcode = require('err-code')
+const { codes } = require('../errors')
+const { Key } = require('interface-datastore/key')
+const { base32 } = require('multiformats/bases/base32')
+const { keys: { unmarshalPublicKey, marshalPublicKey } } = require('libp2p-crypto')
+const { Multiaddr } = require('multiaddr')
+const { Peer: PeerPB } = require('./pb/peer')
+// @ts-expect-error no types
+const mortice = require('mortice')
+const { equals: uint8arrayEquals } = require('uint8arrays/equals')
+
+const log = Object.assign(debug('libp2p:peer-store:store'), {
+  error: debug('libp2p:peer-store:store:err')
+})
+
+/**
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').EventName} EventName
+ * @typedef {import('./types').Peer} Peer
+ */
+
+const NAMESPACE_COMMON = '/peers/'
+
+class PersistentStore {
+  /**
+   * @param {import('interface-datastore').Datastore} datastore
+   */
+  constructor (datastore) {
+    this._datastore = datastore
+    this.lock = mortice('peer-store', {
+      singleProcess: true
+    })
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @returns {Key}
+   */
+  _peerIdToDatastoreKey (peerId) {
+    if (!PeerId.isPeerId(peerId)) {
+      log.error('peerId must be an instance of peer-id to store data')
+      throw errcode(new Error('peerId must be an instance of peer-id'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    const b32key = peerId.toString()
+    return new Key(`${NAMESPACE_COMMON}${b32key}`)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  async has (peerId) {
+    return this._datastore.has(this._peerIdToDatastoreKey(peerId))
+  }
+
+  /**
+   * @param {PeerId} peerId
+   */
+  async delete (peerId) {
+    await this._datastore.delete(this._peerIdToDatastoreKey(peerId))
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @returns {Promise<import('./types').Peer>} peer
+   */
+  async load (peerId) {
+    const buf = await this._datastore.get(this._peerIdToDatastoreKey(peerId))
+    const peer = PeerPB.decode(buf)
+    const pubKey = peer.pubKey ? unmarshalPublicKey(peer.pubKey) : peerId.pubKey
+    const metadata = new Map()
+
+    for (const meta of peer.metadata) {
+      metadata.set(meta.key, meta.value)
+    }
+
+    return {
+      ...peer,
+      id: peerId,
+      pubKey,
+      addresses: peer.addresses.map(({ multiaddr, isCertified }) => ({
+        multiaddr: new Multiaddr(multiaddr),
+        isCertified: isCertified || false
+      })),
+      metadata,
+      peerRecordEnvelope: peer.peerRecordEnvelope || undefined
+    }
+  }
+
+  /**
+   * @param {Peer} peer
+   */
+  async save (peer) {
+    if (peer.pubKey != null && peer.id.pubKey != null && !uint8arrayEquals(peer.pubKey.bytes, peer.id.pubKey.bytes)) {
+      log.error('peer publicKey bytes do not match peer id publicKey bytes')
+      throw errcode(new Error('publicKey bytes do not match peer id publicKey bytes'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    // dedupe addresses
+    const addressSet = new Set()
+
+    const buf = PeerPB.encode({
+      addresses: peer.addresses
+        .filter(address => {
+          if (addressSet.has(address.multiaddr.toString())) {
+            return false
+          }
+
+          addressSet.add(address.multiaddr.toString())
+          return true
+        })
+        .sort((a, b) => {
+          return a.multiaddr.toString().localeCompare(b.multiaddr.toString())
+        })
+        .map(({ multiaddr, isCertified }) => ({
+          multiaddr: multiaddr.bytes,
+          isCertified
+        })),
+      protocols: peer.protocols.sort(),
+      pubKey: peer.pubKey ? marshalPublicKey(peer.pubKey) : undefined,
+      metadata: [...peer.metadata.keys()].sort().map(key => ({ key, value: peer.metadata.get(key) })),
+      peerRecordEnvelope: peer.peerRecordEnvelope
+    }).finish()
+
+    await this._datastore.put(this._peerIdToDatastoreKey(peer.id), buf)
+
+    return this.load(peer.id)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   */
+  async patch (peerId, data) {
+    const peer = await this.load(peerId)
+
+    return await this._patch(peerId, data, peer)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   */
+  async patchOrCreate (peerId, data) {
+    /** @type {Peer} */
+    let peer
+
+    try {
+      peer = await this.load(peerId)
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+
+      peer = { id: peerId, addresses: [], protocols: [], metadata: new Map() }
+    }
+
+    return await this._patch(peerId, data, peer)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   * @param {Peer} peer
+   */
+  async _patch (peerId, data, peer) {
+    return await this.save({
+      ...peer,
+      ...data,
+      id: peerId
+    })
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   */
+  async merge (peerId, data) {
+    const peer = await this.load(peerId)
+
+    return this._merge(peerId, data, peer)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   */
+  async mergeOrCreate (peerId, data) {
+    /** @type {Peer} */
+    let peer
+
+    try {
+      peer = await this.load(peerId)
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
+      }
+
+      peer = { id: peerId, addresses: [], protocols: [], metadata: new Map() }
+    }
+
+    return await this._merge(peerId, data, peer)
+  }
+
+  /**
+   * @param {PeerId} peerId
+   * @param {Partial<Peer>} data
+   * @param {Peer} peer
+   */
+  async _merge (peerId, data, peer) {
+    // if the peer has certified addresses, use those in
+    // favour of the supplied versions
+    /** @type {Map<string, boolean>} */
+    const addresses = new Map()
+
+    ;(data.addresses || []).forEach(addr => {
+      addresses.set(addr.multiaddr.toString(), addr.isCertified)
+    })
+
+    peer.addresses.forEach(({ multiaddr, isCertified }) => {
+      const addrStr = multiaddr.toString()
+      addresses.set(addrStr, Boolean(addresses.get(addrStr) || isCertified))
+    })
+
+    return await this.save({
+      id: peerId,
+      addresses: Array.from(addresses.entries()).map(([addrStr, isCertified]) => {
+        return {
+          multiaddr: new Multiaddr(addrStr),
+          isCertified
+        }
+      }),
+      protocols: Array.from(new Set([
+        ...(peer.protocols || []),
+        ...(data.protocols || [])
+      ])),
+      metadata: new Map([
+        ...(peer.metadata ? peer.metadata.entries() : []),
+        ...(data.metadata ? data.metadata.entries() : [])
+      ]),
+      pubKey: data.pubKey || (peer != null ? peer.pubKey : undefined),
+      peerRecordEnvelope: data.peerRecordEnvelope || (peer != null ? peer.peerRecordEnvelope : undefined)
+    })
+  }
+
+  async * all () {
+    for await (const key of this._datastore.queryKeys({
+      prefix: NAMESPACE_COMMON
+    })) {
+      // /peers/${peer-id-as-libp2p-key-cid-string-in-base-32}
+      const base32Str = key.toString().split('/')[2]
+      const buf = base32.decode(base32Str)
+
+      yield this.load(PeerId.createFromBytes(buf))
+    }
+  }
+}
+
+module.exports = PersistentStore

src/peer-store/types.ts

@@ -0,0 +1,245 @@
+import type PeerId from 'peer-id'
+import type { Multiaddr } from 'multiaddr'
+import type Envelope from '../record/envelope'
+import type { PublicKey } from 'libp2p-interfaces/src/keys/types'
+
+export interface Address {
+  /**
+   * Peer multiaddr
+   */
+  multiaddr: Multiaddr
+
+  /**
+   * Obtained from a signed peer record
+   */
+  isCertified: boolean
+}
+
+export interface Peer {
+  /**
+   * Peer's peer-id instance
+   */
+  id: PeerId
+
+  /**
+   * Peer's addresses containing its multiaddrs and metadata
+   */
+  addresses: Address[]
+
+  /**
+   * Peer's supported protocols
+   */
+  protocols: string[]
+
+  /**
+   * Peer's metadata map
+   */
+  metadata: Map<string, Uint8Array>
+
+  /**
+   * May be set if the key that this Peer has is an RSA key
+   */
+  pubKey?: PublicKey
+
+  /**
+   * The last peer record envelope received
+   */
+  peerRecordEnvelope?: Uint8Array
+}
+
+export interface CertifiedRecord {
+  raw: Uint8Array
+  seqNumber: number
+}
+
+export interface AddressBookEntry {
+  addresses: Address[]
+  record: CertifiedRecord
+}
+
+export interface Book<Type> {
+  /**
+   * Get the known data of a peer
+   */
+  get: (peerId: PeerId) => Promise<Type>
+
+  /**
+   * Set the known data of a peer
+   */
+  set: (peerId: PeerId, data: Type) => Promise<void>
+
+  /**
+   * Remove the known data of a peer
+   */
+  delete: (peerId: PeerId) => Promise<void>
+}
+
+/**
+ * AddressBook containing a map of peerIdStr to Address.
+ */
+export interface AddressBook {
+  /**
+   * ConsumePeerRecord adds addresses from a signed peer record contained in a record envelope.
+   * This will return a boolean that indicates if the record was successfully processed and added
+   * into the AddressBook
+   */
+  consumePeerRecord: (envelope: Envelope) => Promise<boolean>
+
+  /**
+   * Get the raw Envelope for a peer. Returns
+   * undefined if no Envelope is found
+   */
+  getRawEnvelope: (peerId: PeerId) => Promise<Uint8Array | undefined>
+
+  /**
+   * Get an Envelope containing a PeerRecord for the given peer.
+   * Returns undefined if no record exists.
+   */
+  getPeerRecord: (peerId: PeerId) => Promise<Envelope | undefined>
+
+  /**
+   * Add known addresses of a provided peer.
+   * If the peer is not known, it is set with the given addresses.
+   */
+  add: (peerId: PeerId, multiaddrs: Multiaddr[]) => Promise<void>
+
+  /**
+   * Set the known addresses of a peer
+   */
+  set: (peerId: PeerId, data: Multiaddr[]) => Promise<void>
+
+  /**
+   * Return the known addresses of a peer
+   */
+  get: (peerId: PeerId) => Promise<Address[]>
+
+  /**
+   * Get the known multiaddrs for a given peer. All returned multiaddrs
+   * will include the encapsulated `PeerId` of the peer.
+   */
+  getMultiaddrsForPeer: (peerId: PeerId, addressSorter?: (ms: Address[]) => Address[]) => Promise<Multiaddr[]>
+}
+
+/**
+ * KeyBook containing a map of peerIdStr to their PeerId with public keys.
+ */
+export interface KeyBook {
+  /**
+   * Get the known data of a peer
+   */
+  get: (peerId: PeerId) => Promise<PublicKey | undefined>
+
+  /**
+   * Set the known data of a peer
+   */
+  set: (peerId: PeerId, data: PublicKey) => Promise<void>
+
+  /**
+   * Remove the known data of a peer
+   */
+  delete: (peerId: PeerId) => Promise<void>
+}
+
+/**
+ * MetadataBook containing a map of peerIdStr to their metadata Map.
+ */
+export interface MetadataBook extends Book<Map<string, Uint8Array>> {
+  /**
+   * Set a specific metadata value
+   */
+  setValue: (peerId: PeerId, key: string, value: Uint8Array) => Promise<void>
+
+  /**
+   * Get specific metadata value, if it exists
+   */
+  getValue: (peerId: PeerId, key: string) => Promise<Uint8Array | undefined>
+
+  /**
+   * Deletes the provided peer metadata key from the book
+   */
+  deleteValue: (peerId: PeerId, key: string) => Promise<void>
+}
+
+/**
+ * ProtoBook containing a map of peerIdStr to supported protocols.
+ */
+export interface ProtoBook extends Book<string[]> {
+  /**
+   * Adds known protocols of a provided peer.
+   * If the peer was not known before, it will be added.
+   */
+  add: (peerId: PeerId, protocols: string[]) => Promise<void>
+
+  /**
+   * Removes known protocols of a provided peer.
+   * If the protocols did not exist before, nothing will be done.
+   */
+  remove: (peerId: PeerId, protocols: string[]) => Promise<void>
+}
+
+export interface PeerProtocolsChangeEvent {
+  peerId: PeerId
+  protocols: string[]
+}
+
+export interface PeerMultiaddrsChangeEvent {
+  peerId: PeerId
+  multiaddrs: Multiaddr[]
+}
+
+export interface PeerPublicKeyChangeEvent {
+  peerId: PeerId
+  pubKey?: PublicKey
+}
+
+export interface PeerMetadataChangeEvent {
+  peerId: PeerId
+  metadata: Map<string, Uint8Array>
+}
+
+export type EventName = 'peer' | 'change:protocols' | 'change:multiaddrs' | 'change:pubkey' | 'change:metadata'
+
+export interface PeerStoreEvents {
+  'peer': (event: PeerId) => void
+  'change:protocols': (event: PeerProtocolsChangeEvent) => void
+  'change:multiaddrs': (event: PeerMultiaddrsChangeEvent) => void
+  'change:pubkey': (event: PeerPublicKeyChangeEvent) => void
+  'change:metadata': (event: PeerMetadataChangeEvent) => void
+}
+
+export interface PeerStore {
+  addressBook: AddressBook
+  keyBook: KeyBook
+  metadataBook: MetadataBook
+  protoBook: ProtoBook
+
+  getPeers: () => AsyncIterable<Peer>
+  delete: (peerId: PeerId) => Promise<void>
+  has: (peerId: PeerId) => Promise<boolean>
+  get: (peerId: PeerId) => Promise<Peer>
+  on: <U extends keyof PeerStoreEvents>(
+    event: U, listener: PeerStoreEvents[U]
+  ) => this
+  once: <U extends keyof PeerStoreEvents>(
+    event: U, listener: PeerStoreEvents[U]
+  ) => this
+  emit: <U extends keyof PeerStoreEvents>(
+    event: U, ...args: Parameters<PeerStoreEvents[U]>
+  ) => boolean
+}
+
+export interface Store {
+  has: (peerId: PeerId) => Promise<boolean>
+  save: (peer: Peer) => Promise<Peer>
+  load: (peerId: PeerId) => Promise<Peer>
+  merge: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
+  mergeOrCreate: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
+  patch: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
+  patchOrCreate: (peerId: PeerId, data: Partial<Peer>) => Promise<Peer>
+  all: () => AsyncIterable<Peer>
+
+  lock: {
+    readLock: () => Promise<() => void>
+    writeLock: () => Promise<() => void>
+  }
+}

src/ping/index.js

@@ -5,7 +5,7 @@ const log = Object.assign(debug('libp2p:ping'), {
   error: debug('libp2p:ping:err')
 })
 const errCode = require('err-code')
-
+const { codes } = require('../errors')
 const crypto = require('libp2p-crypto')
 const { pipe } = require('it-pipe')
 // @ts-ignore it-buffer has no types exported
@@ -50,7 +50,7 @@ async function ping (node, peer) {
   const end = Date.now()
 
   if (!equals(data, result)) {
-    throw errCode(new Error('Received wrong ping ack'), 'ERR_WRONG_PING_ACK')
+    throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
   }
 
   return end - start
@@ -63,6 +63,9 @@ async function ping (node, peer) {
  */
 function mount (node) {
   node.handle(`/${node._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`, ({ stream }) => pipe(stream, stream))
+    .catch(err => {
+      log.error(err)
+    })
 }
 
 /**
@@ -72,6 +75,9 @@ function mount (node) {
  */
 function unmount (node) {
   node.unhandle(`/${node._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`)
+    .catch(err => {
+      log.error(err)
+    })
 }
 
 exports = module.exports = ping

src/record/peer-record/index.js

@@ -11,7 +11,7 @@ const {
 } = require('./consts')
 
 /**
- * @typedef {import('../../peer-store/address-book.js').Address} Address
+ * @typedef {import('../../peer-store/types').Address} Address
  * @typedef {import('libp2p-interfaces/src/record/types').Record} Record
  */
 

src/record/utils.js

@@ -19,7 +19,7 @@ async function updateSelfPeerRecord (libp2p) {
     multiaddrs: libp2p.multiaddrs
   })
   const envelope = await Envelope.seal(peerRecord, libp2p.peerId)
-  libp2p.peerStore.addressBook.consumePeerRecord(envelope)
+  await libp2p.peerStore.addressBook.consumePeerRecord(envelope)
 }
 
 module.exports.updateSelfPeerRecord = updateSelfPeerRecord

src/registrar.js

@@ -13,7 +13,7 @@ const Topology = require('libp2p-interfaces/src/topology')
 
 /**
  * @typedef {import('peer-id')} PeerId
- * @typedef {import('./peer-store')} PeerStore
+ * @typedef {import('./peer-store/types').PeerStore} PeerStore
  * @typedef {import('./connection-manager')} ConnectionManager
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
  * @typedef {import('./').HandlerProps} HandlerProps
@@ -82,9 +82,9 @@ class Registrar {
    * Register handlers for a set of multicodecs given
    *
    * @param {Topology} topology - protocol topology
-   * @returns {string} registrar identifier
+   * @returns {Promise<string>} registrar identifier
    */
-  register (topology) {
+  async register (topology) {
     if (!Topology.isTopology(topology)) {
       log.error('topology must be an instance of interfaces/topology')
       throw errcode(new Error('topology must be an instance of interfaces/topology'), ERR_INVALID_PARAMETERS)
@@ -96,7 +96,7 @@ class Registrar {
     this.topologies.set(id, topology)
 
     // Set registrar
-    topology.registrar = this
+    await topology.setRegistrar(this)
 
     return id
   }

src/types.ts

@@ -0,0 +1,98 @@
+import type PeerId from 'peer-id'
+import type { Multiaddr } from 'multiaddr'
+import type { MultiaddrConnection } from 'libp2p-interfaces/src/transport/types'
+
+export interface 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>
+}

src/upgrader.js

@@ -5,7 +5,6 @@ const log = Object.assign(debug('libp2p:upgrader'), {
   error: debug('libp2p:upgrader:err')
 })
 const errCode = require('err-code')
-// @ts-ignore multistream-select does not export types
 const Multistream = require('multistream-select')
 const { Connection } = require('libp2p-interfaces/src/connection')
 const PeerId = require('peer-id')
@@ -23,6 +22,7 @@ const { codes } = require('./errors')
  * @typedef {import('libp2p-interfaces/src/crypto/types').Crypto} Crypto
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
  * @typedef {import('multiaddr').Multiaddr} Multiaddr
+ * @typedef {import('./types').ConnectionGater} ConnectionGater
  */
 
 /**
@@ -36,6 +36,8 @@ class Upgrader {
   /**
    * @param {object} options
    * @param {PeerId} options.localPeer
+   * @param {ConnectionGater} options.connectionGater
+   *
    * @param {import('./metrics')} [options.metrics]
    * @param {Map<string, Crypto>} [options.cryptos]
    * @param {Map<string, MuxerFactory>} [options.muxers]
@@ -45,11 +47,13 @@ class Upgrader {
   constructor ({
     localPeer,
     metrics,
+    connectionGater,
     cryptos = new Map(),
     muxers = new Map(),
     onConnectionEnd = () => {},
     onConnection = () => {}
   }) {
+    this.connectionGater = connectionGater
     this.localPeer = localPeer
     this.metrics = metrics
     this.cryptos = cryptos
@@ -77,6 +81,10 @@ class Upgrader {
     let setPeer
     let proxyPeer
 
+    if (await this.connectionGater.denyInboundConnection(maConn)) {
+      throw errCode(new Error('The multiaddr connection is blocked by gater.acceptConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+    }
+
     if (this.metrics) {
       ({ setTarget: setPeer, proxy: proxyPeer } = mutableProxy())
       const idString = (Math.random() * 1e9).toString(36) + Date.now()
@@ -100,6 +108,10 @@ class Upgrader {
         protocol: cryptoProtocol
       } = await this._encryptInbound(this.localPeer, protectedConn, this.cryptos))
 
+      if (await this.connectionGater.denyInboundEncryptedConnection(remotePeer, encryptedConn)) {
+        throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+      }
+
       // Multiplex the connection
       if (this.muxers.size) {
         ({ stream: upgradedConn, Muxer } = await this._multiplexInbound(encryptedConn, this.muxers))
@@ -112,6 +124,10 @@ class Upgrader {
       throw err
     }
 
+    if (await this.connectionGater.denyInboundUpgradedConnection(remotePeer, encryptedConn)) {
+      throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+    }
+
     if (this.metrics) {
       this.metrics.updatePlaceholder(proxyPeer, remotePeer)
       setPeer(remotePeer)
@@ -144,6 +160,10 @@ class Upgrader {
 
     const remotePeerId = PeerId.createFromB58String(idStr)
 
+    if (await this.connectionGater.denyOutboundConnection(remotePeerId, maConn)) {
+      throw errCode(new Error('The multiaddr connection is blocked by connectionGater.denyOutboundConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+    }
+
     let encryptedConn
     let remotePeer
     let upgradedConn
@@ -175,6 +195,10 @@ class Upgrader {
         protocol: cryptoProtocol
       } = await this._encryptOutbound(this.localPeer, protectedConn, remotePeerId, this.cryptos))
 
+      if (await this.connectionGater.denyOutboundEncryptedConnection(remotePeer, encryptedConn)) {
+        throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+      }
+
       // Multiplex the connection
       if (this.muxers.size) {
         ({ stream: upgradedConn, Muxer } = await this._multiplexOutbound(encryptedConn, this.muxers))
@@ -187,6 +211,10 @@ class Upgrader {
       throw err
     }
 
+    if (await this.connectionGater.denyOutboundUpgradedConnection(remotePeer, encryptedConn)) {
+      throw errCode(new Error('The multiaddr connection is blocked by gater.acceptEncryptedConnection'), codes.ERR_CONNECTION_INTERCEPTED)
+    }
+
     if (this.metrics) {
       this.metrics.updatePlaceholder(proxyPeer, remotePeer)
       setPeer(remotePeer)
@@ -288,7 +316,9 @@ class Upgrader {
             } finally {
               this.onConnectionEnd(connection)
             }
-          })()
+          })().catch(err => {
+            log.error(err)
+          })
         }
 
         return Reflect.set(...args)
@@ -297,7 +327,7 @@ class Upgrader {
     maConn.timeline.upgraded = Date.now()
 
     const errConnectionNotMultiplexed = () => {
-      throw errCode(new Error('connection is not multiplexed'), 'ERR_CONNECTION_NOT_MULTIPLEXED')
+      throw errCode(new Error('connection is not multiplexed'), codes.ERR_CONNECTION_NOT_MULTIPLEXED)
     }
 
     // Create the connection

test/configuration/protocol-prefix.node.js

@@ -10,6 +10,10 @@ const { baseOptions } = require('./utils')
 describe('Protocol prefix is configurable', () => {
   let libp2p
 
+  afterEach(async () => {
+    libp2p && await libp2p.stop()
+  })
+
   it('protocolPrefix is provided', async () => {
     const testProtocol = 'test-protocol'
     libp2p = await create(mergeOptions(baseOptions, {
@@ -17,31 +21,27 @@ describe('Protocol prefix is configurable', () => {
         protocolPrefix: testProtocol
       }
     }))
+    await libp2p.start()
 
-    const protocols = libp2p.peerStore.protoBook.get(libp2p.peerId);
+    const protocols = await libp2p.peerStore.protoBook.get(libp2p.peerId)
-    [
+    expect(protocols).to.include.members([
       '/libp2p/circuit/relay/0.1.0',
       `/${testProtocol}/id/1.0.0`,
       `/${testProtocol}/id/push/1.0.0`,
       `/${testProtocol}/ping/1.0.0`
-    ].forEach((i, idx) => {
+    ])
-      expect(protocols[idx]).equals(i)
-    })
-    await libp2p.stop()
   })
 
   it('protocolPrefix is not provided', async () => {
     libp2p = await create(baseOptions)
+    await libp2p.start()
 
-    const protocols = libp2p.peerStore.protoBook.get(libp2p.peerId);
+    const protocols = await libp2p.peerStore.protoBook.get(libp2p.peerId)
-    [
+    expect(protocols).to.include.members([
       '/libp2p/circuit/relay/0.1.0',
       '/ipfs/id/1.0.0',
       '/ipfs/id/push/1.0.0',
       '/ipfs/ping/1.0.0'
-    ].forEach((i, idx) => {
+    ])
-      expect(protocols[idx]).equals(i)
-    })
-    await libp2p.stop()
   })
 })

test/connection-manager/auto-dialler.spec.js

@@ -0,0 +1,64 @@
+'use strict'
+/* eslint-env mocha */
+
+const { expect } = require('aegir/utils/chai')
+const sinon = require('sinon')
+const AutoDialler = require('../../src/connection-manager/auto-dialler')
+const pWaitFor = require('p-wait-for')
+const PeerId = require('peer-id')
+const delay = require('delay')
+
+describe('Auto-dialler', () => {
+  let autoDialler
+  let libp2p
+  let options
+
+  beforeEach(async () => {
+    libp2p = {}
+    options = {}
+    autoDialler = new AutoDialler(libp2p, options)
+  })
+
+  afterEach(async () => {
+    sinon.restore()
+  })
+
+  it('should not dial self', async () => {
+    // peers with protocols are dialled before peers without protocols
+    const self = {
+      id: await PeerId.create(),
+      protocols: [
+        '/foo/bar'
+      ]
+    }
+    const other = {
+      id: await PeerId.create(),
+      protocols: []
+    }
+
+    autoDialler._options.minConnections = 10
+    libp2p.peerId = self.id
+    libp2p.connections = {
+      size: 1
+    }
+    libp2p.peerStore = {
+      getPeers: sinon.stub().returns([self, other])
+    }
+    libp2p.connectionManager = {
+      get: () => {}
+    }
+    libp2p.dialer = {
+      connectToPeer: sinon.stub().resolves()
+    }
+
+    await autoDialler.start()
+
+    await pWaitFor(() => libp2p.dialer.connectToPeer.callCount === 1)
+    await delay(1000)
+
+    await autoDialler.stop()
+
+    expect(libp2p.dialer.connectToPeer.callCount).to.equal(1)
+    expect(libp2p.dialer.connectToPeer.calledWith(self.id)).to.be.false()
+  })
+})

test/connection-manager/index.node.js

@@ -7,12 +7,11 @@ const { CLOSED } = require('libp2p-interfaces/src/connection/status')
 
 const delay = require('delay')
 const pWaitFor = require('p-wait-for')
-
 const peerUtils = require('../utils/creators/peer')
 const mockConnection = require('../utils/mockConnection')
 const baseOptions = require('../utils/base-options.browser')
-
+const { codes } = require('../../src/errors')
-const listenMultiaddr = '/ip4/127.0.0.1/tcp/15002/ws'
+const { Multiaddr } = require('multiaddr')
 
 describe('Connection Manager', () => {
   let libp2p
@@ -27,7 +26,7 @@ describe('Connection Manager', () => {
       config: {
         peerId: peerIds[0],
         addresses: {
-          listen: [listenMultiaddr]
+          listen: ['/ip4/127.0.0.1/tcp/0/ws']
         },
         modules: baseOptions.modules
       }
@@ -71,7 +70,7 @@ describe('Connection Manager', () => {
     sinon.spy(libp2p.connectionManager, 'emit')
     sinon.spy(remoteLibp2p.connectionManager, 'emit')
 
-    libp2p.peerStore.addressBook.set(remoteLibp2p.peerId, remoteLibp2p.multiaddrs)
+    await libp2p.peerStore.addressBook.set(remoteLibp2p.peerId, remoteLibp2p.multiaddrs)
     await libp2p.dial(remoteLibp2p.peerId)
 
     // check connect event
@@ -118,7 +117,7 @@ describe('libp2p.connections', () => {
       }
     })
 
-    libp2p.peerStore.addressBook.set(remoteLibp2p.peerId, remoteLibp2p.multiaddrs)
+    await libp2p.peerStore.addressBook.set(remoteLibp2p.peerId, remoteLibp2p.multiaddrs)
     await libp2p.dial(remoteLibp2p.peerId)
 
     expect(libp2p.connections.size).to.eql(1)
@@ -161,8 +160,8 @@ describe('libp2p.connections', () => {
       })
 
       // Populate PeerStore before starting
-      libp2p.peerStore.addressBook.set(nodes[0].peerId, nodes[0].multiaddrs)
+      await libp2p.peerStore.addressBook.set(nodes[0].peerId, nodes[0].multiaddrs)
-      libp2p.peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
+      await libp2p.peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
 
       await libp2p.start()
 
@@ -188,8 +187,8 @@ describe('libp2p.connections', () => {
       })
 
       // Populate PeerStore before starting
-      libp2p.peerStore.addressBook.set(nodes[0].peerId, nodes[0].multiaddrs)
+      await libp2p.peerStore.addressBook.set(nodes[0].peerId, nodes[0].multiaddrs)
-      libp2p.peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
+      await libp2p.peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
 
       await libp2p.start()
 
@@ -219,9 +218,9 @@ describe('libp2p.connections', () => {
       })
 
       // Populate PeerStore before starting
-      libp2p.peerStore.addressBook.set(nodes[0].peerId, nodes[0].multiaddrs)
+      await libp2p.peerStore.addressBook.set(nodes[0].peerId, nodes[0].multiaddrs)
-      libp2p.peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
+      await libp2p.peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
-      libp2p.peerStore.protoBook.set(nodes[1].peerId, ['/protocol-min-conns'])
+      await libp2p.peerStore.protoBook.set(nodes[1].peerId, ['/protocol-min-conns'])
 
       await libp2p.start()
 
@@ -253,7 +252,7 @@ describe('libp2p.connections', () => {
       })
 
       // Populate PeerStore after starting (discovery)
-      libp2p.peerStore.addressBook.set(nodes[0].peerId, nodes[0].multiaddrs)
+      await libp2p.peerStore.addressBook.set(nodes[0].peerId, nodes[0].multiaddrs)
 
       // Wait for peer to connect
       const conn = await libp2p.dial(nodes[0].peerId)
@@ -290,7 +289,7 @@ describe('libp2p.connections', () => {
         }
       })
 
-      libp2p.peerStore.addressBook.set(remoteLibp2p.peerId, remoteLibp2p.multiaddrs)
+      await libp2p.peerStore.addressBook.set(remoteLibp2p.peerId, remoteLibp2p.multiaddrs)
       await libp2p.dial(remoteLibp2p.peerId)
 
       const totalConns = Array.from(libp2p.connections.values())
@@ -305,4 +304,230 @@ describe('libp2p.connections', () => {
       await remoteLibp2p.stop()
     })
   })
+
+  describe('connection gater', () => {
+    let libp2p
+    let remoteLibp2p
+
+    beforeEach(async () => {
+      [remoteLibp2p] = await peerUtils.createPeer({
+        config: {
+          peerId: peerIds[1],
+          addresses: {
+            listen: ['/ip4/127.0.0.1/tcp/0/ws']
+          },
+          modules: baseOptions.modules
+        }
+      })
+    })
+
+    afterEach(async () => {
+      remoteLibp2p && await remoteLibp2p.stop()
+      libp2p && await libp2p.stop()
+    })
+
+    it('intercept peer dial', async () => {
+      const denyDialPeer = sinon.stub().returns(true)
+
+      ;[libp2p] = await peerUtils.createPeer({
+        config: {
+          peerId: peerIds[0],
+          addresses: {
+            listen: ['/ip4/127.0.0.1/tcp/0/ws']
+          },
+          modules: baseOptions.modules,
+          connectionGater: {
+            denyDialPeer
+          }
+        }
+      })
+      await libp2p.peerStore.addressBook.set(remoteLibp2p.peerId, remoteLibp2p.multiaddrs)
+
+      await expect(libp2p.dial(remoteLibp2p.peerId))
+        .to.eventually.be.rejected().with.property('code', codes.ERR_PEER_DIAL_INTERCEPTED)
+    })
+
+    it('intercept addr dial', async () => {
+      const denyDialMultiaddr = sinon.stub().returns(false)
+
+      ;[libp2p] = await peerUtils.createPeer({
+        config: {
+          peerId: peerIds[0],
+          addresses: {
+            listen: ['/ip4/127.0.0.1/tcp/0/ws']
+          },
+          modules: baseOptions.modules,
+          connectionGater: {
+            denyDialMultiaddr
+          }
+        }
+      })
+      await libp2p.peerStore.addressBook.set(remoteLibp2p.peerId, remoteLibp2p.multiaddrs)
+      await libp2p.dialer.connectToPeer(remoteLibp2p.peerId)
+
+      const peerIdMultiaddr = new Multiaddr(`/p2p/${remoteLibp2p.peerId}`)
+
+      for (const multiaddr of remoteLibp2p.multiaddrs) {
+        expect(denyDialMultiaddr.calledWith(remoteLibp2p.peerId, multiaddr.encapsulate(peerIdMultiaddr))).to.be.true()
+      }
+    })
+
+    it('intercept multiaddr store during multiaddr dial', async () => {
+      const filterMultiaddrForPeer = sinon.stub().returns(true)
+
+      ;[libp2p] = await peerUtils.createPeer({
+        config: {
+          peerId: peerIds[0],
+          addresses: {
+            listen: ['/ip4/127.0.0.1/tcp/0/ws']
+          },
+          modules: baseOptions.modules,
+          connectionGater: {
+            filterMultiaddrForPeer
+          }
+        }
+      })
+
+      const peerIdMultiaddr = new Multiaddr(`/p2p/${remoteLibp2p.peerId}`)
+      const fullMultiaddr = remoteLibp2p.multiaddrs[0].encapsulate(peerIdMultiaddr)
+
+      await libp2p.dialer.connectToPeer(fullMultiaddr)
+
+      expect(filterMultiaddrForPeer.callCount).to.equal(2)
+
+      const args = filterMultiaddrForPeer.getCall(1).args
+      expect(args[0].toString()).to.equal(remoteLibp2p.peerId.toString())
+      expect(args[1].toString()).to.equal(fullMultiaddr.toString())
+    })
+
+    it('intercept accept inbound connection', async () => {
+      const denyInboundConnection = sinon.stub().returns(false)
+
+      ;[libp2p] = await peerUtils.createPeer({
+        config: {
+          peerId: peerIds[0],
+          addresses: {
+            listen: ['/ip4/127.0.0.1/tcp/0/ws']
+          },
+          modules: baseOptions.modules,
+          connectionGater: {
+            denyInboundConnection
+          }
+        }
+      })
+      await remoteLibp2p.peerStore.addressBook.set(libp2p.peerId, libp2p.multiaddrs)
+      await remoteLibp2p.dial(libp2p.peerId)
+
+      expect(denyInboundConnection.called).to.be.true()
+    })
+
+    it('intercept accept outbound connection', async () => {
+      const denyOutboundConnection = sinon.stub().returns(false)
+
+      ;[libp2p] = await peerUtils.createPeer({
+        config: {
+          peerId: peerIds[0],
+          addresses: {
+            listen: ['/ip4/127.0.0.1/tcp/0/ws']
+          },
+          modules: baseOptions.modules,
+          connectionGater: {
+            denyOutboundConnection
+          }
+        }
+      })
+      await libp2p.peerStore.addressBook.set(remoteLibp2p.peerId, remoteLibp2p.multiaddrs)
+      await libp2p.dial(remoteLibp2p.peerId)
+
+      expect(denyOutboundConnection.called).to.be.true()
+    })
+
+    it('intercept inbound encrypted', async () => {
+      const denyInboundEncryptedConnection = sinon.stub().returns(false)
+
+      ;[libp2p] = await peerUtils.createPeer({
+        config: {
+          peerId: peerIds[0],
+          addresses: {
+            listen: ['/ip4/127.0.0.1/tcp/0/ws']
+          },
+          modules: baseOptions.modules,
+          connectionGater: {
+            denyInboundEncryptedConnection
+          }
+        }
+      })
+      await remoteLibp2p.peerStore.addressBook.set(libp2p.peerId, libp2p.multiaddrs)
+      await remoteLibp2p.dial(libp2p.peerId)
+
+      expect(denyInboundEncryptedConnection.called).to.be.true()
+      expect(denyInboundEncryptedConnection.getCall(0)).to.have.nested.property('args[0].id').that.equalBytes(remoteLibp2p.peerId.id)
+    })
+
+    it('intercept outbound encrypted', async () => {
+      const denyOutboundEncryptedConnection = sinon.stub().returns(false)
+
+      ;[libp2p] = await peerUtils.createPeer({
+        config: {
+          peerId: peerIds[0],
+          addresses: {
+            listen: ['/ip4/127.0.0.1/tcp/0/ws']
+          },
+          modules: baseOptions.modules,
+          connectionGater: {
+            denyOutboundEncryptedConnection
+          }
+        }
+      })
+      await libp2p.peerStore.addressBook.set(remoteLibp2p.peerId, remoteLibp2p.multiaddrs)
+      await libp2p.dial(remoteLibp2p.peerId)
+
+      expect(denyOutboundEncryptedConnection.called).to.be.true()
+      expect(denyOutboundEncryptedConnection.getCall(0)).to.have.nested.property('args[0].id').that.equalBytes(remoteLibp2p.peerId.id)
+    })
+
+    it('intercept inbound upgraded', async () => {
+      const denyInboundUpgradedConnection = sinon.stub().returns(false)
+
+      ;[libp2p] = await peerUtils.createPeer({
+        config: {
+          peerId: peerIds[0],
+          addresses: {
+            listen: ['/ip4/127.0.0.1/tcp/0/ws']
+          },
+          modules: baseOptions.modules,
+          connectionGater: {
+            denyInboundUpgradedConnection
+          }
+        }
+      })
+      await remoteLibp2p.peerStore.addressBook.set(libp2p.peerId, libp2p.multiaddrs)
+      await remoteLibp2p.dial(libp2p.peerId)
+
+      expect(denyInboundUpgradedConnection.called).to.be.true()
+      expect(denyInboundUpgradedConnection.getCall(0)).to.have.nested.property('args[0].id').that.equalBytes(remoteLibp2p.peerId.id)
+    })
+
+    it('intercept outbound upgraded', async () => {
+      const denyOutboundUpgradedConnection = sinon.stub().returns(false)
+
+      ;[libp2p] = await peerUtils.createPeer({
+        config: {
+          peerId: peerIds[0],
+          addresses: {
+            listen: ['/ip4/127.0.0.1/tcp/0/ws']
+          },
+          modules: baseOptions.modules,
+          connectionGater: {
+            denyOutboundUpgradedConnection
+          }
+        }
+      })
+      await libp2p.peerStore.addressBook.set(remoteLibp2p.peerId, remoteLibp2p.multiaddrs)
+      await libp2p.dial(remoteLibp2p.peerId)
+
+      expect(denyOutboundUpgradedConnection.called).to.be.true()
+      expect(denyOutboundUpgradedConnection.getCall(0)).to.have.nested.property('args[0].id').that.equalBytes(remoteLibp2p.peerId.id)
+    })
+  })
 })

test/connection-manager/index.spec.js

@@ -77,7 +77,7 @@ describe('Connection Manager', () => {
       const value = Math.random()
       spies.set(value, spy)
       libp2p.connectionManager.setPeerValue(connection.remotePeer, value)
-      libp2p.connectionManager.onConnect(connection)
+      await libp2p.connectionManager.onConnect(connection)
     }))
 
     // get the lowest value
@@ -109,8 +109,8 @@ describe('Connection Manager', () => {
     const spy = sinon.spy()
     await Promise.all([...new Array(max + 1)].map(async () => {
       const connection = await mockConnection()
-      sinon.stub(connection, 'close').callsFake(() => spy()) // eslint-disable-line
+      sinon.stub(connection, 'close').callsFake(async () => spy()) // eslint-disable-line
-      libp2p.connectionManager.onConnect(connection)
+      await libp2p.connectionManager.onConnect(connection)
     }))
 
     expect(libp2p.connectionManager._maybeDisconnectOne).to.have.property('callCount', 1)