libp2p 0.35.8 → 0.36.0

package/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>
+  }
+}

package/src/ping/index.js

@@ -63,6 +63,9 @@ async function ping (node, peer) {
  */
 function mount (node) {
   node.handle(`/${node._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`, ({ stream }) => pipe(stream, stream))
+    .catch(err => {
+      log.error(err)
+    })
 }
 
 /**
@@ -72,6 +75,9 @@ function mount (node) {
  */
 function unmount (node) {
   node.unhandle(`/${node._config.protocolPrefix}/${PROTOCOL_NAME}/${PROTOCOL_VERSION}`)
+    .catch(err => {
+      log.error(err)
+    })
 }
 
 exports = module.exports = ping

package/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
  */
 

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

package/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
   }

package/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>
+}

package/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)

package/dist/src/peer-store/book.d.ts

@@ -1,81 +0,0 @@
-export = Book;
-/**
- * @typedef {import('./')} PeerStore
- */
-declare 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 }: {
-        peerStore: PeerStore;
-        eventName: string;
-        eventProperty: string;
-        eventTransformer?: ((data: any) => any[]) | undefined;
-    });
-    _ps: import("./");
-    eventName: string;
-    eventProperty: string;
-    eventTransformer: (data: any) => any[];
-    /**
-     * Map known peers to their data.
-     *
-     * @type {Map<string, any[]|any>}
-     */
-    data: Map<string, any[] | any>;
-    /**
-     * Set known data of a provided peer.
-     *
-     * @param {PeerId} peerId
-     * @param {any[]|any} data
-     */
-    set(peerId: PeerId, data: any[] | any): void;
-    /**
-     * 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}
-     */
-    protected _setData(peerId: PeerId, data: any, { emit }?: {
-        emit?: boolean | undefined;
-    } | undefined): void;
-    /**
-     * Emit data.
-     *
-     * @protected
-     * @param {PeerId} peerId
-     * @param {any} [data]
-     */
-    protected _emit(peerId: PeerId, data?: any): void;
-    /**
-     * 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: PeerId): any[] | any | undefined;
-    /**
-     * Deletes the provided peer from the book.
-     *
-     * @param {PeerId} peerId
-     * @returns {boolean}
-     */
-    delete(peerId: PeerId): boolean;
-}
-declare namespace Book {
-    export { PeerStore };
-}
-import PeerId = require("peer-id");
-type PeerStore = import('./');
-//# sourceMappingURL=book.d.ts.map

package/dist/src/peer-store/book.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"book.d.ts","sourceRoot":"","sources":["../../../src/peer-store/book.js"],"names":[],"mappings":";AAWA;;GAEG;AAEH;IACE;;;;;;;;;OASG;IACH;QALiC,SAAS,EAA/B,SAAS;QACU,SAAS,EAA5B,MAAM;QACa,aAAa,EAAhC,MAAM;QAC4B,gBAAgB,WAA3C,GAAG,KAAK,GAAG,EAAE;OAc9B;IAXC,kBAAoB;IACpB,kBAA0B;IAC1B,sBAAkC;IAClC,yBANgB,GAAG,KAAK,GAAG,EAAE,CAMW;IAExC;;;;OAIG;IACH,MAFU,IAAI,MAAM,EAAE,GAAG,EAAE,GAAC,GAAG,CAAC,CAEX;IAGvB;;;;;OAKG;IACH,YAHW,MAAM,QACN,GAAG,EAAE,GAAC,GAAG,QAInB;IAED;;;;;;;;;OASG;IACH,2BANW,MAAM,QACN,GAAG;;oBAGD,IAAI,CAUhB;IAED;;;;;;OAMG;IACH,wBAHW,MAAM,SACN,GAAG,QAOb;IAED;;;;;;OAMG;IACH,YAHW,MAAM,GACJ,GAAG,EAAE,GAAC,GAAG,GAAC,SAAS,CAW/B;IAED;;;;;OAKG;IACH,eAHW,MAAM,GACJ,OAAO,CAcnB;CACF;;;;;iBA7GY,OAAO,IAAI,CAAC"}

package/dist/src/peer-store/persistent/consts.d.ts

@@ -1,6 +0,0 @@
-export var NAMESPACE_COMMON: string;
-export var NAMESPACE_ADDRESS: string;
-export var NAMESPACE_KEYS: string;
-export var NAMESPACE_METADATA: string;
-export var NAMESPACE_PROTOCOL: string;
-//# sourceMappingURL=consts.d.ts.map

package/dist/src/peer-store/persistent/consts.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"consts.d.ts","sourceRoot":"","sources":["../../../../src/peer-store/persistent/consts.js"],"names":[],"mappings":""}