libp2p 0.35.8 → 0.36.0-d44bd90

package/dist/src/metrics/index.d.ts

@@ -45,7 +45,7 @@ declare class Metrics {
      * @returns {void}
      */
     private _onMessage;
-    _componentMetrics: Map<any, any>;
+    _systems: Map<any, any>;
     /**
      * Must be called for stats to saved. Any data pushed for tracking
      * will be ignored.
@@ -69,10 +69,15 @@ declare class Metrics {
      */
     get peers(): string[];
     /**
-     * @returns {Map}
+     * @returns {Map<string, Map<string, Map<string, any>>>}
      */
-    getComponentMetrics(): Map<any, any>;
-    updateComponentMetric(component: any, metric: any, value: any): void;
+    getComponentMetrics(): Map<string, Map<string, Map<string, any>>>;
+    updateComponentMetric({ system, component, metric, value }: {
+        system?: string | undefined;
+        component: any;
+        metric: any;
+        value: any;
+    }): void;
     /**
      * Returns the `Stats` object for the given `PeerId` whether it
      * is a live peer, or in the disconnected peer LRU cache.

package/dist/src/metrics/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metrics/index.js"],"names":[],"mappings":";AAoBA;;;GAGG;AAEH;;;;;;GAMG;AAEH;IAqOE;;;;;;;OAOG;IACH,0BAJW,KAAK,SACL,KAAK,GACH,KAAK,CAWjB;IArPD;;;OAGG;IACH,qBAFW,cAAc,EAWxB;IARC,cAAqD;IACrD,oBAA6D;IAC7D,0BAA2B;IAC3B,8BAA+B;IAC/B,eAA+D;IAC/D,kBAAqB;IA8GvB;;;;;;;;;;;;OAYG;IACH,mBAwBC;IAjJC,iCAAkC;IAGpC;;;OAGG;IACH,cAEC;IAED;;;OAGG;IACH,aASC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;;OAIG;IACH,sBAEC;IAED;;OAEG;IACH,qCAEC;IAED,qEAOC;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,KAAK,CAKjB;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,KAAK,CAIjB;IAED;;;;;;OAMG;IACH,2BAFW,MAAM,QAUhB;IAyCD;;;;;;;;OAQG;IACH,+BAJW,MAAM,UACN,MAAM,GACJ,IAAI,CAoBhB;IAED;;;;;;;;;;;;OAYG;IACH;QALwC,MAAM,EAAnC,mBAAmB;QACF,UAAU;QACV,QAAQ;QACvB,mBAAmB,CA2B/B;CAoBF;;;;;cAnQY,OAAO,SAAS,CAAC;2BACjB,OAAO,uCAAuC,EAAE,mBAAmB"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metrics/index.js"],"names":[],"mappings":";AAoBA;;;GAGG;AAEH;;;;;;GAMG;AAEH;IA4OE;;;;;;;OAOG;IACH,0BAJW,KAAK,SACL,KAAK,GACH,KAAK,CAWjB;IA5PD;;;OAGG;IACH,qBAFW,cAAc,EAWxB;IARC,cAAqD;IACrD,oBAA6D;IAC7D,0BAA2B;IAC3B,8BAA+B;IAC/B,eAA+D;IAC/D,kBAAqB;IAqHvB;;;;;;;;;;;;OAYG;IACH,mBAwBC;IAxJC,wBAAyB;IAG3B;;;OAGG;IACH,cAEC;IAED;;;OAGG;IACH,aASC;IAED;;;;OAIG;IACH,oBAEC;IAED;;;;OAIG;IACH,sBAEC;IAED;;OAEG;IACH,uBAFa,IAAI,MAAM,EAAE,IAAI,MAAM,EAAE,IAAI,MAAM,EAAE,GAAG,CAAC,CAAC,CAAC,CAItD;IAED;;;;;aAcC;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,GACJ,KAAK,CAKjB;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,KAAK,CAIjB;IAED;;;;;;OAMG;IACH,2BAFW,MAAM,QAUhB;IAyCD;;;;;;;;OAQG;IACH,+BAJW,MAAM,UACN,MAAM,GACJ,IAAI,CAoBhB;IAED;;;;;;;;;;;;OAYG;IACH;QALwC,MAAM,EAAnC,mBAAmB;QACF,UAAU;QACV,QAAQ;QACvB,mBAAmB,CA2B/B;CAoBF;;;;;cA1QY,OAAO,SAAS,CAAC;2BACjB,OAAO,uCAAuC,EAAE,mBAAmB"}

package/dist/src/metrics/tracked-map.d.ts

@@ -1,3 +1,8 @@
-declare function _exports<K, V>(component: string, name: string, metrics?: import(".") | undefined): Map<K, V>;
+declare function _exports<K, V>({ system, component, metric, metrics }: {
+    system?: string | undefined;
+    component: string;
+    metric: string;
+    metrics?: import(".") | undefined;
+}): Map<K, V>;
 export = _exports;
 //# sourceMappingURL=tracked-map.d.ts.map

package/dist/src/metrics/tracked-map.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tracked-map.d.ts","sourceRoot":"","sources":["../../../src/metrics/tracked-map.js"],"names":[],"mappings":"AAwDiB,2CALN,MAAM,QACN,MAAM,gDAehB"}
+{"version":3,"file":"tracked-map.d.ts","sourceRoot":"","sources":["../../../src/metrics/tracked-map.js"],"names":[],"mappings":"AAkFiB;IANW,MAAM;IACP,SAAS,EAAzB,MAAM;IACU,MAAM,EAAtB,MAAM;IACgB,OAAO;cAcvC"}

package/dist/src/peer-routing.d.ts

@@ -21,7 +21,7 @@ declare class PeerRouting {
      */
     constructor(libp2p: import('./'));
     _peerId: import("peer-id");
-    _peerStore: import("./peer-store");
+    _peerStore: import("./peer-store/types").PeerStore;
     /** @type {PeerRoutingModule[]} */
     _routers: PeerRoutingModule[];
     _refreshManagerOptions: {

package/dist/src/peer-routing.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"peer-routing.d.ts","sourceRoot":"","sources":["../../src/peer-routing.js"],"names":[],"mappings":";AA6BA;;;;GAIG;AAEH;;;;;;;;;GASG;AAEH;IACE;;;OAGG;IACH,oBAFW,OAAO,IAAI,CAAC,EAgBtB;IAbC,2BAA4B;IAC5B,mCAAkC;IAClC,kCAAkC;IAClC,UADW,iBAAiB,EAAE,CACmB;IAOjD;;;;8BAAwE;IAkB1E;;OAEG;IACH,uCAOC;IAvBD;;OAEG;IACH,cAQC;IAHC,gBAEC;IAeH;;OAEG;IACH,aAEC;IAED;;;;;;;OAOG;IACH,aALW,MAAM;;oBAGJ,QAAQ;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,SAAS,EAAE,CAAA;KAAE,CAAC,CA+B5D;IAED;;;;;;;;OAQG;IACH,qBANW,UAAU;;;oBAIR,cAAc;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,SAAS,EAAE,CAAA;KAAE,CAAC,CAwBlE;CACF;;;;yBA1IY,OAAO,0CAA0C,EAAE,WAAW;;;;;;;;;;;;;;;;;;;cAF9D,OAAO,SAAS,CAAC;iBACjB,OAAO,WAAW,EAAE,SAAS"}
+{"version":3,"file":"peer-routing.d.ts","sourceRoot":"","sources":["../../src/peer-routing.js"],"names":[],"mappings":";AA6BA;;;;GAIG;AAEH;;;;;;;;;GASG;AAEH;IACE;;;OAGG;IACH,oBAFW,OAAO,IAAI,CAAC,EAgBtB;IAbC,2BAA4B;IAC5B,mDAAkC;IAClC,kCAAkC;IAClC,UADW,iBAAiB,EAAE,CACmB;IAOjD;;;;8BAAwE;IAkB1E;;OAEG;IACH,uCAOC;IAvBD;;OAEG;IACH,cAQC;IAHC,gBAEC;IAeH;;OAEG;IACH,aAEC;IAED;;;;;;;OAOG;IACH,aALW,MAAM;;oBAGJ,QAAQ;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,SAAS,EAAE,CAAA;KAAE,CAAC,CA+B5D;IAED;;;;;;;;OAQG;IACH,qBANW,UAAU;;;oBAIR,cAAc;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,SAAS,EAAE,CAAA;KAAE,CAAC,CA2BlE;CACF;;;;yBA7IY,OAAO,0CAA0C,EAAE,WAAW;;;;;;;;;;;;;;;;;;;cAF9D,OAAO,SAAS,CAAC;iBACjB,OAAO,WAAW,EAAE,SAAS"}

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

@@ -1,121 +1,67 @@
-export = AddressBook;
+export = PeerStoreAddressBook;
 /**
- * @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}
- */
-declare class AddressBook extends Book {
+declare class PeerStoreAddressBook implements AddressBook {
     /**
-     * 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);
+    constructor(emit: PeerStore["emit"], store: import('./types').Store, addressFilter: (peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>);
+    _emit: <U extends keyof import("./types").PeerStoreEvents>(event: U, ...args: Parameters<import("./types").PeerStoreEvents[U]>) => boolean;
+    _store: import("./types").Store;
+    _addressFilter: (peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>;
     /**
      * 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.
      *
      * @param {Envelope} envelope
-     * @returns {boolean}
      */
-    consumePeerRecord(envelope: Envelope): boolean;
+    consumePeerRecord(envelope: Envelope): Promise<boolean>;
     /**
-     * Get the raw Envelope for a peer. Returns
-     * undefined if no Envelope is found.
-     *
      * @param {PeerId} peerId
-     * @returns {Uint8Array|undefined}
      */
-    getRawEnvelope(peerId: PeerId): Uint8Array | undefined;
+    getRawEnvelope(peerId: PeerId): Promise<Uint8Array | undefined>;
     /**
      * Get an Envelope containing a PeerRecord for the given peer.
      * Returns undefined if no record exists.
      *
      * @param {PeerId} peerId
-     * @returns {Promise<Envelope|void>|undefined}
      */
-    getPeerRecord(peerId: PeerId): Promise<Envelope | void> | undefined;
+    getPeerRecord(peerId: PeerId): Promise<Envelope | undefined>;
+    /**
+     * @param {PeerId} peerId
+     */
+    get(peerId: PeerId): Promise<import("./types").Address[]>;
     /**
-     * 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: PeerId, multiaddrs: Multiaddr[]): AddressBook;
+    set(peerId: PeerId, multiaddrs: Multiaddr[]): Promise<void>;
     /**
-     * Transforms received multiaddrs into Address.
-     *
-     * @private
+     * @param {PeerId} peerId
      * @param {Multiaddr[]} multiaddrs
-     * @param {boolean} [isCertified]
-     * @returns {Address[]}
      */
-    private _toAddresses;
+    add(peerId: PeerId, multiaddrs: Multiaddr[]): Promise<void>;
+    /**
+     * @param {PeerId} peerId
+     */
+    delete(peerId: PeerId): Promise<void>;
     /**
-     * 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: PeerId, addressSorter?: ((addresses: Address[]) => Address[]) | undefined): Multiaddr[] | undefined;
+    getMultiaddrsForPeer(peerId: PeerId, addressSorter?: ((addresses: Address[]) => Address[]) | undefined): Promise<Multiaddr[]>;
 }
-declare namespace AddressBook {
-    export { PeerStore, Address, CertifiedRecord, Entry };
+declare namespace PeerStoreAddressBook {
+    export { PeerStore, Address, AddressBook };
 }
-import Book = require("./book");
+type AddressBook = import('./types').AddressBook;
 import Envelope = require("../record/envelope");
 import PeerId = require("peer-id");
 import { Multiaddr } from "multiaddr";
-type PeerStore = import('./');
-type Address = {
-    /**
-     * peer multiaddr.
-     */
-    multiaddr: Multiaddr;
-    /**
-     * obtained from a signed peer record.
-     */
-    isCertified: boolean;
-};
-type CertifiedRecord = {
-    /**
-     * raw envelope.
-     */
-    raw: Uint8Array;
-    /**
-     * seq counter.
-     */
-    seqNumber: number;
-};
-type Entry = {
-    /**
-     * peer Addresses.
-     */
-    addresses: Address[];
-    /**
-     * certified peer record.
-     */
-    record: CertifiedRecord;
-};
+type PeerStore = import('./types').PeerStore;
+type Address = import('./types').Address;
 //# sourceMappingURL=address-book.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"address-book.d.ts","sourceRoot":"","sources":["../../../src/peer-store/address-book.js"],"names":[],"mappings":";AAmBA;;GAEG;AAEH;;;;;;;;;;;;GAYG;AAEH;;GAEG;AACH;IACE;;;;;OAKG;IACH,uBAFW,SAAS,EA0BnB;IAED;;;;;;;OAOG;IACH,4BAHW,QAAQ,GACN,OAAO,CA8CnB;IAED;;;;;;OAMG;IACH,uBAHW,MAAM,GACJ,UAAU,GAAC,SAAS,CAUhC;IAED;;;;;;OAMG;IACH,sBAHW,MAAM,GACJ,QAAQ,QAAQ,GAAC,IAAI,CAAC,GAAC,SAAS,CAU5C;IAuDD;;;;;;;OAOG;IACH,YAJW,MAAM,cACN,SAAS,EAAE,GACT,WAAW,CA+CvB;IAmBD;;;;;;;OAOG;IACH,qBAyBC;IAED;;;;;;;;OAQG;IACH,6BAJW,MAAM,+BACM,OAAO,EAAE,KAAK,OAAO,EAAE,gBACjC,SAAS,EAAE,GAAC,SAAS,CAsBjC;CACF;;;;;;;;iBA3UY,OAAO,IAAI,CAAC;;;;;eAKX,SAAS;;;;iBACT,OAAO;;;;;;SAGP,UAAU;;;;eACV,MAAM;;;;;;eAGN,OAAO,EAAE;;;;YACT,eAAe"}
+{"version":3,"file":"address-book.d.ts","sourceRoot":"","sources":["../../../src/peer-store/address-book.js"],"names":[],"mappings":";AA2BA;;GAEG;AACH;IACE;;;;OAIG;IACH,kBAJW,SAAS,CAAC,MAAM,CAAC,SACjB,OAAO,SAAS,EAAE,KAAK,0BACd,MAAM,aAAa,SAAS,KAAK,QAAQ,OAAO,CAAC,EAMpE;IAHC,2IAAiB;IACjB,gCAAmB;IACnB,yBALkB,MAAM,aAAa,SAAS,KAAK,QAAQ,OAAO,CAAC,CAKhC;IAGrC;;;;;;OAMG;IACH,4BAFW,QAAQ,oBA+DlB;IAED;;OAEG;IACH,uBAFW,MAAM,mCAmBhB;IAED;;;;;OAKG;IACH,sBAFW,MAAM,iCAUhB;IAED;;OAEG;IACH,YAFW,MAAM,wCA0BhB;IAED;;;OAGG;IACH,YAHW,MAAM,cACN,SAAS,EAAE,iBA2DrB;IAED;;;OAGG;IACH,YAHW,MAAM,cACN,SAAS,EAAE,iBA0DrB;IAED;;OAEG;IACH,eAFW,MAAM,iBA4BhB;IAED;;;OAGG;IACH,6BAHW,MAAM,+BACM,OAAO,EAAE,KAAK,OAAO,EAAE,qCAe7C;CACF;;;;mBA/UY,OAAO,SAAS,EAAE,WAAW;;;;iBAF7B,OAAO,SAAS,EAAE,SAAS;eAC3B,OAAO,SAAS,EAAE,OAAO"}

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

@@ -1,124 +1,58 @@
-export = PeerStore;
+export = DefaultPeerStore;
 /**
- * @typedef {import('./address-book').Address} Address
- */
-/**
- * @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}
  */
-declare class PeerStore 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.
-     */
+declare class DefaultPeerStore extends EventEmitter implements PeerStore {
     /**
-     * Responsible for managing known peers, as well as their addresses, protocols and metadata.
-     *
-     * @param {object} options
-     * @param {PeerId} options.peerId
-     * @class
+     * @param {object} properties
+     * @param {PeerId} properties.peerId
+     * @param {import('interface-datastore').Datastore} properties.datastore
+     * @param {(peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>} properties.addressFilter
      */
-    constructor({ peerId }: {
+    constructor({ peerId, datastore, addressFilter }: {
         peerId: PeerId;
+        datastore: import('interface-datastore').Datastore;
+        addressFilter: (peerId: PeerId, multiaddr: Multiaddr) => Promise<boolean>;
     });
-    _peerId: PeerId;
-    /**
-     * AddressBook containing a map of peerIdStr to Address.
-     */
+    _peerId: import("peer-id");
+    _store: Store;
     addressBook: AddressBook;
-    /**
-     * KeyBook containing a map of peerIdStr to their PeerId with public keys.
-     */
     keyBook: KeyBook;
-    /**
-     * MetadataBook containing a map of peerIdStr to their metadata Map.
-     */
     metadataBook: MetadataBook;
-    /**
-     * ProtoBook containing a map of peerIdStr to supported protocols.
-     */
     protoBook: ProtoBook;
+    getPeers(): AsyncGenerator<import("./types").Peer, void, unknown>;
     /**
-     * Start the PeerStore.
-     */
-    start(): void;
-    /**
-     * Stop the PeerStore.
-     */
-    stop(): void;
-    /**
-     * Get all the stored information of every peer known.
+     * Delete the information of the given peer in every book
      *
-     * @returns {Map<string, Peer>}
+     * @param {PeerId} peerId
      */
-    get peers(): Map<string, {
-        /**
-         * 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> | undefined;
-    }>;
+    delete(peerId: PeerId): Promise<void>;
     /**
-     * Delete the information of the given peer in every book.
+     * Get the stored information of a given peer
      *
      * @param {PeerId} peerId
-     * @returns {boolean} true if found and removed
      */
-    delete(peerId: PeerId): boolean;
+    get(peerId: PeerId): Promise<import("./types").Peer>;
     /**
-     * Get the stored information of a given peer.
+     * Returns true if we have a record of the peer
      *
      * @param {PeerId} peerId
-     * @returns {Peer|undefined}
      */
-    get(peerId: PeerId): {
-        /**
-         * 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> | undefined;
-    } | undefined;
+    has(peerId: PeerId): Promise<boolean>;
 }
-declare namespace PeerStore {
-    export { Address };
+declare namespace DefaultPeerStore {
+    export { PeerStore, Peer, PeerId, Multiaddr };
 }
+type PeerStore = import('./types').PeerStore;
 import { EventEmitter } from "events";
-import PeerId = require("peer-id");
+import Store = require("./store");
 import AddressBook = require("./address-book");
 import KeyBook = require("./key-book");
 import MetadataBook = require("./metadata-book");
 import ProtoBook = require("./proto-book");
-type Address = import('./address-book').Address;
+type PeerId = import('peer-id');
+type Multiaddr = import('multiaddr').Multiaddr;
+type Peer = import('./types').Peer;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/peer-store/index.js"],"names":[],"mappings":";AAgBA;;GAEG;AAEH;;;;;;;;GAQG;AACH;IACE;;;;;;;;OAQG;IAEH;;;;;;OAMG;IACH;QAH2B,MAAM,EAAtB,MAAM;OA2BhB;IArBC,gBAAqB;IAErB;;OAEG;IACH,yBAAwC;IAExC;;OAEG;IACH,iBAAgC;IAEhC;;OAEG;IACH,2BAA0C;IAE1C;;OAEG;IACH,qBAAoC;IAGtC;;OAEG;IACH,cAAW;IAEX;;OAEG;IACH,aAAU;IAEV;;;;OAIG;IACH;;;;YAtDc,MAAM;;;;mBACN,OAAO,EAAE;;;;mBACT,MAAM,EAAE;;;;kBACR,IAAI,MAAM,EAAE,UAAU,CAAC,GAAC,SAAS;OAoE9C;IAED;;;;;OAKG;IACH,eAHW,MAAM,GACJ,OAAO,CASnB;IAED;;;;;OAKG;IACH,YAHW,MAAM;;;;YA3FH,MAAM;;;;mBACN,OAAO,EAAE;;;;mBACT,MAAM,EAAE;;;;kBACR,IAAI,MAAM,EAAE,UAAU,CAAC,GAAC,SAAS;kBA+G9C;CACF;;;;;;;;;;eApIY,OAAO,gBAAgB,EAAE,OAAO"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/peer-store/index.js"],"names":[],"mappings":";AAqBA;;;;GAIG;AACH;IACE;;;;;OAKG;IACH;gBAJW,MAAM;mBACN,OAAO,qBAAqB,EAAE,SAAS;gCAC9B,MAAM,aAAa,SAAS,KAAK,QAAQ,OAAO,CAAC;OAYpE;IAPC,2BAAqB;IACrB,cAAkC;IAElC,yBAAoF;IACpF,iBAA6D;IAC7D,2BAAuE;IACvE,qBAAiE;IAGnE,kEAkBC;IAED;;;;OAIG;IACH,eAFW,MAAM,iBAahB;IAED;;;;OAIG;IACH,YAFW,MAAM,mCAahB;IAED;;;;OAIG;IACH,YAFW,MAAM,oBAahB;CACF;;;;iBA3GY,OAAO,SAAS,EAAE,SAAS;;;;;;;cAE3B,OAAO,SAAS,CAAC;iBACjB,OAAO,WAAW,EAAE,SAAS;YAF7B,OAAO,SAAS,EAAE,IAAI"}

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

@@ -1,24 +1,40 @@
-export = KeyBook;
+export = PeerStoreKeyBook;
 /**
- * @typedef {import('./')} PeerStore
- * @typedef {import('libp2p-crypto').PublicKey} PublicKey
+ * @implements {KeyBook}
  */
-/**
- * @extends {Book}
- */
-declare class KeyBook extends Book {
+declare class PeerStoreKeyBook implements KeyBook {
     /**
      * 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(emit: PeerStore["emit"], store: import('./types').Store);
+    _emit: <U extends keyof import("./types").PeerStoreEvents>(event: U, ...args: Parameters<import("./types").PeerStoreEvents[U]>) => boolean;
+    _store: import("./types").Store;
+    /**
+     * Set the Peer public key
+     *
+     * @param {PeerId} peerId
+     * @param {PublicKey} publicKey
+     */
+    set(peerId: PeerId, publicKey: PublicKey): Promise<void>;
+    /**
+     * Get Public key of the given PeerId, if stored
+     *
+     * @param {PeerId} peerId
+     */
+    get(peerId: PeerId): Promise<import("libp2p-interfaces/src/keys/types").PublicKey | undefined>;
+    /**
+     * @param {PeerId} peerId
      */
-    constructor(peerStore: PeerStore);
+    delete(peerId: PeerId): Promise<void>;
 }
-declare namespace KeyBook {
-    export { PeerStore, PublicKey };
+declare namespace PeerStoreKeyBook {
+    export { PeerStore, KeyBook, PublicKey };
 }
-import Book = require("./book");
-type PeerStore = import('./');
-type PublicKey = import('libp2p-crypto').PublicKey;
+type KeyBook = import('./types').KeyBook;
+import PeerId = require("peer-id");
+type PublicKey = import('libp2p-interfaces/src/keys/types').PublicKey;
+type PeerStore = import('./types').PeerStore;
 //# sourceMappingURL=key-book.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"key-book.d.ts","sourceRoot":"","sources":["../../../src/peer-store/key-book.js"],"names":[],"mappings":";AAgBA;;;GAGG;AAEH;;GAEG;AACH;IACE;;;;;OAKG;IACH,uBAFW,SAAS,EAgBnB;CAgDF;;;;;iBA5EY,OAAO,IAAI,CAAC;iBACZ,OAAO,eAAe,EAAE,SAAS"}
+{"version":3,"file":"key-book.d.ts","sourceRoot":"","sources":["../../../src/peer-store/key-book.js"],"names":[],"mappings":";AAoBA;;GAEG;AACH;IACE;;;;;OAKG;IACH,kBAHW,SAAS,CAAC,MAAM,CAAC,SACjB,OAAO,SAAS,EAAE,KAAK,EAKjC;IAFC,2IAAiB;IACjB,gCAAmB;IAGrB;;;;;OAKG;IACH,YAHW,MAAM,aACN,SAAS,iBA4CnB;IAED;;;;OAIG;IACH,YAFW,MAAM,6EAwBhB;IAED;;OAEG;IACH,eAFW,MAAM,iBAsBhB;CACF;;;;eAhIY,OAAO,SAAS,EAAE,OAAO;;iBACzB,OAAO,kCAAkC,EAAE,SAAS;iBAFpD,OAAO,SAAS,EAAE,SAAS"}

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

@@ -1,54 +1,58 @@
-export = MetadataBook;
+export = PeerStoreMetadataBook;
 /**
- * @typedef {import('./')} PeerStore
+ * @implements {MetadataBook}
  */
-/**
- * @extends {Book}
- *
- * @fires MetadataBook#change:metadata
- */
-declare class MetadataBook extends Book {
+declare class PeerStoreMetadataBook implements MetadataBook {
     /**
      * 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);
+    constructor(emit: PeerStore["emit"], store: import('./types').Store);
+    _emit: <U extends keyof import("./types").PeerStoreEvents>(event: U, ...args: Parameters<import("./types").PeerStoreEvents[U]>) => boolean;
+    _store: import("./types").Store;
     /**
-     * Set data into the datastructure
+     * Get the known data of a provided peer
      *
      * @param {PeerId} peerId
-     * @param {string} key
-     * @param {Uint8Array} value
-     * @param {object} [opts]
-     * @param {boolean} [opts.emit]
      */
-    _setValue(peerId: PeerId, key: string, value: Uint8Array, { emit }?: {
-        emit?: boolean | undefined;
-    } | undefined): void;
+    get(peerId: PeerId): Promise<Map<any, any>>;
     /**
      * Get specific metadata value, if it exists
      *
      * @param {PeerId} peerId
      * @param {string} key
-     * @returns {Uint8Array | undefined}
      */
-    getValue(peerId: PeerId, key: string): Uint8Array | undefined;
+    getValue(peerId: PeerId, key: string): Promise<Uint8Array | undefined>;
+    /**
+     * @param {PeerId} peerId
+     * @param {Map<string, Uint8Array>} metadata
+     */
+    set(peerId: PeerId, metadata: Map<string, Uint8Array>): Promise<void>;
     /**
-     * Deletes the provided peer metadata key from the book.
+     * Set metadata key and value of a provided peer
      *
+     * @param {PeerId} peerId
+     * @param {string} key - metadata key
+     * @param {Uint8Array} value - metadata value
+     */
+    setValue(peerId: PeerId, key: string, value: Uint8Array): Promise<void>;
+    /**
+     * @param {PeerId} peerId
+     */
+    delete(peerId: PeerId): Promise<void>;
+    /**
      * @param {PeerId} peerId
      * @param {string} key
-     * @returns {boolean}
      */
-    deleteValue(peerId: PeerId, key: string): boolean;
+    deleteValue(peerId: PeerId, key: string): Promise<void>;
 }
-declare namespace MetadataBook {
-    export { PeerStore };
+declare namespace PeerStoreMetadataBook {
+    export { PeerStore, MetadataBook };
 }
-import Book = require("./book");
+type MetadataBook = import('./types').MetadataBook;
 import PeerId = require("peer-id");
-type PeerStore = import('./');
+type PeerStore = import('./types').PeerStore;
 //# sourceMappingURL=metadata-book.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"metadata-book.d.ts","sourceRoot":"","sources":["../../../src/peer-store/metadata-book.js"],"names":[],"mappings":";AAiBA;;GAEG;AAEH;;;;GAIG;AACH;IACE;;;;;;OAMG;IACH,uBAFW,SAAS,EAmBnB;IA4BD;;;;;;;;OAQG;IACH,kBANW,MAAM,OACN,MAAM,SACN,UAAU;;yBAmBpB;IAgBD;;;;;;OAMG;IACH,iBAJW,MAAM,OACN,MAAM,GACJ,UAAU,GAAG,SAAS,CASlC;IAsBD;;;;;;OAMG;IACH,oBAJW,MAAM,OACN,MAAM,GACJ,OAAO,CAgBnB;CACF;;;;;;iBA/JY,OAAO,IAAI,CAAC"}
+{"version":3,"file":"metadata-book.d.ts","sourceRoot":"","sources":["../../../src/peer-store/metadata-book.js"],"names":[],"mappings":";AAmBA;;GAEG;AACH;IACE;;;;;;OAMG;IACH,kBAHW,SAAS,CAAC,MAAM,CAAC,SACjB,OAAO,SAAS,EAAE,KAAK,EAKjC;IAFC,2IAAiB;IACjB,gCAAmB;IAGrB;;;;OAIG;IACH,YAFW,MAAM,0BA0BhB;IAED;;;;;OAKG;IACH,iBAHW,MAAM,OACN,MAAM,mCAwBhB;IAED;;;OAGG;IACH,YAHW,MAAM,YACN,IAAI,MAAM,EAAE,UAAU,CAAC,iBA2BjC;IAED;;;;;;OAMG;IACH,iBAJW,MAAM,OACN,MAAM,SACN,UAAU,iBA0CpB;IAED;;OAEG;IACH,eAFW,MAAM,iBA8BhB;IAED;;;OAGG;IACH,oBAHW,MAAM,OACN,MAAM,iBAmChB;CACF;;;;oBAzOY,OAAO,SAAS,EAAE,YAAY;;iBAD9B,OAAO,SAAS,EAAE,SAAS"}