chore: release 0.36.2 (#1147)

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

.github/workflows/main.yml

@@ -8,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
-    - run: npm install
+        node-version: lts/*
+    - 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@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: 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
-      - run: npm run test:browser -- -t browser -t webworker --bail
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:browser -- -t browser --cov --bail
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          directory: ./.nyc_output
+          flags: chrome
+
+  test-chrome-webworker:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:browser -- -t webworker --bail
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          directory: ./.nyc_output
+          flags: chrome-webworker
+
   test-firefox:
-    needs: check
+    needs: build
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - uses: actions/setup-node@v2
         with:
           node-version: lts/*
-      - run: npm install
-      - run: npm run test:browser -- -t browser -t webworker --bail -- --browser firefox
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:browser -- -t browser --bail -- --browser firefox
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          directory: ./.nyc_output
+          flags: firefox
+
+  test-firefox-webworker:
+    needs: build
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: actions/setup-node@v2
+        with:
+          node-version: lts/*
+      - uses: ipfs/aegir/actions/cache-node-modules@master
+      - run: npm run test:browser -- -t webworker --bail -- --browser firefox
+      - uses: codecov/codecov-action@f32b3a3741e1053eb607407145bc9619351dc93b # v2.1.0
+        with:
+          directory: ./.nyc_output
+          flags: firefox-webworker
+
   test-ts:
-    needs: check
+    needs: build
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v2
       - 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,57 @@
+## [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.2](https://www.github.com/libp2p/js-libp2p/compare/v0.36.1...v0.36.2) (2022-01-26)
+
+
+### Bug Fixes
+
+* reject connections when not running ([#1146](https://www.github.com/libp2p/js-libp2p/issues/1146)) ([902f10d](https://www.github.com/libp2p/js-libp2p/commit/902f10d58d1062e812eb27aa0e2256e3fde5d3f6))
+
+### [0.36.1](https://www.github.com/libp2p/js-libp2p/compare/v0.36.0...v0.36.1) (2022-01-25)
+
+
+### Bug Fixes
+
+* await unhandle of protocols ([#1144](https://www.github.com/libp2p/js-libp2p/issues/1144)) ([d44bd90](https://www.github.com/libp2p/js-libp2p/commit/d44bd9094fe9545054eb8eff68f81bc52ece03e7))
+
+## [0.36.0](https://www.github.com/libp2p/js-libp2p/compare/v0.35.8...v0.36.0) (2022-01-25)
+
+
+### ⚠ BREAKING CHANGES
+
+* abort-controller dep is gone from dependency tree
+* `libp2p.handle`, `libp2p.registrar.register` and the peerstore methods have become async
+
+### Features
+
+* add fetch protocol ([#1036](https://www.github.com/libp2p/js-libp2p/issues/1036)) ([d8ceb0b](https://www.github.com/libp2p/js-libp2p/commit/d8ceb0bc66fe225d1335d3f05b9a3a30983c2a57))
+* async peerstore backed by datastores ([#1058](https://www.github.com/libp2p/js-libp2p/issues/1058)) ([978eb36](https://www.github.com/libp2p/js-libp2p/commit/978eb3676fad5d5d50ddb28d1a7868f448cbb20b))
+* connection gater ([#1142](https://www.github.com/libp2p/js-libp2p/issues/1142)) ([ff32eba](https://www.github.com/libp2p/js-libp2p/commit/ff32eba6a0fa222af1a7a46775d5e0346ad6ebdf))
+
+
+### Bug Fixes
+
+* cache build artefacts ([#1091](https://www.github.com/libp2p/js-libp2p/issues/1091)) ([5043cd5](https://www.github.com/libp2p/js-libp2p/commit/5043cd56435a264e83db4fb8388d33e9a0442fff))
+* catch errors during identify ([#1138](https://www.github.com/libp2p/js-libp2p/issues/1138)) ([12f1bb0](https://www.github.com/libp2p/js-libp2p/commit/12f1bb0aeec4b639bd2af05807215f3b4284e379))
+* import uint8arrays package in example ([#1083](https://www.github.com/libp2p/js-libp2p/issues/1083)) ([c3700f5](https://www.github.com/libp2p/js-libp2p/commit/c3700f55d5a0b62182d683ca37258887b24065b9))
+* make tests more reliable ([#1139](https://www.github.com/libp2p/js-libp2p/issues/1139)) ([b7e8706](https://www.github.com/libp2p/js-libp2p/commit/b7e87066a69970f1adca4ba552c7fdf624916a7e))
+* prevent auto-dialer from dialing self ([#1104](https://www.github.com/libp2p/js-libp2p/issues/1104)) ([9b22c6e](https://www.github.com/libp2p/js-libp2p/commit/9b22c6e2f987a20c6639cd07f31fe9c824e24923))
+* remove abort-controller dep ([#1095](https://www.github.com/libp2p/js-libp2p/issues/1095)) ([0a4dc54](https://www.github.com/libp2p/js-libp2p/commit/0a4dc54d084c901df47cce1788bd5922090ee037))
+* try all peer addresses when dialing a relay ([#1140](https://www.github.com/libp2p/js-libp2p/issues/1140)) ([63aa480](https://www.github.com/libp2p/js-libp2p/commit/63aa480800974515f44d3b7e013da9c8ccaae8ad))
+* update any-signal and timeout-abort-controller ([#1128](https://www.github.com/libp2p/js-libp2p/issues/1128)) ([e0354b4](https://www.github.com/libp2p/js-libp2p/commit/e0354b4c6b95bb90656b868849182eb3efddf096))
+* update multistream select ([#1136](https://www.github.com/libp2p/js-libp2p/issues/1136)) ([00e4959](https://www.github.com/libp2p/js-libp2p/commit/00e49592a356e39b20c889d5f40b9bb37d4bf293))
+* update node-forge ([#1133](https://www.github.com/libp2p/js-libp2p/issues/1133)) ([a4bba35](https://www.github.com/libp2p/js-libp2p/commit/a4bba35948e1cd8dbe5147f2c8d6385b1fbb6fae))
+
 ## [0.35.7](https://github.com/libp2p/js-libp2p/compare/v0.35.2...v0.35.7) (2021-12-24)
 
 
@@ -1749,6 +1803,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)
-
-
-

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,7 +500,7 @@ const Libp2p = require('libp2p')
 const TCP = require('libp2p-tcp')
 const MPLEX = require('libp2p-mplex')
 const { NOISE } = require('libp2p-noise')
-const LevelDatastore = require('datastore-level')
+const { LevelDatastore } = require('datastore-level')
 
 const datastore = new LevelDatastore('path/to/store')
 await datastore.open()
@@ -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')

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

examples/delegated-routing/package.json

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

examples/delegated-routing/src/App.js

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

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

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

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

examples/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.23.0",
+    "libp2p-webrtc-star": "^0.25.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)
-  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
 
   await Promise.all([
     node1.dial(node2.peerId),

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

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

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

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

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

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

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

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

examples/pnet/index.js

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

examples/pnet/test.js

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

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

@@ -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,8 +32,8 @@ const createNode = async () => {
   ])
 
   // Add node's 2 data to the PeerStore
-  node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
-  
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+
   node1.handle('/node-1', ({ stream }) => {
     pipe(
       stream,

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

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

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

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

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

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

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

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

examples/pubsub/1.js

@@ -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,7 +35,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)
   await node1.dial(node2.peerId)
 
   node1.pubsub.on(topic, (msg) => {

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)
-  node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
-  node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)
+  await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+  await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+  await node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)
 
   // node 1 (TCP) dials to node 2 (TCP+WebSockets)
   const { stream } = await node1.dialProtocol(node2.peerId, '/print')

examples/transports/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)
-node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
-node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)
+await node1.peerStore.addressBook.set(node2.peerId, node2.multiaddrs)
+await node2.peerStore.addressBook.set(node3.peerId, node3.multiaddrs)
+await node3.peerStore.addressBook.set(node1.peerId, node1.multiaddrs)
 
 // node 1 (TCP) dials to node 2 (TCP+WebSockets)
 const { stream } = await node1.dialProtocol(node2.peerId, '/print')

examples/transports/test-1.js

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

examples/transports/test-2.js

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

examples/transports/test-3.js

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

examples/transports/test-4.js

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

examples/utils.js

@@ -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.7",
+  "version": "0.36.2",
   "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
   "leadMaintainer": "Jacob Heun <jacobheun@gmail.com>",
   "main": "src/index.js",
@@ -20,20 +20,20 @@
   "scripts": {
     "lint": "aegir lint",
     "build": "aegir build",
-    "build:proto": "npm run build:proto:circuit && npm run build:proto:identify && npm run build:proto:plaintext && npm run build:proto:address-book && npm run build:proto:proto-book && npm run build:proto:peer-record && npm run build:proto:envelope",
+    "build:proto": "npm run build:proto:circuit && npm run build:proto:fetch && npm run build:proto:identify && npm run build:proto:plaintext && npm run build:proto:address-book && npm run build:proto:proto-book && npm run build:proto:peer && npm run build:proto:peer-record && npm run build:proto:envelope",
     "build:proto:circuit": "pbjs -t static-module -w commonjs -r libp2p-circuit --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/circuit/protocol/index.js ./src/circuit/protocol/index.proto",
+    "build:proto:fetch": "pbjs -t static-module -w commonjs -r libp2p-fetch --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/fetch/proto.js ./src/fetch/proto.proto",
     "build:proto:identify": "pbjs -t static-module -w commonjs -r libp2p-identify --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/identify/message.js ./src/identify/message.proto",
     "build:proto:plaintext": "pbjs -t static-module -w commonjs -r libp2p-plaintext --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/insecure/proto.js ./src/insecure/proto.proto",
-    "build:proto:address-book": "pbjs -t static-module -w commonjs -r libp2p-address-book --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/peer-store/persistent/pb/address-book.js ./src/peer-store/persistent/pb/address-book.proto",
-    "build:proto:proto-book": "pbjs -t static-module -w commonjs -r libp2p-proto-book --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/peer-store/persistent/pb/proto-book.js ./src/peer-store/persistent/pb/proto-book.proto",
+    "build:proto:peer": "pbjs -t static-module -w commonjs -r libp2p-peer --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/peer-store/pb/peer.js ./src/peer-store/pb/peer.proto",
     "build:proto:peer-record": "pbjs -t static-module -w commonjs -r libp2p-peer-record --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/record/peer-record/peer-record.js ./src/record/peer-record/peer-record.proto",
     "build:proto:envelope": "pbjs -t static-module -w commonjs -r libp2p-envelope --force-number --no-verify --no-delimited --no-create --no-beautify --no-defaults --lint eslint-disable -o src/record/envelope/envelope.js ./src/record/envelope/envelope.proto",
-    "build:proto-types": "npm run build:proto-types:circuit && npm run build:proto-types:identify && npm run build:proto-types:plaintext && npm run build:proto-types:address-book && npm run build:proto-types:proto-book && npm run build:proto-types:peer-record && npm run build:proto-types:envelope",
+    "build:proto-types": "npm run build:proto-types:circuit && npm run build:proto-types:fetch && npm run build:proto-types:identify && npm run build:proto-types:plaintext && npm run build:proto-types:address-book && npm run build:proto-types:proto-book && npm run build:proto-types:peer && npm run build:proto-types:peer-record && npm run build:proto-types:envelope",
     "build:proto-types:circuit": "pbts -o src/circuit/protocol/index.d.ts src/circuit/protocol/index.js",
+    "build:proto-types:fetch": "pbts -o src/fetch/proto.d.ts src/fetch/proto.js",
     "build:proto-types:identify": "pbts -o src/identify/message.d.ts src/identify/message.js",
     "build:proto-types:plaintext": "pbts -o src/insecure/proto.d.ts src/insecure/proto.js",
-    "build:proto-types:address-book": "pbts -o src/peer-store/persistent/pb/address-book.d.ts src/peer-store/persistent/pb/address-book.js",
-    "build:proto-types:proto-book": "pbts -o src/peer-store/persistent/pb/proto-book.d.ts src/peer-store/persistent/pb/proto-book.js",
+    "build:proto-types:peer": "pbts -o src/peer-store/pb/peer.d.ts src/peer-store/pb/peer.js",
     "build:proto-types:peer-record": "pbts -o src/record/peer-record/peer-record.d.ts src/record/peer-record/peer-record.js",
     "build:proto-types:envelope": "pbts -o src/record/envelope/envelope.d.ts src/record/envelope/envelope.js",
     "test": "aegir test",
@@ -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",
-    "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",
+    "prepare": "npm run build",
     "coverage": "nyc --reporter=text --reporter=lcov npm run test:node"
   },
   "repository": {
@@ -81,12 +78,12 @@
   },
   "dependencies": {
     "@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",
@@ -98,23 +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-interfaces": "^2.0.1",
+    "libp2p-crypto": "^0.21.2",
+    "libp2p-interfaces": "^4.0.0",
     "libp2p-utils": "^0.4.0",
     "mafmt": "^10.0.0",
     "merge-options": "^3.0.4",
+    "mortice": "^2.0.1",
     "multiaddr": "^10.0.0",
     "multiformats": "^9.0.0",
-    "multistream-select": "^2.0.0",
+    "multistream-select": "^3.0.0",
     "mutable-proxy": "^1.0.0",
     "nat-api": "^0.3.1",
-    "node-forge": "^0.10.0",
+    "node-forge": "^1.2.1",
     "p-any": "^3.0.0",
     "p-fifo": "^1.0.0",
     "p-retry": "^4.4.0",
@@ -126,7 +126,7 @@
     "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",
@@ -137,11 +137,10 @@
     "@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",
@@ -152,13 +151,11 @@
     "libp2p-bootstrap": "^0.14.0",
     "libp2p-delegated-content-routing": "^0.11.0",
     "libp2p-delegated-peer-routing": "^0.11.1",
-    "libp2p-floodsub": "^0.28.0",
-    "libp2p-gossipsub": "^0.12.1",
-    "libp2p-interfaces-compliance-tests": "^2.0.1",
-    "libp2p-interop": "^0.5.0",
-    "libp2p-kad-dht": "^0.27.1",
+    "libp2p-interfaces-compliance-tests": "^4.0.8",
+    "libp2p-interop": "^0.7.1",
+    "libp2p-kad-dht": "^0.28.6",
     "libp2p-mdns": "^0.18.0",
-    "libp2p-mplex": "^0.10.1",
+    "libp2p-mplex": "^0.10.4",
     "libp2p-tcp": "^0.17.0",
     "libp2p-webrtc-star": "^0.25.0",
     "libp2p-websockets": "^0.16.0",
@@ -181,12 +178,12 @@
     "Friedel Ziegelmayer <dignifiedquire@gmail.com>",
     "Maciej Krüger <mkg20001@gmail.com>",
     "Hugo Dias <mail@hugodias.me>",
+    "dirkmc <dirkmdev@gmail.com>",
     "Volker Mische <volker.mische@gmail.com>",
     "Chris Dostert <chrisdostert@users.noreply.github.com>",
-    "dirkmc <dirkmdev@gmail.com>",
+    "zeim839 <50573884+zeim839@users.noreply.github.com>",
     "Robert Kiel <robert.kiel@hoprnet.org>",
     "Richard Littauer <richard.littauer@gmail.com>",
-    "zeim839 <50573884+zeim839@users.noreply.github.com>",
     "a1300 <matthias-knopp@gmx.net>",
     "Ryan Bell <ryan@piing.net>",
     "ᴠɪᴄᴛᴏʀ ʙᴊᴇʟᴋʜᴏʟᴍ <victorbjelkholm@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)])
-      // Announce multiaddrs will update on listen success by TransportManager event being triggered
+      // Check if already listening on enough relays
+      if (this._listenRelays.size >= this.maxListeners) {
+        return
+      }
+
+      // Get peer known addresses and sort them per public addresses first
+      const remoteAddrs = await this._peerStore.addressBook.getMultiaddrsForPeer(
+        connection.remotePeer, this._addressSorter
+      )
+
+      // Attempt to listen on relay
+      const result = await Promise.all(
+        remoteAddrs.map(async addr => {
+          try {
+            // Announce multiaddrs will update on listen success by TransportManager event being triggered
+            await this._transportManager.listen([new Multiaddr(`${addr.toString()}/p2p-circuit`)])
+            return true
+          } catch (/** @type {any} */ err) {
+            this._onError(err)
+          }
+
+          return false
+        })
+      )
+
+      if (result.includes(true)) {
+        this._listenRelays.add(id)
+      }
     } catch (/** @type {any} */ err) {
       this._onError(err)
       this._listenRelays.delete(id)
@@ -180,12 +190,11 @@ class AutoRelay {
    *
    * @private
    * @param {string} id - peer identifier string.
-   * @returns {void}
    */
-  _removeListenRelay (id) {
+  async _removeListenRelay (id) {
     if (this._listenRelays.delete(id)) {
       // TODO: this should be responsibility of the connMgr
-      this._listenOnAvailableHopRelays([id])
+      await this._listenOnAvailableHopRelays([id])
     }
   }
 
@@ -197,7 +206,6 @@ class AutoRelay {
    * 3. Search the network.
    *
    * @param {string[]} [peersToIgnore]
-   * @returns {Promise<void>}
    */
   async _listenOnAvailableHopRelays (peersToIgnore = []) {
     // TODO: The peer redial issue on disconnect should be handled by connection gating
@@ -207,31 +215,37 @@ class AutoRelay {
     }
 
     const knownHopsToDial = []
+    const peers = await all(this._peerStore.getPeers())
 
     // Check if we have known hop peers to use and attempt to listen on the already connected
-    for (const [id, metadataMap] of this._peerStore.metadataBook.data.entries()) {
+    for await (const { id, metadata } of peers) {
+      const idStr = id.toB58String()
+
       // Continue to next if listening on this or peer to ignore
-      if (this._listenRelays.has(id) || peersToIgnore.includes(id)) {
+      if (this._listenRelays.has(idStr)) {
         continue
       }
 
-      const supportsHop = metadataMap.get(HOP_METADATA_KEY)
+      if (peersToIgnore.includes(idStr)) {
+        continue
+      }
+
+      const supportsHop = metadata.get(HOP_METADATA_KEY)
 
       // Continue to next if it does not support Hop
       if (!supportsHop || uint8ArrayToString(supportsHop) !== HOP_METADATA_VALUE) {
         continue
       }
 
-      const peerId = PeerId.createFromB58String(id)
-      const connection = this._connectionManager.get(peerId)
+      const connection = this._connectionManager.get(id)
 
       // If not connected, store for possible later use.
       if (!connection) {
-        knownHopsToDial.push(peerId)
+        knownHopsToDial.push(id)
         continue
       }
 
-      await this._addListenRelay(connection, id)
+      await this._addListenRelay(connection, idStr)
 
       // Check if already listening on enough relays
       if (this._listenRelays.size >= this.maxListeners) {
@@ -258,7 +272,7 @@ class AutoRelay {
         }
 
         const peerId = provider.id
-        this._peerStore.addressBook.add(peerId, provider.multiaddrs)
+        await this._peerStore.addressBook.add(peerId, provider.multiaddrs)
 
         await this._tryToListenOnRelay(peerId)
 

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

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
-    const peers = Array.from(this._libp2p.peerStore.peers.values())
-      .sort((a, b) => {
+    // Sort peers on whether we know protocols of public keys for them
+    // TODO: assuming the `peerStore.getPeers()` order is stable this will mean
+    // we keep trying to connect to the same peers?
+    const peers = await pipe(
+      this._libp2p.peerStore.getPeers(),
+      (source) => filter(source, (peer) => !peer.id.equals(this._libp2p.peerId)),
+      (source) => sort(source, (a, b) => {
         if (b.protocols && b.protocols.length && (!a.protocols || !a.protocols.length)) {
           return 1
         } else if (b.id.pubKey && !a.id.pubKey) {
           return 1
         }
         return -1
-      })
+      }),
+      (source) => all(source)
+    )
 
     for (let i = 0; this._running && i < peers.length && this._libp2p.connections.size < minConnections; i++) {
-      if (!this._libp2p.connectionManager.get(peers[i].id)) {
-        log('connecting to a peerStore stored peer %s', peers[i].id.toB58String())
+      const peer = peers[i]
+
+      if (!this._libp2p.connectionManager.get(peer.id)) {
+        log('connecting to a peerStore stored peer %s', peer.id.toB58String())
         try {
-          await this._libp2p.dialer.connectToPeer(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

@@ -87,14 +87,22 @@ class ConnectionManager extends EventEmitter {
      *
      * @type {Map<string, number>}
      */
-    this._peerValues = trackedMap(METRICS_COMPONENT, METRICS_PEER_VALUES, this._libp2p.metrics)
+    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 = trackedMap(METRICS_COMPONENT, METRICS_PEER_CONNECTIONS, this._libp2p.metrics)
+    this.connections = trackedMap({
+      component: METRICS_COMPONENT,
+      metric: METRICS_PEER_CONNECTIONS,
+      metrics: this._libp2p.metrics
+    })
 
     this._started = false
     this._timer = null
@@ -104,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)
   }
 
   /**
@@ -187,19 +198,22 @@ class ConnectionManager extends EventEmitter {
    *
    * @private
    */
-  _checkMetrics () {
+  async _checkMetrics () {
     if (this._libp2p.metrics) {
-      const movingAverages = this._libp2p.metrics.global.movingAverages
-      // @ts-ignore moving averages object types
-      const received = movingAverages.dataReceived[this._options.movingAverageInterval].movingAverage()
-      this._checkMaxLimit('maxReceivedData', received)
-      // @ts-ignore moving averages object types
-      const sent = movingAverages.dataSent[this._options.movingAverageInterval].movingAverage()
-      this._checkMaxLimit('maxSentData', sent)
-      const total = received + sent
-      this._checkMaxLimit('maxData', total)
-      log('metrics update', total)
-      this._timer = retimer(this._checkMetrics, this._options.pollInterval)
+      try {
+        const movingAverages = this._libp2p.metrics.global.movingAverages
+        // @ts-ignore moving averages object types
+        const received = movingAverages.dataReceived[this._options.movingAverageInterval].movingAverage()
+        await this._checkMaxLimit('maxReceivedData', received)
+        // @ts-ignore moving averages object types
+        const sent = movingAverages.dataSent[this._options.movingAverageInterval].movingAverage()
+        await this._checkMaxLimit('maxSentData', sent)
+        const total = received + sent
+        await this._checkMaxLimit('maxData', total)
+        log('metrics update', total)
+      } finally {
+        this._timer = retimer(this._checkMetrics, this._options.pollInterval)
+      }
     }
   }
 
@@ -207,9 +221,14 @@ class ConnectionManager extends EventEmitter {
    * Tracks the incoming connection and check the connection limit
    *
    * @param {Connection} connection
-   * @returns {void}
    */
-  onConnect (connection) {
+  async onConnect (connection) {
+    if (!this._started) {
+      // This can happen when we are in the process of shutting down the node
+      await connection.close()
+      return
+    }
+
     const peerId = connection.remotePeer
     const peerIdStr = peerId.toB58String()
     const storedConn = this.connections.get(peerIdStr)
@@ -222,13 +241,13 @@ class ConnectionManager extends EventEmitter {
       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)
   }
 
   /**
@@ -238,6 +257,11 @@ class ConnectionManager extends EventEmitter {
    * @returns {void}
    */
   onDisconnect (connection) {
+    if (!this._started) {
+      // This can happen when we are in the process of shutting down the node
+      return
+    }
+
     const peerId = connection.remotePeer.toB58String()
     let storedConn = this.connections.get(peerId)
 
@@ -296,6 +320,9 @@ class ConnectionManager extends EventEmitter {
    */
   _onLatencyMeasure (summary) {
     this._checkMaxLimit('maxEventLoopDelay', summary.avgMs)
+      .catch(err => {
+        log.error(err)
+      })
   }
 
   /**
@@ -305,12 +332,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()
     }
   }
 
@@ -320,7 +347,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)
@@ -331,7 +358,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/utils.js

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

src/dht/dht-peer-routing.js

@@ -27,12 +27,8 @@ class DHTPeerRouting {
    */
   async findPeer (peerId, options = {}) {
     for await (const event of this._dht.findPeer(peerId, options)) {
-      if (event.name === 'PEER_RESPONSE') {
-        const peer = event.closer.find(peerData => peerData.id.equals(peerId))
-
-        if (peer) {
-          return peer
-        }
+      if (event.name === 'FINAL_PEER') {
+        return event.peer
       }
     }
 

src/dialer/dial-request.js

@@ -63,7 +63,10 @@ class DialRequest {
     tokens.forEach(token => tokenHolder.push(token))
     const dialAbortControllers = this.addrs.map(() => {
       const controller = new AbortController()
-      setMaxListeners && setMaxListeners(Infinity, controller.signal)
+      try {
+        // fails on node < 15.4
+        setMaxListeners && setMaxListeners(Infinity, controller.signal)
+      } catch {}
 
       return controller
     })

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')
 })
@@ -30,15 +33,17 @@ const METRICS_PENDING_DIAL_TARGETS = 'pending-dial-targets'
 /**
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
  * @typedef {import('peer-id')} PeerId
- * @typedef {import('../peer-store')} PeerStore
- * @typedef {import('../peer-store/address-book').Address} Address
+ * @typedef {import('../peer-store/types').PeerStore} PeerStore
+ * @typedef {import('../peer-store/types').Address} Address
  * @typedef {import('../transport-manager')} TransportManager
+ * @typedef {import('../types').ConnectionGater} ConnectionGater
  */
 
 /**
  * @typedef {Object} DialerProperties
  * @property {PeerStore} peerStore
  * @property {TransportManager} transportManager
+ * @property {ConnectionGater} connectionGater
  *
  * @typedef {(addr:Multiaddr) => Promise<string[]>} Resolver
  *
@@ -70,6 +75,7 @@ class Dialer {
   constructor ({
     transportManager,
     peerStore,
+    connectionGater,
     addressSorter = publicAddressesFirst,
     maxParallelDials = MAX_PARALLEL_DIALS,
     maxAddrsToDial = MAX_ADDRS_TO_DIAL,
@@ -78,6 +84,7 @@ class Dialer {
     resolvers = {},
     metrics
   }) {
+    this.connectionGater = connectionGater
     this.transportManager = transportManager
     this.peerStore = peerStore
     this.addressSorter = addressSorter
@@ -88,10 +95,18 @@ class Dialer {
     this.tokens = [...new Array(maxParallelDials)].map((_, index) => index)
 
     /** @type {Map<string, PendingDial>} */
-    this._pendingDials = trackedMap(METRICS_COMPONENT, METRICS_PENDING_DIALS, metrics)
+    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(METRICS_COMPONENT, METRICS_PENDING_DIAL_TARGETS, metrics)
+    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)
@@ -128,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) {
@@ -192,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.
@@ -215,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)
     }
 
@@ -252,14 +279,18 @@ class Dialer {
 
     // Combine the timeout signal and options.signal, if provided
     const timeoutController = new TimeoutController(this.timeout)
-    // this controller will potentially be used while dialing lots of
-    // peers so prevent MaxListenersExceededWarning appearing in the console
-    setMaxListeners && setMaxListeners(Infinity, timeoutController.signal)
 
     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,

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

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)) {
-        this.peerStore.protoBook.set(id, protocols)
-        this.peerStore.metadataBook.set(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
-        this.peerStore.metadataBook.set(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
+      if (await this.peerStore.addressBook.consumePeerRecord(envelope)) {
+        await this.peerStore.protoBook.set(id, protocols)
+        await this.peerStore.metadataBook.setValue(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
+        await this.peerStore.metadataBook.setValue(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
         return
       }
     } catch (/** @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)
-    this.peerStore.metadataBook.set(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
-    this.peerStore.metadataBook.set(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
+    await this.peerStore.protoBook.set(id, protocols)
+    await this.peerStore.metadataBook.setValue(id, 'AgentVersion', uint8ArrayFromString(message.agentVersion))
+    await this.peerStore.metadataBook.setValue(id, 'ProtocolVersion', uint8ArrayFromString(message.protocolVersion))
 
     // TODO: Add and score our observed addr
     log('received observed address of %s', cleanObservedAddr)
@@ -262,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)) {
-        this.peerStore.protoBook.set(id, message.protocols)
+      if (await this.peerStore.addressBook.consumePeerRecord(envelope)) {
+        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 PingService = require('./ping')
 const NatManager = require('./nat-manager')
 const { updateSelfPeerRecord } = require('./record/utils')
 
@@ -48,6 +48,7 @@ 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]
  */
@@ -106,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 & PersistentPeerStoreOptions} [peerStore]
+ * @property {PeerStoreOptions} [peerStore]
  * @property {import('./transport-manager').TransportManagerOptions} [transportManager]
  * @property {Libp2pConfig} [config]
  *
@@ -172,13 +174,26 @@ class Libp2p extends EventEmitter {
       this.metrics = metrics
     }
 
-    this.peerStore = (this.datastore && this._options.peerStore.persistence)
-      ? new PersistentPeerStore({
-        peerId: this.peerId,
-        datastore: this.datastore,
-        ...this._options.peerStore
-      })
-      : new PeerStore({ peerId: this.peerId })
+    /** @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
@@ -222,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),
@@ -264,6 +280,7 @@ class Libp2p extends EventEmitter {
 
     this.dialer = new Dialer({
       transportManager: this.transportManager,
+      connectionGater: this.connectionGater,
       peerStore: this.peerStore,
       metrics: this.metrics,
       ...this._options.dialer
@@ -290,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
@@ -323,10 +339,10 @@ class Libp2p extends EventEmitter {
     this.peerRouting = new PeerRouting(this)
     this.contentRouting = new ContentRouting(this)
 
-    // Mount default protocols
-    ping.mount(this)
-
     this._onDiscoveryPeer = this._onDiscoveryPeer.bind(this)
+
+    this.fetchService = new FetchService(this)
+    this.pingService = new PingService(this)
   }
 
   /**
@@ -356,6 +372,18 @@ 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)
+    }
+
+    if (this.pingService) {
+      await this.handle(PingService.getProtocolStr(this), this.pingService.handleMessage)
+    }
+
     try {
       await this._onStarting()
       await this._onDidStart()
@@ -380,9 +408,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()) {
@@ -393,7 +425,6 @@ class Libp2p extends EventEmitter {
 
       this._discovery = new Map()
 
-      await this.peerStore.stop()
       await this.connectionManager.stop()
 
       await Promise.all([
@@ -404,7 +435,9 @@ class Libp2p extends EventEmitter {
       await this.natManager.stop()
       await this.transportManager.close()
 
-      ping.unmount(this)
+      await this.unhandle(FetchService.PROTOCOL)
+      await this.unhandle(PingService.getProtocolStr(this))
+
       this.dialer.destroy()
     } catch (/** @type {any} */ err) {
       if (err) {
@@ -499,7 +532,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
@@ -556,6 +589,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.
    *
@@ -567,10 +611,10 @@ class Libp2p extends EventEmitter {
 
     // If received multiaddr, ping it
     if (multiaddrs) {
-      return ping(this, multiaddrs[0])
+      return this.pingService.ping(multiaddrs[0])
     }
 
-    return ping(this, id)
+    return this.pingService.ping(id)
   }
 
   /**
@@ -579,14 +623,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)
   }
 
   /**
@@ -595,14 +639,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 () {
@@ -613,11 +657,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
@@ -631,6 +672,10 @@ class Libp2p extends EventEmitter {
 
     // Start metrics if present
     this.metrics && this.metrics.start()
+
+    if (this.identifyService) {
+      await this.identifyService.start()
+    }
   }
 
   /**
@@ -643,17 +688,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()
@@ -677,8 +724,8 @@ class Libp2p extends EventEmitter {
       return
     }
 
-    peer.multiaddrs && this.peerStore.addressBook.add(peer.id, peer.multiaddrs)
-    peer.protocols && this.peerStore.protoBook.set(peer.id, peer.protocols)
+    peer.multiaddrs && this.peerStore.addressBook.add(peer.id, peer.multiaddrs).catch(err => log.error(err))
+    peer.protocols && this.peerStore.protoBook.set(peer.id, peer.protocols).catch(err => log.error(err))
   }
 
   /**

src/metrics/index.js

@@ -44,7 +44,7 @@ class Metrics {
     this._oldPeers = oldPeerLRU(this._options.maxOldPeersRetention)
     this._running = false
     this._onMessage = this._onMessage.bind(this)
-    this._componentMetrics = new Map()
+    this._systems = new Map()
   }
 
   /**
@@ -89,19 +89,26 @@ class Metrics {
   }
 
   /**
-   * @returns {Map}
+   * @returns {Map<string, Map<string, Map<string, any>>>}
    */
   getComponentMetrics () {
-    return this._componentMetrics
+    return this._systems
   }
 
-  updateComponentMetric (component, metric, value) {
-    if (!this._componentMetrics.has(component)) {
-      this._componentMetrics.set(component, new Map())
+  updateComponentMetric ({ system = 'libp2p', component, metric, value }) {
+    if (!this._systems.has(system)) {
+      this._systems.set(system, new Map())
     }
 
-    const map = this._componentMetrics.get(component)
-    map.set(metric, value)
+    const systemMetrics = this._systems.get(system)
+
+    if (!systemMetrics.has(component)) {
+      systemMetrics.set(component, new Map())
+    }
+
+    const componentMetrics = systemMetrics.get(component)
+
+    componentMetrics.set(metric, value)
   }
 
   /**

src/metrics/tracked-map.js

@@ -6,18 +6,27 @@
  */
 class TrackedMap extends Map {
   /**
-   * @param {string} component
-   * @param {string} name
-   * @param {import('.')} metrics
+   * @param {object} options
+   * @param {string} options.system
+   * @param {string} options.component
+   * @param {string} options.metric
+   * @param {import('.')} options.metrics
    */
-  constructor (component, name, metrics) {
+  constructor (options) {
     super()
 
+    const { system, component, metric, metrics } = options
+    this._system = system
     this._component = component
-    this._name = name
+    this._metric = metric
     this._metrics = metrics
 
-    this._metrics.updateComponentMetric(this._component, this._name, this.size)
+    this._metrics.updateComponentMetric({
+      system: this._system,
+      component: this._component,
+      metric: this._metric,
+      value: this.size
+    })
   }
 
   /**
@@ -26,7 +35,12 @@ class TrackedMap extends Map {
    */
   set (key, value) {
     super.set(key, value)
-    this._metrics.updateComponentMetric(this._component, this._name, this.size)
+    this._metrics.updateComponentMetric({
+      system: this._system,
+      component: this._component,
+      metric: this._metric,
+      value: this.size
+    })
     return this
   }
 
@@ -35,25 +49,43 @@ class TrackedMap extends Map {
    */
   delete (key) {
     const deleted = super.delete(key)
-    this._metrics.updateComponentMetric(this._component, this._name, this.size)
+    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 {string} component
- * @param {string} name
- * @param {import('.')} [metrics]
+ * @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 = (component, name, metrics) => {
+module.exports = ({ system = 'libp2p', component, metric, metrics }) => {
   /** @type {Map<K, V>} */
   let map
 
   if (metrics) {
-    map = new TrackedMap(component, name, metrics)
+    map = new TrackedMap({ system, component, metric, metrics })
   } else {
     map = new Map()
   }

src/peer-routing.js

@@ -154,7 +154,10 @@ class PeerRouting {
       const controller = new TimeoutController(options.timeout)
       // this controller will potentially be used while dialing lots of
       // peers so prevent MaxListenersExceededWarning appearing in the console
-      setMaxListeners && setMaxListeners(Infinity, controller.signal)
+      try {
+        // fails on node < 15.4
+        setMaxListeners && setMaxListeners(Infinity, controller.signal)
+      } catch {}
 
       options.signal = controller.signal
     }

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 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')
+const EVENT_NAME = 'change:multiaddrs'
 
 /**
- * @typedef {import('./')} PeerStore
+ * @implements {AddressBook}
  */
-
-/**
- * @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 {
+class PeerStoreAddressBook {
   /**
-   * The AddressBook is responsible for keeping the known multiaddrs of a peer.
-   *
-   * @class
-   * @param {PeerStore} peerStore
+   * @param {PeerStore["emit"]} emit
+   * @param {import('./types').Store} store
+   * @param {(peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>} addressFilter
    */
-  constructor (peerStore) {
-    /**
-     * PeerStore Event emitter, used by the AddressBook to emit:
-     * "peer" - emitted when a peer is discovered by the node.
-     * "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()
+  constructor (emit, store, addressFilter) {
+    this._emit = emit
+    this._store = store
+    this._addressFilter = addressFilter
   }
 
   /**
@@ -77,69 +46,90 @@ class AddressBook extends Book {
    * into the AddressBook.
    *
    * @param {Envelope} envelope
-   * @returns {boolean}
    */
-  consumePeerRecord (envelope) {
-    let peerRecord
+  async consumePeerRecord (envelope) {
+    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)
-    } 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
+      let peerRecord
+      try {
+        peerRecord = PeerRecord.createFromProtobuf(envelope.payload)
+      } catch (/** @type {any} */ err) {
+        log.error('invalid peer record received')
+        return false
       }
-    })
-    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) {
-    const entry = this.data.get(peerId.toB58String())
+  async getRawEnvelope (peerId) {
+    log('getRawEnvelope await read lock')
+    const release = await this._store.lock.readLock()
+    log('getRawEnvelope got read lock')
 
-    if (!entry || !entry.record || !entry.record.raw) {
-      return undefined
+    try {
+      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) {
-    const raw = this.getRawEnvelope(peerId)
+  async getPeerRecord (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
-    if (!addresses.length) {
-      return this
-    }
+    try {
+      const peer = await this._store.load(peerId)
 
-    const id = peerId.toB58String()
-    const entry = this.data.get(id)
-
-    // Already knows the peer
-    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
+      return peer.addresses
+    } catch (/** @type {any} */ err) {
+      if (err.code !== codes.ERR_NOT_FOUND) {
+        throw err
       }
+    } finally {
+      log('get release read lock')
+      release()
     }
 
-    this._setData(peerId, {
-      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
+    return []
   }
 
   /**
-   * 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)
-    const id = peerId.toB58String()
-
-    // No addresses to be added
-    if (!addresses.length) {
-      return this
+    if (!Array.isArray(multiaddrs)) {
+      log.error('multiaddrs must be an array of Multiaddrs')
+      throw errcode(new Error('multiaddrs must be an array of Multiaddrs'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    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) {
-      // Add recorded uniquely to the new array (Union)
-      entry.addresses.forEach((addr) => {
-        if (!addresses.find(r => r.multiaddr.equals(addr.multiaddr))) {
-          addresses.push(addr)
+    let hasPeer = false
+    let updatedPeer
+
+    try {
+      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, {
-      addresses,
-      record: entry && entry.record
-    })
+    this._emit(EVENT_NAME, { peerId, multiaddrs: updatedPeer.addresses.map(addr => addr.multiaddr) })
 
-    log(`added provided multiaddrs for ${id}`)
-
-    // Notify the existance of a new peer
-    if (!(entry && entry.addresses)) {
-      this._ps.emit('peer', peerId)
+    // Notify the existence of a new peer
+    if (!hasPeer) {
+      this._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) {
-    if (!multiaddrs) {
-      log.error('multiaddrs must be provided to store data')
-      throw errcode(new Error('multiaddrs must be provided'), ERR_INVALID_PARAMETERS)
+  async add (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'), codes.ERR_INVALID_PARAMETERS)
     }
 
-    // create Address for each address
-    /** @type {Address[]} */
-    const addresses = []
-    multiaddrs.forEach((addr) => {
-      if (!Multiaddr.isMultiaddr(addr)) {
-        log.error(`multiaddr ${addr} must be an instance of multiaddr`)
-        throw errcode(new Error(`multiaddr ${addr} must be an instance of multiaddr`), ERR_INVALID_PARAMETERS)
+    if (!Array.isArray(multiaddrs)) {
+      log.error('multiaddrs must be an array of Multiaddrs')
+      throw errcode(new Error('multiaddrs must be an array of Multiaddrs'), codes.ERR_INVALID_PARAMETERS)
+    }
+
+    log('add await write lock')
+    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
-      if (!addresses.find((a) => a.multiaddr.equals(addr))) {
-        addresses.push({
-          multiaddr: addr,
-          isCertified
-        })
-      }
-    })
+      try {
+        const peer = await this._store.load(peerId)
+        hasPeer = true
 
-    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.toB58String()}`)
+    } 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) {
-    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())
-    if (!entry || !entry.addresses) {
-      return undefined
-    }
+  async getMultiaddrsForPeer (peerId, addressSorter = (ms) => ms) {
+    const addresses = await this.get(peerId)
 
     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,124 +0,0 @@
-'use strict'
-
-const errcode = require('err-code')
-const PeerId = require('peer-id')
-const { codes } = 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'), codes.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'), codes.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'), codes.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 {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
+const Store = require('./store')
 
 /**
- * @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.
- * @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.
+ * @implements {PeerStore}
  */
-class PeerStore extends EventEmitter {
+class DefaultPeerStore extends EventEmitter {
   /**
-   * Peer object
-   *
-   * @typedef {Object} Peer
-   * @property {PeerId} id peer's peer-id instance.
-   * @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.
+   * @param {object} properties
+   * @param {PeerId} properties.peerId
+   * @param {import('interface-datastore').Datastore} properties.datastore
+   * @param {(peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>} properties.addressFilter
    */
-
-  /**
-   * Responsible for managing known peers, as well as their addresses, protocols and metadata.
-   *
-   * @param {object} options
-   * @param {PeerId} options.peerId
-   * @class
-   */
-  constructor ({ peerId }) {
+  constructor ({ peerId, datastore, addressFilter }) {
     super()
 
     this._peerId = peerId
+    this._store = new Store(datastore)
 
-    /**
-     * AddressBook containing a map of peerIdStr to Address.
-     */
-    this.addressBook = new AddressBook(this)
+    this.addressBook = new AddressBook(this.emit.bind(this), this._store, addressFilter)
+    this.keyBook = new KeyBook(this.emit.bind(this), this._store)
+    this.metadataBook = new MetadataBook(this.emit.bind(this), this._store)
+    this.protoBook = new ProtoBook(this.emit.bind(this), this._store)
+  }
 
-    /**
-     * KeyBook containing a map of peerIdStr to their PeerId with public keys.
-     */
-    this.keyBook = new KeyBook(this)
+  async * getPeers () {
+    log('getPeers await read lock')
+    const release = await this._store.lock.readLock()
+    log('getPeers got read lock')
 
-    /**
-     * MetadataBook containing a map of peerIdStr to their metadata Map.
-     */
-    this.metadataBook = new MetadataBook(this)
+    try {
+      for await (const peer of this._store.all()) {
+        if (peer.id.toB58String() === this._peerId.toB58String()) {
+          // Remove self peer if present
+          continue
+        }
 
-    /**
-     * ProtoBook containing a map of peerIdStr to supported protocols.
-     */
-    this.protoBook = new ProtoBook(this)
+        yield peer
+      }
+    } finally {
+      log('getPeers release read lock')
+      release()
+    }
   }
 
   /**
-   * Start the PeerStore.
-   */
-  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.
+   * Delete the information of the given peer in every book
    *
    * @param {PeerId} peerId
-   * @returns {boolean} true if found and removed
    */
-  delete (peerId) {
-    const addressesDeleted = this.addressBook.delete(peerId)
-    const keyDeleted = this.keyBook.delete(peerId)
-    const protocolsDeleted = this.protoBook.delete(peerId)
-    const metadataDeleted = this.metadataBook.delete(peerId)
+  async delete (peerId) {
+    log('delete await write lock')
+    const release = await this._store.lock.writeLock()
+    log('delete got write lock')
 
-    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) {
-    if (!PeerId.isPeerId(peerId)) {
-      throw errcode(new Error('peerId must be an instance of peer-id'), ERR_INVALID_PARAMETERS)
+  async get (peerId) {
+    log('get await read lock')
+    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)
-    const metadata = this.metadataBook.get(peerId)
-    const protocols = this.protoBook.get(peerId)
+  /**
+   * Returns true if we have a record of the peer
+   *
+   * @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) {
-      return undefined
-    }
-
-    return {
-      id: id || peerId,
-      addresses: addresses || [],
-      protocols: protocols || [],
-      metadata: metadata
+    try {
+      return this._store.has(peerId)
+    } finally {
+      log('has release read lock')
+      release()
     }
   }
 }
 
-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 Book = require('./book')
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
+const EVENT_NAME = 'change:pubkey'
 
 /**
- * @typedef {import('./')} PeerStore
- * @typedef {import('libp2p-crypto').PublicKey} PublicKey
+ * @implements {KeyBook}
  */
-
-/**
- * @extends {Book}
- */
-class KeyBook extends Book {
+class PeerStoreKeyBook {
   /**
    * The KeyBook is responsible for keeping the known public keys of a peer.
    *
-   * @class
-   * @param {PeerStore} peerStore
+   * @param {PeerStore["emit"]} emit
+   * @param {import('./types').Store} store
    */
-  constructor (peerStore) {
-    super({
-      peerStore,
-      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()
+  constructor (emit, store) {
+    this._emit = emit
+    this._store = store
   }
 
   /**
-   * 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()
-    const recPeerId = this.data.get(id)
-
-    // 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}`)
+    if (!publicKey) {
+      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)
     }
 
-    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 Book = require('./book')
-
-const {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
+const log = Object.assign(debug('libp2p:peer-store:metadata-book'), {
+  error: debug('libp2p:peer-store:metadata-book:err')
+})
 
 /**
- * @typedef {import('./')} PeerStore
+ * @typedef {import('./types').PeerStore} PeerStore
+ * @typedef {import('./types').MetadataBook} MetadataBook
  */
 
+const EVENT_NAME = 'change:metadata'
+
 /**
- * @extends {Book}
- *
- * @fires MetadataBook#change:metadata
+ * @implements {MetadataBook}
  */
-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} peerStore
+   * @param {PeerStore["emit"]} emit
+   * @param {import('./types').Store} store
    */
-  constructor (peerStore) {
-    /**
-     * PeerStore Event emitter, used by the MetadataBook to emit:
-     * "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()
+  constructor (emit, store) {
+    this._emit = emit
+    this._store = store
   }
 
   /**
-   * 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
-  set (peerId, key, value) {
+  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)
     }
 
-    if (typeof key !== 'string' || !(value instanceof Uint8Array)) {
-      log.error('valid key and value must be provided to store data')
-      throw errcode(new Error('valid key and value must be provided'), ERR_INVALID_PARAMETERS)
+    log('get await read lock')
+    const release = await this._store.lock.readLock()
+    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 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())
+    return new Map()
   }
 
   /**
@@ -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())
-    return rec && rec.get(key)
+    log('getValue await read lock')
+    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())) {
-      return false
+    if (typeof key !== 'string' || !(value instanceof Uint8Array)) {
+      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)) {
-      return false
+    let metadata
+
+    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)
-
-    return true
+    if (metadata) {
+      this._emit(EVENT_NAME, { peerId, metadata })
+    }
   }
 }
 
-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 {
-  codes: { ERR_INVALID_PARAMETERS }
-} = require('../errors')
+const EVENT_NAME = 'change:protocols'
 
 /**
- * @typedef {import('./')} PeerStore
+ * @implements {ProtoBook}
  */
-
-/**
- * @extends {Book}
- *
- * @fires ProtoBook#change:protocols
- */
-class ProtoBook extends Book {
+class PersistentProtoBook {
   /**
-   * The ProtoBook is responsible for keeping the known supported
-   * protocols of a peer.
-   *
-   * @class
-   * @param {PeerStore} peerStore
+   * @param {PeerStore["emit"]} emit
+   * @param {import('./types').Store} store
    */
-  constructor (peerStore) {
-    /**
-     * PeerStore Event emitter, used by the ProtoBook to emit:
-     * "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()
+  constructor (emit, store) {
+    this._emit = emit
+    this._store = store
   }
 
   /**
-   * 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) {
-    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)
+  async get (peerId) {
+    log('get wait for read lock')
+    const release = await this._store.lock.readLock()
+    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) {
-      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
+    return []
   }
 
   /**
-   * 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()
-    const recSet = this.data.get(id) || new Set()
-    const newSet = new Set([...recSet, ...protocols]) // Set Union
+    log('set await write lock')
+    const release = await this._store.lock.writeLock()
+    log('set got write lock')
 
-    // Any new protocol added?
-    if (recSet.size === newSet.size) {
-      log(`the protocols provided to store are already stored for ${id}`)
-      return this
-    }
+    let updatedPeer
 
-    this._setData(peerId, newSet)
-    log(`added provided protocols for ${id}`)
+    try {
+      try {
+        const peer = await this._store.load(peerId)
 
-    return this
-  }
-
-  /**
-   * Removes known protocols of a provided peer.
-   * If the protocols did not exist before, nothing will be done.
-   *
-   * @param {PeerId} peerId
-   * @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
+        if (new Set([
+          ...protocols
+        ]).size === peer.protocols.length) {
+          return
+        }
+      } catch (/** @type {any} */ err) {
+        if (err.code !== codes.ERR_NOT_FOUND) {
+          throw err
+        }
       }
 
-      this._setData(peerId, newSet)
-      log(`removed provided protocols for ${id}`)
+      updatedPeer = await this._store.patchOrCreate(peerId, {
+        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

@@ -22,58 +22,63 @@ const { PROTOCOL_NAME, PING_LENGTH, PROTOCOL_VERSION } = require('./constants')
  * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
  */
 
-/**
- * Ping a given peer and wait for its response, getting the operation latency.
- *
- * @param {Libp2p} node
- * @param {PeerId|Multiaddr} peer
- * @returns {Promise<number>}
- */
-async function ping (node, peer) {
-  const protocol = `/${node._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
-  // @ts-ignore multiaddr might not have toB58String
-  log('dialing %s to %s', protocol, peer.toB58String ? peer.toB58String() : peer)
-
-  const connection = await node.dial(peer)
-  const { stream } = await connection.newStream(protocol)
-
-  const start = Date.now()
-  const data = crypto.randomBytes(PING_LENGTH)
-
-  const [result] = await pipe(
-    [data],
-    stream,
-    (/** @type {MuxedStream} */ stream) => take(1, stream),
-    toBuffer,
-    collect
-  )
-  const end = Date.now()
-
-  if (!equals(data, result)) {
-    throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
+class PingService {
+  /**
+   * @param {import('../')} libp2p
+   */
+  static getProtocolStr (libp2p) {
+    return `/${libp2p._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
   }
 
-  return end - start
+  /**
+   * @param {Libp2p} libp2p
+   */
+  constructor (libp2p) {
+    this._libp2p = libp2p
+  }
+
+  /**
+   * A handler to register with Libp2p to process ping messages
+   *
+   * @param {Object} options
+   * @param {MuxedStream} options.stream
+   */
+  handleMessage ({ stream }) {
+    return pipe(stream, stream)
+  }
+
+  /**
+   * Ping a given peer and wait for its response, getting the operation latency.
+   *
+   * @param {PeerId|Multiaddr} peer
+   * @returns {Promise<number>}
+   */
+  async ping (peer) {
+    const protocol = `/${this._libp2p._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`
+    // @ts-ignore multiaddr might not have toB58String
+    log('dialing %s to %s', protocol, peer.toB58String ? peer.toB58String() : peer)
+
+    const connection = await this._libp2p.dial(peer)
+    const { stream } = await connection.newStream(protocol)
+
+    const start = Date.now()
+    const data = crypto.randomBytes(PING_LENGTH)
+
+    const [result] = await pipe(
+      [data],
+      stream,
+      (/** @type {MuxedStream} */ stream) => take(1, stream),
+      toBuffer,
+      collect
+    )
+    const end = Date.now()
+
+    if (!equals(data, result)) {
+      throw errCode(new Error('Received wrong ping ack'), codes.ERR_WRONG_PING_ACK)
+    }
+
+    return end - start
+  }
 }
 
-/**
- * Subscribe ping protocol handler.
- *
- * @param {Libp2p} node
- */
-function mount (node) {
-  node.handle(`/${node._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`, ({ stream }) => pipe(stream, stream))
-}
-
-/**
- * Unsubscribe ping protocol handler.
- *
- * @param {Libp2p} node
- */
-function unmount (node) {
-  node.unhandle(`/${node._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`)
-}
-
-exports = module.exports = ping
-exports.mount = mount
-exports.unmount = unmount
+module.exports = PingService

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)

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 listenMultiaddr = '/ip4/127.0.0.1/tcp/15002/ws'
+const { codes } = require('../../src/errors')
+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)
-      libp2p.peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
+      await libp2p.peerStore.addressBook.set(nodes[0].peerId, nodes[0].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)
-      libp2p.peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
+      await libp2p.peerStore.addressBook.set(nodes[0].peerId, nodes[0].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)
-      libp2p.peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
-      libp2p.peerStore.protoBook.set(nodes[1].peerId, ['/protocol-min-conns'])
+      await libp2p.peerStore.addressBook.set(nodes[0].peerId, nodes[0].multiaddrs)
+      await libp2p.peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
+      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
-      libp2p.connectionManager.onConnect(connection)
+      sinon.stub(connection, 'close').callsFake(async () => spy()) // eslint-disable-line
+      await libp2p.connectionManager.onConnect(connection)
     }))
 
     expect(libp2p.connectionManager._maybeDisconnectOne).to.have.property('callCount', 1)

test/content-routing/content-routing.node.js

@@ -291,11 +291,11 @@ describe('content-routing', () => {
         yield result
       })
 
-      expect(node.peerStore.addressBook.get(providerPeerId)).to.not.be.ok()
+      expect(await node.peerStore.has(providerPeerId)).to.not.be.ok()
 
       await drain(node.contentRouting.findProviders('a cid'))
 
-      expect(node.peerStore.addressBook.get(providerPeerId)).to.deep.include({
+      expect(await node.peerStore.addressBook.get(providerPeerId)).to.deep.include({
         isCertified: false,
         multiaddr: result.multiaddrs[0]
       })
@@ -377,7 +377,7 @@ describe('content-routing', () => {
 
       await drain(node.contentRouting.findProviders('a cid'))
 
-      expect(node.peerStore.addressBook.get(providerPeerId)).to.deep.include({
+      expect(await node.peerStore.addressBook.get(providerPeerId)).to.deep.include({
         isCertified: false,
         multiaddr: result1.multiaddrs[0]
       }).and.to.deep.include({

test/content-routing/dht/operation.node.js

@@ -45,8 +45,8 @@ describe('DHT subsystem operates correctly', () => {
         remoteLibp2p.start()
       ])
 
-      libp2p.peerStore.addressBook.set(remotePeerId, [remoteListenAddr])
-      remAddr = libp2p.peerStore.addressBook.getMultiaddrsForPeer(remotePeerId)[0]
+      await libp2p.peerStore.addressBook.set(remotePeerId, [remoteListenAddr]);
+      [remAddr] = await libp2p.peerStore.addressBook.getMultiaddrsForPeer(remotePeerId)
     })
 
     afterEach(() => Promise.all([
@@ -106,8 +106,8 @@ describe('DHT subsystem operates correctly', () => {
       await libp2p.start()
       await remoteLibp2p.start()
 
-      libp2p.peerStore.addressBook.set(remotePeerId, [remoteListenAddr])
-      remAddr = libp2p.peerStore.addressBook.getMultiaddrsForPeer(remotePeerId)[0]
+      await libp2p.peerStore.addressBook.set(remotePeerId, [remoteListenAddr])
+      remAddr = (await libp2p.peerStore.addressBook.getMultiaddrsForPeer(remotePeerId))[0]
     })
 
     afterEach(() => Promise.all([

test/core/ping.node.js

@@ -19,8 +19,8 @@ describe('ping', () => {
       config: baseOptions
     })
 
-    nodes[0].peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
-    nodes[1].peerStore.addressBook.set(nodes[0].peerId, nodes[0].multiaddrs)
+    await nodes[0].peerStore.addressBook.set(nodes[1].peerId, nodes[1].multiaddrs)
+    await nodes[1].peerStore.addressBook.set(nodes[0].peerId, nodes[0].multiaddrs)
   })
 
   afterEach(() => Promise.all(nodes.map(n => n.stop())))

test/dialing/dial-request.spec.js

@@ -5,7 +5,6 @@ const { expect } = require('aegir/utils/chai')
 const sinon = require('sinon')
 
 const { AbortError } = require('libp2p-interfaces/src/transport/errors')
-const AbortController = require('abort-controller')
 const AggregateError = require('aggregate-error')
 const pDefer = require('p-defer')
 const delay = require('delay')

test/dialing/direct.node.js

@@ -18,7 +18,7 @@ const AggregateError = require('aggregate-error')
 const { Connection } = require('libp2p-interfaces/src/connection')
 const { AbortError } = require('libp2p-interfaces/src/transport/errors')
 const { fromString: uint8ArrayFromString } = require('uint8arrays/from-string')
-
+const { MemoryDatastore } = require('datastore-core/memory')
 const Libp2p = require('../../src')
 const Dialer = require('../../src/dialer')
 const AddressManager = require('../../src/address-manager')
@@ -27,7 +27,7 @@ const TransportManager = require('../../src/transport-manager')
 const { codes: ErrorCodes } = require('../../src/errors')
 const Protector = require('../../src/pnet')
 const swarmKeyBuffer = uint8ArrayFromString(require('../fixtures/swarm.key'))
-
+const { mockConnectionGater } = require('../utils/mock-connection-gater')
 const mockUpgrader = require('../utils/mockUpgrader')
 const createMockConnection = require('../utils/mockConnection')
 const Peers = require('../fixtures/peers')
@@ -37,6 +37,7 @@ const listenAddr = new Multiaddr('/ip4/127.0.0.1/tcp/0')
 const unsupportedAddr = new Multiaddr('/ip4/127.0.0.1/tcp/9999/ws/p2p/QmckxVrJw1Yo8LqvmDJNUmdAsKtSbiKWmrXJFyKmUraBoN')
 
 describe('Dialing (direct, TCP)', () => {
+  const connectionGater = mockConnectionGater()
   let remoteTM
   let localTM
   let peerStore
@@ -48,7 +49,11 @@ describe('Dialing (direct, TCP)', () => {
       PeerId.createFromJSON(Peers[1])
     ])
 
-    peerStore = new PeerStore({ peerId: remotePeerId })
+    peerStore = new PeerStore({
+      peerId: remotePeerId,
+      datastore: new MemoryDatastore(),
+      addressFilter: connectionGater.filterMultiaddrForPeer
+    })
     remoteTM = new TransportManager({
       libp2p: {
         addressManager: new AddressManager(remotePeerId, { listen: [listenAddr] }),
@@ -62,7 +67,11 @@ describe('Dialing (direct, TCP)', () => {
     localTM = new TransportManager({
       libp2p: {
         peerId: localPeerId,
-        peerStore: new PeerStore({ peerId: localPeerId })
+        peerStore: new PeerStore({
+          peerId: localPeerId,
+          datastore: new MemoryDatastore(),
+          addressFilter: connectionGater.filterMultiaddrForPeer
+        })
       },
       upgrader: mockUpgrader
     })
@@ -80,7 +89,11 @@ describe('Dialing (direct, TCP)', () => {
   })
 
   it('should be able to connect to a remote node via its multiaddr', async () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({
+      transportManager: localTM,
+      peerStore,
+      connectionGater
+    })
 
     const connection = await dialer.connectToPeer(remoteAddr)
     expect(connection).to.exist()
@@ -88,14 +101,22 @@ describe('Dialing (direct, TCP)', () => {
   })
 
   it('should be able to connect to a remote node via its stringified multiaddr', async () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({
+      transportManager: localTM,
+      peerStore,
+      connectionGater
+    })
     const connection = await dialer.connectToPeer(remoteAddr.toString())
     expect(connection).to.exist()
     await connection.close()
   })
 
   it('should fail to connect to an unsupported multiaddr', async () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({
+      transportManager: localTM,
+      peerStore,
+      connectionGater
+    })
 
     await expect(dialer.connectToPeer(unsupportedAddr))
       .to.eventually.be.rejectedWith(Error)
@@ -103,7 +124,11 @@ describe('Dialing (direct, TCP)', () => {
   })
 
   it('should fail to connect if peer has no known addresses', async () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({
+      transportManager: localTM,
+      peerStore,
+      connectionGater
+    })
     const peerId = await PeerId.createFromJSON(Peers[1])
 
     await expect(dialer.connectToPeer(peerId))
@@ -113,13 +138,18 @@ describe('Dialing (direct, TCP)', () => {
 
   it('should be able to connect to a given peer id', async () => {
     const peerId = await PeerId.createFromJSON(Peers[0])
-    const peerStore = new PeerStore({ peerId })
+    const peerStore = new PeerStore({
+      peerId,
+      datastore: new MemoryDatastore(),
+      addressFilter: connectionGater.filterMultiaddrForPeer
+    })
     const dialer = new Dialer({
       transportManager: localTM,
-      peerStore
+      peerStore,
+      connectionGater
     })
 
-    peerStore.addressBook.set(peerId, remoteTM.getAddrs())
+    await peerStore.addressBook.set(peerId, remoteTM.getAddrs())
 
     const connection = await dialer.connectToPeer(peerId)
     expect(connection).to.exist()
@@ -134,7 +164,8 @@ describe('Dialing (direct, TCP)', () => {
           add: () => {},
           getMultiaddrsForPeer: () => [unsupportedAddr]
         }
-      }
+      },
+      connectionGater
     })
     const peerId = await PeerId.createFromJSON(Peers[0])
 
@@ -152,7 +183,8 @@ describe('Dialing (direct, TCP)', () => {
           add: () => { },
           getMultiaddrsForPeer: () => [...remoteAddrs, unsupportedAddr]
         }
-      }
+      },
+      connectionGater
     })
     const peerId = await PeerId.createFromJSON(Peers[0])
 
@@ -167,7 +199,8 @@ describe('Dialing (direct, TCP)', () => {
     const dialer = new Dialer({
       transportManager: localTM,
       peerStore,
-      dialTimeout: 50
+      dialTimeout: 50,
+      connectionGater
     })
     sinon.stub(localTM, 'dial').callsFake(async (addr, options) => {
       expect(options.signal).to.exist()
@@ -197,7 +230,8 @@ describe('Dialing (direct, TCP)', () => {
           add: () => {},
           getMultiaddrsForPeer: () => addrs
         }
-      }
+      },
+      connectionGater
     })
 
     expect(dialer.tokens).to.have.length(2)
@@ -249,7 +283,7 @@ describe('Dialing (direct, TCP)', () => {
           connEncryption: [Crypto]
         }
       })
-      remoteLibp2p.handle('/echo/1.0.0', ({ stream }) => pipe(stream, stream))
+      await remoteLibp2p.handle('/echo/1.0.0', ({ stream }) => pipe(stream, stream))
 
       await remoteLibp2p.start()
       remoteAddr = remoteLibp2p.transportManager.getAddrs()[0].encapsulate(`/p2p/${remotePeerId.toB58String()}`)
@@ -273,6 +307,8 @@ describe('Dialing (direct, TCP)', () => {
         }
       })
 
+      await libp2p.start()
+
       sinon.spy(libp2p.dialer, 'connectToPeer')
 
       try {
@@ -295,6 +331,8 @@ describe('Dialing (direct, TCP)', () => {
         }
       })
 
+      await libp2p.start()
+
       sinon.spy(libp2p.dialer, 'connectToPeer')
 
       const connection = await libp2p.dial(remoteAddr)
@@ -303,7 +341,7 @@ describe('Dialing (direct, TCP)', () => {
       expect(stream).to.exist()
       expect(protocol).to.equal('/echo/1.0.0')
       await connection.close()
-      expect(libp2p.dialer.connectToPeer.callCount).to.equal(1)
+      expect(libp2p.dialer.connectToPeer.callCount).to.be.greaterThan(0)
     })
 
     it('should use the dialer for connecting to a peer', async () => {
@@ -316,8 +354,10 @@ describe('Dialing (direct, TCP)', () => {
         }
       })
 
+      await libp2p.start()
+
       sinon.spy(libp2p.dialer, 'connectToPeer')
-      libp2p.peerStore.addressBook.set(remotePeerId, remoteLibp2p.multiaddrs)
+      await libp2p.peerStore.addressBook.set(remotePeerId, remoteLibp2p.multiaddrs)
 
       const connection = await libp2p.dial(remotePeerId)
       expect(connection).to.exist()
@@ -325,7 +365,7 @@ describe('Dialing (direct, TCP)', () => {
       expect(stream).to.exist()
       expect(protocol).to.equal('/echo/1.0.0')
       await connection.close()
-      expect(libp2p.dialer.connectToPeer.callCount).to.equal(1)
+      expect(libp2p.dialer.connectToPeer.callCount).to.be.greaterThan(0)
     })
 
     it('should close all streams when the connection closes', async () => {
@@ -338,13 +378,15 @@ describe('Dialing (direct, TCP)', () => {
         }
       })
 
-      // register some stream handlers to simulate several protocols
-      libp2p.handle('/stream-count/1', ({ stream }) => pipe(stream, stream))
-      libp2p.handle('/stream-count/2', ({ stream }) => pipe(stream, stream))
-      remoteLibp2p.handle('/stream-count/3', ({ stream }) => pipe(stream, stream))
-      remoteLibp2p.handle('/stream-count/4', ({ stream }) => pipe(stream, stream))
+      await libp2p.start()
 
-      libp2p.peerStore.addressBook.set(remotePeerId, remoteLibp2p.multiaddrs)
+      // register some stream handlers to simulate several protocols
+      await libp2p.handle('/stream-count/1', ({ stream }) => pipe(stream, stream))
+      await libp2p.handle('/stream-count/2', ({ stream }) => pipe(stream, stream))
+      await remoteLibp2p.handle('/stream-count/3', ({ stream }) => pipe(stream, stream))
+      await remoteLibp2p.handle('/stream-count/4', ({ stream }) => pipe(stream, stream))
+
+      await libp2p.peerStore.addressBook.set(remotePeerId, remoteLibp2p.multiaddrs)
       const connection = await libp2p.dial(remotePeerId)
 
       // Create local to remote streams
@@ -382,6 +424,8 @@ describe('Dialing (direct, TCP)', () => {
         }
       })
 
+      await libp2p.start()
+
       await expect(libp2p.dialProtocol(remotePeerId))
         .to.eventually.be.rejectedWith(Error)
         .and.to.have.property('code', ErrorCodes.ERR_INVALID_PROTOCOLS_FOR_STREAM)
@@ -401,6 +445,8 @@ describe('Dialing (direct, TCP)', () => {
         }
       })
 
+      await libp2p.start()
+
       const connection = await libp2p.dial(remoteAddr)
       expect(connection).to.exist()
       expect(connection.stat.timeline.close).to.not.exist()
@@ -418,6 +464,8 @@ describe('Dialing (direct, TCP)', () => {
         }
       })
 
+      await libp2p.start()
+
       const connection = await libp2p.dial(`${remoteAddr.toString()}`)
       expect(connection).to.exist()
       expect(connection.stat.timeline.close).to.not.exist()
@@ -440,6 +488,8 @@ describe('Dialing (direct, TCP)', () => {
       sinon.spy(libp2p.upgrader.protector, 'protect')
       sinon.stub(remoteLibp2p.upgrader, 'protector').value(new Protector(swarmKeyBuffer))
 
+      await libp2p.start()
+
       const connection = await libp2p.dialer.connectToPeer(remoteAddr)
       expect(connection).to.exist()
       const { stream, protocol } = await connection.newStream('/echo/1.0.0')
@@ -458,11 +508,13 @@ describe('Dialing (direct, TCP)', () => {
           connEncryption: [Crypto]
         }
       })
-      const dials = 10
 
+      await libp2p.start()
+
+      const dials = 10
       const fullAddress = remoteAddr.encapsulate(`/p2p/${remoteLibp2p.peerId.toB58String()}`)
 
-      libp2p.peerStore.addressBook.set(remotePeerId, remoteLibp2p.multiaddrs)
+      await libp2p.peerStore.addressBook.set(remotePeerId, remoteLibp2p.multiaddrs)
       const dialResults = await Promise.all([...new Array(dials)].map((_, index) => {
         if (index % 2 === 0) return libp2p.dial(remoteLibp2p.peerId)
         return libp2p.dial(fullAddress)
@@ -488,11 +540,14 @@ describe('Dialing (direct, TCP)', () => {
           connEncryption: [Crypto]
         }
       })
+
+      await libp2p.start()
+
       const dials = 10
       const error = new Error('Boom')
       sinon.stub(libp2p.transportManager, 'dial').callsFake(() => Promise.reject(error))
 
-      libp2p.peerStore.addressBook.set(remotePeerId, remoteLibp2p.multiaddrs)
+      await libp2p.peerStore.addressBook.set(remotePeerId, remoteLibp2p.multiaddrs)
       const dialResults = await pSettle([...new Array(dials)].map((_, index) => {
         if (index % 2 === 0) return libp2p.dial(remoteLibp2p.peerId)
         return libp2p.dial(remoteAddr)

test/dialing/direct.spec.js

@@ -13,7 +13,7 @@ const { NOISE: Crypto } = require('@chainsafe/libp2p-noise')
 const { Multiaddr } = require('multiaddr')
 const AggregateError = require('aggregate-error')
 const { AbortError } = require('libp2p-interfaces/src/transport/errors')
-
+const { MemoryDatastore } = require('datastore-core/memory')
 const { codes: ErrorCodes } = require('../../src/errors')
 const Constants = require('../../src/constants')
 const Dialer = require('../../src/dialer')
@@ -21,6 +21,7 @@ const addressSort = require('libp2p-utils/src/address-sort')
 const PeerStore = require('../../src/peer-store')
 const TransportManager = require('../../src/transport-manager')
 const Libp2p = require('../../src')
+const { mockConnectionGater } = require('../utils/mock-connection-gater')
 
 const { MULTIADDRS_WEBSOCKETS } = require('../fixtures/browser')
 const mockUpgrader = require('../utils/mockUpgrader')
@@ -30,13 +31,18 @@ const unsupportedAddr = new Multiaddr('/ip4/127.0.0.1/tcp/9999/ws/p2p/QmckxVrJw1
 const remoteAddr = MULTIADDRS_WEBSOCKETS[0]
 
 describe('Dialing (direct, WebSockets)', () => {
+  const connectionGater = mockConnectionGater()
   let localTM
   let peerStore
   let peerId
 
   before(async () => {
     [peerId] = await createPeerId()
-    peerStore = new PeerStore({ peerId })
+    peerStore = new PeerStore({
+      peerId,
+      datastore: new MemoryDatastore(),
+      addressFilter: connectionGater.filterMultiaddrForPeer
+    })
     localTM = new TransportManager({
       libp2p: {},
       upgrader: mockUpgrader,
@@ -45,19 +51,27 @@ describe('Dialing (direct, WebSockets)', () => {
     localTM.add(Transport.prototype[Symbol.toStringTag], Transport, { filter: filters.all })
   })
 
-  afterEach(() => {
-    peerStore.delete(peerId)
+  afterEach(async () => {
+    await peerStore.delete(peerId)
     sinon.restore()
   })
 
   it('should have appropriate defaults', () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({
+      transportManager: localTM,
+      peerStore,
+      connectionGater
+    })
     expect(dialer.maxParallelDials).to.equal(Constants.MAX_PARALLEL_DIALS)
     expect(dialer.timeout).to.equal(Constants.DIAL_TIMEOUT)
   })
 
   it('should limit the number of tokens it provides', () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({
+      transportManager: localTM,
+      peerStore,
+      connectionGater
+    })
     const maxPerPeer = Constants.MAX_PER_PEER_DIALS
     expect(dialer.tokens).to.have.length(Constants.MAX_PARALLEL_DIALS)
     const tokens = dialer.getTokens(maxPerPeer + 1)
@@ -66,14 +80,22 @@ describe('Dialing (direct, WebSockets)', () => {
   })
 
   it('should not return tokens if non are left', () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({
+      transportManager: localTM,
+      peerStore,
+      connectionGater
+    })
     sinon.stub(dialer, 'tokens').value([])
     const tokens = dialer.getTokens(1)
     expect(tokens.length).to.equal(0)
   })
 
   it('should NOT be able to return a token twice', () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({
+      transportManager: localTM,
+      peerStore,
+      connectionGater
+    })
     const tokens = dialer.getTokens(1)
     expect(tokens).to.have.length(1)
     expect(dialer.tokens).to.have.length(Constants.MAX_PARALLEL_DIALS - 1)
@@ -90,7 +112,8 @@ describe('Dialing (direct, WebSockets)', () => {
           add: () => {},
           getMultiaddrsForPeer: () => [remoteAddr]
         }
-      }
+      },
+      connectionGater
     })
 
     const connection = await dialer.connectToPeer(remoteAddr)
@@ -106,7 +129,8 @@ describe('Dialing (direct, WebSockets)', () => {
           add: () => {},
           getMultiaddrsForPeer: () => [remoteAddr]
         }
-      }
+      },
+      connectionGater
     })
 
     const connection = await dialer.connectToPeer(remoteAddr.toString())
@@ -115,7 +139,11 @@ describe('Dialing (direct, WebSockets)', () => {
   })
 
   it('should fail to connect to an unsupported multiaddr', async () => {
-    const dialer = new Dialer({ transportManager: localTM, peerStore })
+    const dialer = new Dialer({
+      transportManager: localTM,
+      peerStore,
+      connectionGater
+    })
 
     await expect(dialer.connectToPeer(unsupportedAddr))
       .to.eventually.be.rejectedWith(AggregateError)
@@ -129,7 +157,8 @@ describe('Dialing (direct, WebSockets)', () => {
           add: () => {},
           getMultiaddrsForPeer: () => [remoteAddr]
         }
-      }
+      },
+      connectionGater
     })
 
     const connection = await dialer.connectToPeer(peerId)
@@ -145,7 +174,8 @@ describe('Dialing (direct, WebSockets)', () => {
           set: () => {},
           getMultiaddrsForPeer: () => [unsupportedAddr]
         }
-      }
+      },
+      connectionGater
     })
 
     await expect(dialer.connectToPeer(peerId))
@@ -161,7 +191,8 @@ describe('Dialing (direct, WebSockets)', () => {
           add: () => {},
           getMultiaddrsForPeer: () => [remoteAddr]
         }
-      }
+      },
+      connectionGater
     })
     sinon.stub(localTM, 'dial').callsFake(async (addr, options) => {
       expect(options.signal).to.exist()
@@ -188,7 +219,8 @@ describe('Dialing (direct, WebSockets)', () => {
           add: () => { },
           getMultiaddrsForPeer: () => Array.from({ length: 11 }, (_, i) => new Multiaddr(`/ip4/127.0.0.1/tcp/1500${i}/ws/p2p/12D3KooWHFKTMzwerBtsVmtz4ZZEQy2heafxzWw6wNn5PPYkBxJ5`))
         }
-      }
+      },
+      connectionGater
     })
 
     await expect(dialer.connectToPeer(remoteAddr))
@@ -211,11 +243,12 @@ describe('Dialing (direct, WebSockets)', () => {
       transportManager: localTM,
       addressSorter: addressSort.publicAddressesFirst,
       maxParallelDials: 3,
-      peerStore
+      peerStore,
+      connectionGater
     })
 
     // Inject data in the AddressBook
-    peerStore.addressBook.add(peerId, peerMultiaddrs)
+    await peerStore.addressBook.add(peerId, peerMultiaddrs)
 
     // Perform 3 multiaddr dials
     await dialer.connectToPeer(peerId)
@@ -237,7 +270,8 @@ describe('Dialing (direct, WebSockets)', () => {
           set: () => {},
           getMultiaddrsForPeer: () => [remoteAddr, remoteAddr, remoteAddr]
         }
-      }
+      },
+      connectionGater
     })
 
     expect(dialer.tokens).to.have.length(2)
@@ -275,7 +309,8 @@ describe('Dialing (direct, WebSockets)', () => {
           set: () => {},
           getMultiaddrsForPeer: () => [remoteAddr, remoteAddr, remoteAddr]
         }
-      }
+      },
+      connectionGater
     })
 
     expect(dialer.tokens).to.have.length(2)
@@ -317,7 +352,8 @@ describe('Dialing (direct, WebSockets)', () => {
         addressBook: {
           set: () => { }
         }
-      }
+      },
+      connectionGater
     })
 
     sinon.stub(dialer, '_createDialTarget').callsFake(() => {
@@ -362,7 +398,8 @@ describe('Dialing (direct, WebSockets)', () => {
               filter: filters.all
             }
           }
-        }
+        },
+        connectionGater
       })
 
       expect(libp2p.dialer).to.exist()
@@ -422,14 +459,18 @@ describe('Dialing (direct, WebSockets)', () => {
       sinon.spy(libp2p.dialer, 'connectToPeer')
       sinon.spy(libp2p.peerStore.addressBook, 'add')
 
+      await libp2p.start()
+
       const connection = await libp2p.dial(remoteAddr)
       expect(connection).to.exist()
       const { stream, protocol } = await connection.newStream('/echo/1.0.0')
       expect(stream).to.exist()
       expect(protocol).to.equal('/echo/1.0.0')
       await connection.close()
-      expect(libp2p.dialer.connectToPeer.callCount).to.equal(1)
+      expect(libp2p.dialer.connectToPeer.callCount).to.be.at.least(1)
       expect(libp2p.peerStore.addressBook.add.callCount).to.be.at.least(1)
+
+      await libp2p.stop()
     })
 
     it('should run identify automatically after connecting', async () => {
@@ -452,6 +493,8 @@ describe('Dialing (direct, WebSockets)', () => {
       sinon.spy(libp2p.identifyService, 'identify')
       sinon.spy(libp2p.upgrader, 'onConnection')
 
+      await libp2p.start()
+
       const connection = await libp2p.dial(remoteAddr)
       expect(connection).to.exist()
 
@@ -464,6 +507,8 @@ describe('Dialing (direct, WebSockets)', () => {
       await libp2p.identifyService.identify.firstCall.returnValue
 
       expect(libp2p.peerStore.protoBook.set.callCount).to.equal(1)
+
+      await libp2p.stop()
     })
 
     it('should be able to use hangup to close connections', async () => {
@@ -483,11 +528,15 @@ describe('Dialing (direct, WebSockets)', () => {
         }
       })
 
+      await libp2p.start()
+
       const connection = await libp2p.dial(remoteAddr)
       expect(connection).to.exist()
       expect(connection.stat.timeline.close).to.not.exist()
       await libp2p.hangUp(connection.remotePeer)
       expect(connection.stat.timeline.close).to.exist()
+
+      await libp2p.stop()
     })
 
     it('should be able to use hangup when no connection exists', async () => {