libp2p 0.35.8 → 0.36.0

package/dist/src/index.d.ts

@@ -12,6 +12,7 @@ export = Libp2p;
  * @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]
  */
@@ -69,13 +70,14 @@ export = Libp2p;
  * @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]
  *
@@ -115,6 +117,7 @@ declare class Libp2p extends EventEmitter {
         connectionManager: {
             minConnections: number;
         };
+        connectionGater: {};
         transportManager: {
             faultTolerance: number;
         };
@@ -134,6 +137,98 @@ declare class Libp2p extends EventEmitter {
             enabled: boolean;
         };
         peerStore: {
+            /**
+             * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
+             * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
+             * @typedef {import('libp2p-interfaces/src/transport/types').TransportFactory<any, any>} TransportFactory
+             * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxerFactory} MuxerFactory
+             * @typedef {import('libp2p-interfaces/src/content-routing/types').ContentRouting} ContentRoutingModule
+             * @typedef {import('libp2p-interfaces/src/peer-discovery/types').PeerDiscoveryFactory} PeerDiscoveryFactory
+             * @typedef {import('libp2p-interfaces/src/peer-routing/types').PeerRouting} PeerRoutingModule
+             * @typedef {import('libp2p-interfaces/src/crypto/types').Crypto} Crypto
+             * @typedef {import('libp2p-interfaces/src/pubsub')} Pubsub
+             * @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]
+             */
+            /**
+             * @typedef {Object} HandlerProps
+             * @property {Connection} connection
+             * @property {MuxedStream} stream
+             * @property {string} protocol
+             *
+             * @typedef {Object} DhtOptions
+             * @property {boolean} [enabled = false]
+             * @property {number} [kBucketSize = 20]
+             * @property {boolean} [clientMode]
+             * @property {import('libp2p-interfaces/src/types').DhtSelectors} [selectors]
+             * @property {import('libp2p-interfaces/src/types').DhtValidators} [validators]
+             *
+             * @typedef {Object} KeychainOptions
+             * @property {Datastore} [datastore]
+             *
+             * @typedef {Object} PeerStoreOptions
+             * @property {boolean} persistence
+             *
+             * @typedef {Object} PubsubLocalOptions
+             * @property {boolean} enabled
+             *
+             * @typedef {Object} MetricsOptions
+             * @property {boolean} enabled
+             *
+             * @typedef {Object} RelayOptions
+             * @property {boolean} [enabled = true]
+             * @property {import('./circuit').RelayAdvertiseOptions} [advertise]
+             * @property {import('./circuit').HopOptions} [hop]
+             * @property {import('./circuit').AutoRelayOptions} [autoRelay]
+             *
+             * @typedef {Object} Libp2pConfig
+             * @property {DhtOptions} [dht] dht module options
+             * @property {import('./nat-manager').NatManagerOptions} [nat]
+             * @property {Record<string, Object|boolean>} [peerDiscovery]
+             * @property {PubsubLocalOptions & PubsubOptions} [pubsub] pubsub module options
+             * @property {RelayOptions} [relay]
+             * @property {Record<string, Object>} [transport] transport options indexed by transport key
+             *
+             * @typedef {Object} Libp2pModules
+             * @property {TransportFactory[]} transport
+             * @property {MuxerFactory[]} streamMuxer
+             * @property {Crypto[]} connEncryption
+             * @property {PeerDiscoveryFactory[]} [peerDiscovery]
+             * @property {PeerRoutingModule[]} [peerRouting]
+             * @property {ContentRoutingModule[]} [contentRouting]
+             * @property {Object} [dht]
+             * @property {{new(...args: any[]): Pubsub}} [pubsub]
+             * @property {Protector} [connProtector]
+             *
+             * @typedef {Object} Libp2pOptions
+             * @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} [peerStore]
+             * @property {import('./transport-manager').TransportManagerOptions} [transportManager]
+             * @property {Libp2pConfig} [config]
+             *
+             * @typedef {Object} constructorOptions
+             * @property {PeerId} peerId
+             *
+             * @typedef {Object} CreateOptions
+             * @property {PeerId} [peerId]
+             *
+             * @extends {EventEmitter}
+             * @fires Libp2p#error Emitted when an error occurs
+             * @fires Libp2p#peer:discovery Emitted when a peer is discovered
+             */
             persistence: boolean;
             threshold: number;
         };
@@ -189,7 +284,10 @@ declare class Libp2p extends EventEmitter {
     peerId: PeerId;
     datastore: import("interface-datastore").Datastore | undefined;
     metrics: Metrics | undefined;
-    peerStore: PeerStore;
+    /** @type {ConnectionGater} */
+    connectionGater: ConnectionGater;
+    /** @type {import('./peer-store/types').PeerStore} */
+    peerStore: import('./peer-store/types').PeerStore;
     addresses: {
         listen: never[];
         announce: never[];
@@ -253,7 +351,7 @@ declare class Libp2p extends EventEmitter {
      * @param {string[]|string} protocols
      * @param {(props: HandlerProps) => void} handler
      */
-    handle(protocols: string[] | string, handler: (props: HandlerProps) => void): void;
+    handle(protocols: string[] | string, handler: (props: HandlerProps) => void): Promise<void>;
     dialer: Dialer;
     relay: Relay | undefined;
     identifyService: IdentifyService | undefined;
@@ -270,6 +368,7 @@ declare class Libp2p extends EventEmitter {
      * @param {{ id: PeerId, multiaddrs: Multiaddr[], protocols: string[] }} peer
      */
     private _onDiscoveryPeer;
+    fetchService: FetchService;
     /**
      * Starts the libp2p node and all its subsystems
      *
@@ -354,6 +453,14 @@ declare class Libp2p extends EventEmitter {
      * @returns {Promise<void>}
      */
     hangUp(peer: PeerId | Multiaddr | string): Promise<void>;
+    /**
+     * 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: PeerId | Multiaddr, key: string): Promise<Uint8Array | null>;
     /**
      * Pings the given peer in order to obtain the operation latency.
      *
@@ -367,7 +474,7 @@ declare class Libp2p extends EventEmitter {
      *
      * @param {string[]|string} protocols
      */
-    unhandle(protocols: string[] | string): void;
+    unhandle(protocols: string[] | string): Promise<void>;
     _onStarting(): Promise<void>;
     /**
      * Called when libp2p has started and before it returns
@@ -393,7 +500,7 @@ declare class Libp2p extends EventEmitter {
     private _setupPeerDiscovery;
 }
 declare namespace Libp2p {
-    export { Connection, MuxedStream, TransportFactory, MuxerFactory, ContentRoutingModule, PeerDiscoveryFactory, PeerRoutingModule, Crypto, Pubsub, PubsubOptions, Datastore, Protector, PersistentPeerStoreOptions, HandlerProps, DhtOptions, KeychainOptions, PeerStoreOptions, PubsubLocalOptions, MetricsOptions, RelayOptions, Libp2pConfig, Libp2pModules, Libp2pOptions, constructorOptions, CreateOptions };
+    export { Connection, MuxedStream, TransportFactory, MuxerFactory, ContentRoutingModule, PeerDiscoveryFactory, PeerRoutingModule, Crypto, Pubsub, PubsubOptions, Datastore, Protector, ConnectionGater, PersistentPeerStoreOptions, HandlerProps, DhtOptions, KeychainOptions, PeerStoreOptions, PubsubLocalOptions, MetricsOptions, RelayOptions, Libp2pConfig, Libp2pModules, Libp2pOptions, constructorOptions, CreateOptions };
 }
 import { EventEmitter } from "events";
 type Libp2pOptions = {
@@ -403,6 +510,7 @@ type Libp2pOptions = {
     modules: Libp2pModules;
     addresses?: AddressManager.AddressManagerOptions | undefined;
     connectionManager?: ConnectionManager.ConnectionManagerOptions | undefined;
+    connectionGater?: Partial<import("./types").ConnectionGater> | undefined;
     datastore?: import("interface-datastore").Datastore | undefined;
     dialer?: Dialer.DialerOptions | undefined;
     /**
@@ -412,7 +520,7 @@ type Libp2pOptions = {
     keychain?: (KeychainOptions & Keychain.KeychainOptions) | undefined;
     metrics?: (MetricsOptions & Metrics.MetricsOptions) | undefined;
     peerRouting?: PeerRouting.PeerRoutingOptions | undefined;
-    peerStore?: (PeerStoreOptions & PersistentPeerStoreOptions) | undefined;
+    peerStore?: PeerStoreOptions | undefined;
     transportManager?: TransportManager.TransportManagerOptions | undefined;
     config?: Libp2pConfig | undefined;
 };
@@ -421,7 +529,7 @@ type constructorOptions = {
 };
 import PeerId = require("peer-id");
 import Metrics = require("./metrics");
-import PeerStore = require("./peer-store");
+type ConnectionGater = import('./types').ConnectionGater;
 import AddressManager = require("./address-manager");
 type Libp2pModules = {
     transport: import("libp2p-interfaces/src/transport/types").TransportFactory<any, any>[];
@@ -468,6 +576,7 @@ import Relay = require("./circuit");
 import IdentifyService = require("./identify");
 import PeerRouting = require("./peer-routing");
 import ContentRouting = require("./content-routing");
+import FetchService = require("./fetch");
 import { Multiaddr } from "multiaddr";
 type Connection = import("libp2p-interfaces/src/connection/connection");
 type CreateOptions = {

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":"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"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":"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"}

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