libp2p 0.35.4 → 0.35.8-bf1fc32

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/upgrader.js

@@ -288,7 +288,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":""}

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

@@ -1,129 +0,0 @@
-export = PersistentPeerStore;
-/**
- * @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.
- */
-declare class PersistentPeerStore extends PeerStore {
-    /**
-     * @class
-     * @param {PersistentPeerStoreProperties & PersistentPeerStoreOptions} properties
-     */
-    constructor({ peerId, datastore, threshold }: PersistentPeerStoreProperties & PersistentPeerStoreOptions);
-    /**
-     * Backend datastore used to persist data.
-     */
-    _datastore: import("interface-datastore").Datastore;
-    /**
-     * Peers modified after the latest data persisted.
-     */
-    _dirtyPeers: Set<any>;
-    /**
-     * Peers metadata changed mapping peer identifers to metadata changed.
-     *
-     * @type {Map<string, Set<string>>}
-     */
-    _dirtyMetadata: Map<string, Set<string>>;
-    threshold: number;
-    /**
-     * Add modified peer to the dirty set
-     *
-     * @private
-     * @param {Object} params
-     * @param {PeerId} params.peerId
-     */
-    private _addDirtyPeer;
-    /**
-     * Add modified peer key to the dirty set
-     *
-     * @private
-     * @param {Object} params
-     * @param {PeerId} params.peerId
-     */
-    private _addDirtyPeerKey;
-    /**
-     * Add modified metadata peer to the set.
-     *
-     * @private
-     * @param {Object} params
-     * @param {PeerId} params.peerId
-     * @param {string} params.metadata
-     */
-    private _addDirtyPeerMetadata;
-    /**
-     * Add all the peers current data to a datastore batch and commit it.
-     *
-     * @private
-     * @returns {Promise<void>}
-     */
-    private _commitData;
-    /**
-     * Add address book data of the peer to the batch.
-     *
-     * @private
-     * @param {PeerId} peerId
-     * @param {Batch} batch
-     */
-    private _batchAddressBook;
-    /**
-     * Add Key book data of the peer to the batch.
-     *
-     * @private
-     * @param {PeerId} peerId
-     * @param {Batch} batch
-     */
-    private _batchKeyBook;
-    /**
-     * Add metadata book data of the peer to the batch.
-     *
-     * @private
-     * @param {PeerId} peerId
-     * @param {Batch} batch
-     */
-    private _batchMetadataBook;
-    /**
-     * Add proto book data of the peer to the batch.
-     *
-     * @private
-     * @param {PeerId} peerId
-     * @param {Batch} batch
-     */
-    private _batchProtoBook;
-    /**
-     * 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>}
-     */
-    private _processDatastoreEntry;
-}
-declare namespace PersistentPeerStore {
-    export { Batch, Address, PersistentPeerStoreProperties, PersistentPeerStoreOptions };
-}
-import PeerStore = require("..");
-type PersistentPeerStoreProperties = {
-    peerId: PeerId;
-    datastore: import('interface-datastore').Datastore;
-};
-type PersistentPeerStoreOptions = {
-    /**
-     * - Number of dirty peers allowed before commit data.
-     */
-    threshold?: number | undefined;
-};
-type Batch = import('interface-datastore').Batch;
-type Address = import('../address-book.js').Address;
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/peer-store/persistent/index.js"],"names":[],"mappings":";AAwBA;;;GAGG;AAEH;;;;;;;GAOG;AAEH;;GAEG;AACH;IACE;;;OAGG;IACH,8CAFW,6BAA6B,GAAG,0BAA0B,EAwBpE;IAnBC;;OAEG;IACH,oDAA2B;IAE3B;;OAEG;IACH,sBAA4B;IAE5B;;;;OAIG;IACH,gBAFU,IAAI,MAAM,EAAE,IAAI,MAAM,CAAC,CAAC,CAEH;IAE/B,kBAA0B;IAsC5B;;;;;;OAMG;IACH,sBAYC;IAED;;;;;;OAMG;IACH,yBAiBC;IAED;;;;;;;OAOG;IACH,8BAiBC;IAED;;;;;OAKG;IACH,oBA+BC;IAED;;;;;;OAMG;IACH,0BA8BC;IAED;;;;;;OAMG;IACH,sBAiBC;IAED;;;;;;OAMG;IACH,2BAkBC;IAED;;;;;;OAMG;IACH,wBAmBC;IAED;;;;;;;;OAQG;IACH,+BA0DC;CACF;;;;;;YAtXa,MAAM;eACN,OAAO,qBAAqB,EAAE,SAAS;;;;;;;;aAPxC,OAAO,qBAAqB,EAAE,KAAK;eACnC,OAAO,oBAAoB,EAAE,OAAO"}