libp2p 0.35.8 → 0.36.0

package/dist/src/circuit/auto-relay.d.ts

@@ -1,7 +1,8 @@
 export = AutoRelay;
 /**
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
- * @typedef {import('../peer-store/address-book').Address} Address
+ * @typedef {import('../peer-store/types').Address} Address
+ * @typedef {import('peer-id')} PeerId
  */
 /**
  * @typedef {Object} AutoRelayProperties
@@ -20,11 +21,11 @@ declare class AutoRelay {
      */
     constructor({ libp2p, maxListeners, onError }: AutoRelayProperties & AutoRelayOptions);
     _libp2p: import("../");
-    _peerId: PeerId;
-    _peerStore: import("../peer-store");
+    _peerId: import("peer-id");
+    _peerStore: import("../peer-store/types").PeerStore;
     _connectionManager: import("../connection-manager");
     _transportManager: import("../transport-manager");
-    _addressSorter: (addresses: import("../peer-store/address-book").Address[]) => import("../peer-store/address-book").Address[];
+    _addressSorter: (addresses: import("../peer-store/types").Address[]) => import("../peer-store/types").Address[];
     maxListeners: number;
     /**
      * @type {Set<string>}
@@ -49,7 +50,6 @@ declare class AutoRelay {
      * Peer disconnects.
      *
      * @param {Connection} connection - connection to the peer
-     * @returns {void}
      */
     _onPeerDisconnected(connection: Connection): void;
     /**
@@ -71,7 +71,6 @@ declare class AutoRelay {
      *
      * @private
      * @param {string} id - peer identifier string.
-     * @returns {void}
      */
     private _removeListenRelay;
     /**
@@ -82,7 +81,6 @@ declare class AutoRelay {
      * 3. Search the network.
      *
      * @param {string[]} [peersToIgnore]
-     * @returns {Promise<void>}
      */
     _listenOnAvailableHopRelays(peersToIgnore?: string[] | undefined): Promise<void>;
     /**
@@ -91,9 +89,9 @@ declare class AutoRelay {
     _tryToListenOnRelay(peerId: PeerId): Promise<void>;
 }
 declare namespace AutoRelay {
-    export { Connection, Address, AutoRelayProperties, AutoRelayOptions };
+    export { Connection, Address, PeerId, AutoRelayProperties, AutoRelayOptions };
 }
-import PeerId = require("peer-id");
+type PeerId = import('peer-id');
 type Connection = import("libp2p-interfaces/src/connection/connection");
 type AutoRelayProperties = {
     libp2p: import('../');
@@ -105,5 +103,5 @@ type AutoRelayOptions = {
     maxListeners?: number | undefined;
     onError?: ((error: Error, msg?: string | undefined) => {}) | undefined;
 };
-type Address = import('../peer-store/address-book').Address;
+type Address = import('../peer-store/types').Address;
 //# sourceMappingURL=auto-relay.d.ts.map

package/dist/src/circuit/auto-relay.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auto-relay.d.ts","sourceRoot":"","sources":["../../../src/circuit/auto-relay.js"],"names":[],"mappings":";AAsBA;;;GAGG;AAEH;;;;;;;GAOG;AAEH;IACE;;;;;OAKG;IACH,+CAFW,mBAAmB,GAAG,gBAAgB,EA+BhD;IA5BC,uBAAqB;IACrB,gBAA4B;IAC5B,oCAAkC;IAClC,oDAAkD;IAClD,kDAAgD;IAChD,8HAAiD;IAEjD,qBAAgC;IAEhC;;OAEG;IACH,eAFU,IAAI,MAAM,CAAC,CAES;IAkBhC;;;;;;;;;;OAUG;IACH;QAJyB,MAAM,EAApB,MAAM;QACU,SAAS,EAAzB,MAAM,EAAE;QACN,QAAQ,IAAI,CAAC,CAsCzB;IAED;;;;;OAKG;IACH,gCAHW,UAAU,GACR,IAAI,CAYhB;IA3EC;;;OAGG;IACH,kBAHW,KAAK,oCAMf;IAsEH;;;;;;;OAOG;IACH,wBA0BC;IAED;;;;;;OAMG;IACH,2BAKC;IAED;;;;;;;;;OASG;IACH,mEAFa,QAAQ,IAAI,CAAC,CAyEzB;IAED;;OAEG;IACH,4BAFW,MAAM,iBAShB;CACF;;;;;;;YAhQa,OAAO,KAAK,CAAC;;;;;;;uBAIL,KAAK,+BAAmB,EAAE;;eATnC,OAAO,4BAA4B,EAAE,OAAO"}
+{"version":3,"file":"auto-relay.d.ts","sourceRoot":"","sources":["../../../src/circuit/auto-relay.js"],"names":[],"mappings":";AAsBA;;;;GAIG;AAEH;;;;;;;GAOG;AAEH;IACE;;;;;OAKG;IACH,+CAFW,mBAAmB,GAAG,gBAAgB,EA+BhD;IA5BC,uBAAqB;IACrB,2BAA4B;IAC5B,oDAAkC;IAClC,oDAAkD;IAClD,kDAAgD;IAChD,gHAAiD;IAEjD,qBAAgC;IAEhC;;OAEG;IACH,eAFU,IAAI,MAAM,CAAC,CAES;IAkBhC;;;;;;;;;;OAUG;IACH;QAJyB,MAAM,EAApB,MAAM;QACU,SAAS,EAAzB,MAAM,EAAE;QACN,QAAQ,IAAI,CAAC,CAsCzB;IAED;;;;OAIG;IACH,gCAFW,UAAU,QAcpB;IA5EC;;;OAGG;IACH,kBAHW,KAAK,oCAMf;IAuEH;;;;;;;OAOG;IACH,wBAkCC;IAED;;;;;OAKG;IACH,2BAKC;IAED;;;;;;;;OAQG;IACH,iFA6EC;IAED;;OAEG;IACH,4BAFW,MAAM,iBAShB;CACF;;;;cAlRY,OAAO,SAAS,CAAC;;;YAKhB,OAAO,KAAK,CAAC;;;;;;;uBAIL,KAAK,+BAAmB,EAAE;;eAVnC,OAAO,qBAAqB,EAAE,OAAO"}

package/dist/src/config.d.ts

@@ -8,6 +8,7 @@ export function validate(opts: Libp2pOptions): {
     connectionManager: {
         minConnections: number;
     };
+    connectionGater: {};
     transportManager: {
         faultTolerance: number;
     };
@@ -79,6 +80,7 @@ export function validate(opts: Libp2pOptions): {
     };
 } & Libp2pOptions & constructorOptions;
 export type Multiaddr = import('multiaddr').Multiaddr;
+export type ConnectionGater = import('./types').ConnectionGater;
 export type Libp2pOptions = import('.').Libp2pOptions;
 export type constructorOptions = import('.').constructorOptions;
 //# sourceMappingURL=config.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.js"],"names":[],"mappings":"AAwG0B,+BAHf,aAAa,GACX;;;;;qCA9EmB,SAAS,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA8Ed,aAAa,GAAG,kBAAkB,CAS9D;wBAjGY,OAAO,WAAW,EAAE,SAAS;4BAC7B,OAAO,GAAG,EAAE,aAAa;iCACzB,OAAO,GAAG,EAAE,kBAAkB"}
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../../src/config.js"],"names":[],"mappings":"AA0G0B,+BAHf,aAAa,GACX;;;;;qCA/EmB,SAAS,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA+Ed,aAAa,GAAG,kBAAkB,CAS9D;wBAnGY,OAAO,WAAW,EAAE,SAAS;8BAC7B,OAAO,SAAS,EAAE,eAAe;4BACjC,OAAO,GAAG,EAAE,aAAa;iCACzB,OAAO,GAAG,EAAE,kBAAkB"}

package/dist/src/connection-manager/auto-dialler.d.ts

@@ -28,7 +28,7 @@ declare class AutoDialler {
     /**
      * Starts the auto dialer
      */
-    start(): void;
+    start(): Promise<void>;
     /**
      * Stops the auto dialler
      */

package/dist/src/connection-manager/auto-dialler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"auto-dialler.d.ts","sourceRoot":"","sources":["../../../src/connection-manager/auto-dialler.js"],"names":[],"mappings":";AAiBA;;;GAGG;AAEH;;;;;GAKG;AAEH;IACE;;;;;;;;OAQG;IACH,oBAHW,MAAM,YACN,kBAAkB,EAU5B;IAPC,cAAqF;IACrF,4BAAqB;IACrB,kBAAqB;IACrB,sBAA4B;IAoC9B,2BAqCC;IAnED;;OAEG;IACH,cAWC;IAED;;OAEG;IACH,sBASC;CAwCF;;;;cAnGY,OAAO,UAAU,CAAC"}
+{"version":3,"file":"auto-dialler.d.ts","sourceRoot":"","sources":["../../../src/connection-manager/auto-dialler.js"],"names":[],"mappings":";AAqBA;;;GAGG;AAEH;;;;;GAKG;AAEH;IACE;;;;;;;;OAQG;IACH,oBAHW,MAAM,YACN,kBAAkB,EAU5B;IAPC,cAAqF;IACrF,4BAAqB;IACrB,kBAAqB;IACrB,sBAA4B;IAoC9B,2BA6CC;IA3ED;;OAEG;IACH,uBAWC;IAED;;OAEG;IACH,sBASC;CAgDF;;;;cA3GY,OAAO,UAAU,CAAC"}

package/dist/src/connection-manager/index.d.ts

@@ -97,9 +97,8 @@ declare class ConnectionManager extends EventEmitter {
      * Tracks the incoming connection and check the connection limit
      *
      * @param {Connection} connection
-     * @returns {void}
      */
-    onConnect(connection: Connection): void;
+    onConnect(connection: Connection): Promise<void>;
     /**
      * Removes the connection from tracking
      *

package/dist/src/connection-manager/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection-manager/index.js"],"names":[],"mappings":";AAsCA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AAEH;;;;GAIG;AACH;IACE;;;;;;OAMG;IACH,oBAHW,MAAM,YACN,wBAAwB,EAqClC;IAhCC,uBAAqB;IACrB,gBAA0C;IAE1C,cAAqF;IAOrF;;;;OAIG;IACH,aAFU,IAAI,MAAM,EAAE,MAAM,CAAC,CAE8D;IAE3F;;;;OAIG;IACH,aAFU,IAAI,MAAM,EAAE,UAAU,EAAE,CAAC,CAE6D;IAEhG,kBAAqB;IACrB,YAAkB;IAoFpB;;;;;OAKG;IACH,sBAcC;IArGC,gCAGE;IAGJ;;OAEG;IACH,mBAGC;IAED;;;OAGG;IACH,cAYC;IA8JD;;;;;OAKG;IACH,0BAEC;IApKD;;;;OAIG;IACH,sBASC;IAED;;;;OAIG;IACH,wBAWC;IAED;;;;;;;OAOG;IACH,qBAJW,MAAM,SACN,MAAM,GACJ,IAAI,CAOhB;IAwBD;;;;;OAKG;IACH,sBAHW,UAAU,GACR,IAAI,CAsBhB;IAED;;;;;OAKG;IACH,yBAHW,UAAU,GACR,IAAI,CAgBhB;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,UAAU,GAAC,IAAI,CAQ3B;IAED;;;;;OAKG;IACH,eAHW,MAAM,GACJ,UAAU,EAAE,CAexB;IAYD;;;;;;OAMG;IACH,uBAOC;IAED;;;;;OAKG;IACH,4BAiBC;CACF;;;;;;;;cA7SY,OAAO,KAAK,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection-manager/index.js"],"names":[],"mappings":";AAsCA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AAEH;;;;GAIG;AACH;IACE;;;;;;OAMG;IACH,oBAHW,MAAM,YACN,wBAAwB,EAgDlC;IA3CC,uBAAqB;IACrB,gBAA0C;IAE1C,cAAqF;IAOrF;;;;OAIG;IACH,aAFU,IAAI,MAAM,EAAE,MAAM,CAAC,CAM3B;IAEF;;;;OAIG;IACH,aAFU,IAAI,MAAM,EAAE,UAAU,EAAE,CAAC,CAMjC;IAEF,kBAAqB;IACrB,YAAkB;IAuFpB;;;;;OAKG;IACH,sBAiBC;IA3GC,gCAGE;IAMJ;;OAEG;IACH,mBAGC;IAED;;;OAGG;IACH,cAYC;IAgKD;;;;;OAKG;IACH,0BAKC;IAzKD;;;;OAIG;IACH,sBASC;IAED;;;;OAIG;IACH,wBAWC;IAED;;;;;;;OAOG;IACH,qBAJW,MAAM,SACN,MAAM,GACJ,IAAI,CAOhB;IA2BD;;;;OAIG;IACH,sBAFW,UAAU,iBAsBpB;IAED;;;;;OAKG;IACH,yBAHW,UAAU,GACR,IAAI,CAgBhB;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,UAAU,GAAC,IAAI,CAQ3B;IAED;;;;;OAKG;IACH,eAHW,MAAM,GACJ,UAAU,EAAE,CAexB;IAeD;;;;;;OAMG;IACH,uBAOC;IAED;;;;;OAKG;IACH,4BAqBC;CACF;;;;;;;;cAjUY,OAAO,KAAK,CAAC"}

package/dist/src/content-routing/utils.d.ts

@@ -8,15 +8,15 @@ export type Multiaddr = import('multiaddr').Multiaddr;
  * Store the multiaddrs from every peer in the passed peer store
  *
  * @param {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>} source
- * @param {import('../peer-store')} peerStore
+ * @param {import('../peer-store/types').PeerStore} peerStore
  */
 export function storeAddresses(source: AsyncIterable<{
     id: PeerId;
     multiaddrs: Multiaddr[];
-}>, peerStore: import('../peer-store')): AsyncIterable<{
+}>, peerStore: import('../peer-store/types').PeerStore): AsyncGenerator<{
     id: PeerId;
     multiaddrs: Multiaddr[];
-}>;
+}, void, undefined>;
 /**
  * Filter peers by unique peer id
  *

package/dist/src/content-routing/utils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/content-routing/utils.js"],"names":[],"mappings":"qBAQa,OAAO,SAAS,CAAC;wBACjB,OAAO,WAAW,EAAE,SAAS;AAF1C;;;GAGG;AAEH;;;;;GAKG;AACH,uCAHW,cAAc;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC,aACtD,OAAO,eAAe,CAAC;QADH,MAAM;gBAAc,SAAS,EAAE;GAU7D;AAED;;;;GAIG;AACH,oCAFW,cAAc;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC;QAAlC,MAAM;gBAAc,SAAS,EAAE;kBAgB7D;AAED;;;;;GAKG;AACH,qCAHW,cAAc;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC,QACtD,MAAM;QADc,MAAM;gBAAc,SAAS,EAAE;kBAe7D;AAED;;;;;;GAMG;AACH,yCAHW,cAAc;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC;QAAlC,MAAM;gBAAc,SAAS,EAAE;GAS7D"}
+{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/content-routing/utils.js"],"names":[],"mappings":"qBAQa,OAAO,SAAS,CAAC;wBACjB,OAAO,WAAW,EAAE,SAAS;AAF1C;;;GAGG;AAEH;;;;;GAKG;AACH,uCAHW,cAAc;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC,aACtD,OAAO,qBAAqB,EAAE,SAAS;QADnB,MAAM;gBAAc,SAAS,EAAE;oBAU7D;AAED;;;;GAIG;AACH,oCAFW,cAAc;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC;QAAlC,MAAM;gBAAc,SAAS,EAAE;kBAgB7D;AAED;;;;;GAKG;AACH,qCAHW,cAAc;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC,QACtD,MAAM;QADc,MAAM;gBAAc,SAAS,EAAE;kBAe7D;AAED;;;;;;GAMG;AACH,yCAHW,cAAc;IAAE,EAAE,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,SAAS,EAAE,CAAA;CAAE,CAAC;QAAlC,MAAM;gBAAc,SAAS,EAAE;GAS7D"}

package/dist/src/dialer/dial-request.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"dial-request.d.ts","sourceRoot":"","sources":["../../../src/dialer/dial-request.js"],"names":[],"mappings":";AAWA;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;IACE;;;;;;;;;OASG;IACH,2CAFW,kBAAkB,EAU5B;IAHC,uCAAkB;IAClB,qBAAoB;IACpB,gBAtBc,SAAS,WAAW,WAAW,KAAK,QAAQ,UAAU,CAAC,CAsBzC;IAG9B;;;;;OAKG;IACH;;oBAFa,QAAQ,UAAU,CAAC,CA4C/B;CACF;;;;;;WA3Ea,SAAS,EAAE;oBACP,SAAS,WAAW,WAAW,KAAK,QAAQ,UAAU,CAAC;YAC3D,MAAM;;cAXP,OAAO,IAAI,CAAC;iBACZ,OAAO,WAAW,EAAE,SAAS;;YAK5B,WAAW"}
+{"version":3,"file":"dial-request.d.ts","sourceRoot":"","sources":["../../../src/dialer/dial-request.js"],"names":[],"mappings":";AAWA;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;IACE;;;;;;;;;OASG;IACH,2CAFW,kBAAkB,EAU5B;IAHC,uCAAkB;IAClB,qBAAoB;IACpB,gBAtBc,SAAS,WAAW,WAAW,KAAK,QAAQ,UAAU,CAAC,CAsBzC;IAG9B;;;;;OAKG;IACH;;oBAFa,QAAQ,UAAU,CAAC,CA+C/B;CACF;;;;;;WA9Ea,SAAS,EAAE;oBACP,SAAS,WAAW,WAAW,KAAK,QAAQ,UAAU,CAAC;YAC3D,MAAM;;cAXP,OAAO,IAAI,CAAC;iBACZ,OAAO,WAAW,EAAE,SAAS;;YAK5B,WAAW"}

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

@@ -2,14 +2,16 @@ export = Dialer;
 /**
  * @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
  * @typedef {import('peer-id')} PeerId
- * @typedef {import('../peer-store')} PeerStore
- * @typedef {import('../peer-store/address-book').Address} Address
+ * @typedef {import('../peer-store/types').PeerStore} PeerStore
+ * @typedef {import('../peer-store/types').Address} Address
  * @typedef {import('../transport-manager')} TransportManager
+ * @typedef {import('../types').ConnectionGater} ConnectionGater
  */
 /**
  * @typedef {Object} DialerProperties
  * @property {PeerStore} peerStore
  * @property {TransportManager} transportManager
+ * @property {ConnectionGater} connectionGater
  *
  * @typedef {(addr:Multiaddr) => Promise<string[]>} Resolver
  *
@@ -37,9 +39,10 @@ declare class Dialer {
      * @class
      * @param {DialerProperties & DialerOptions} options
      */
-    constructor({ transportManager, peerStore, addressSorter, maxParallelDials, maxAddrsToDial, dialTimeout, maxDialsPerPeer, resolvers, metrics }: DialerProperties & DialerOptions);
+    constructor({ transportManager, peerStore, connectionGater, addressSorter, maxParallelDials, maxAddrsToDial, dialTimeout, maxDialsPerPeer, resolvers, metrics }: DialerProperties & DialerOptions);
+    connectionGater: import("../types").ConnectionGater;
     transportManager: import("../transport-manager");
-    peerStore: import("../peer-store");
+    peerStore: import("../peer-store/types").PeerStore;
     addressSorter: (addresses: Address[]) => Address[];
     maxParallelDials: number;
     maxAddrsToDial: number;
@@ -124,7 +127,7 @@ declare class Dialer {
     _resolveRecord(ma: Multiaddr): Promise<Multiaddr[]>;
 }
 declare namespace Dialer {
-    export { Connection, PeerId, PeerStore, Address, TransportManager, DialerProperties, Resolver, DialerOptions, DialTarget, PendingDial };
+    export { Connection, PeerId, PeerStore, Address, TransportManager, ConnectionGater, DialerProperties, Resolver, DialerOptions, DialTarget, PendingDial };
 }
 type PendingDial = {
     dialRequest: import('./dial-request');
@@ -142,6 +145,7 @@ type DialTarget = {
 type DialerProperties = {
     peerStore: PeerStore;
     transportManager: TransportManager;
+    connectionGater: ConnectionGater;
 };
 type DialerOptions = {
     /**
@@ -170,8 +174,9 @@ type DialerOptions = {
     resolvers?: Record<string, Resolver> | undefined;
     metrics?: import("../metrics") | undefined;
 };
-type PeerStore = import('../peer-store');
-type Address = import('../peer-store/address-book').Address;
+type PeerStore = import('../peer-store/types').PeerStore;
+type Address = import('../peer-store/types').Address;
 type TransportManager = import('../transport-manager');
+type ConnectionGater = import('../types').ConnectionGater;
 type Resolver = (addr: Multiaddr) => Promise<string[]>;
 //# sourceMappingURL=index.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dialer/index.js"],"names":[],"mappings":";AA6BA;;;;;;GAMG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH;IACE;;;OAGG;IACH,gJAFW,gBAAgB,GAAG,aAAa,EA+B1C;IAlBC,iDAAwC;IACxC,mCAA0B;IAC1B,2BArCsB,OAAO,EAAE,KAAK,OAAO,EAAE,CAqCX;IAClC,yBAAwC;IACxC,uBAAoC;IACpC,gBAA0B;IAC1B,wBAAsC;IACtC,iBAAuE;IAEvE,uCAAuC;IACvC,eADW,IAAI,MAAM,EAAE,WAAW,CAAC,CAC+C;IAElF,0FAA0F;IAC1F;yBAD0C,GAAG,KAAK,IAAI;sBAAgB,KAAK,KAAK,IAAI;OACW;IAOjG;;OAEG;IACH,gBAcC;IAED;;;;;;;;;OASG;IACH,oBALW,MAAM,GAAC,SAAS,GAAC,MAAM;;oBAGrB,QAAQ,UAAU,CAAC,CAwB/B;IAED;;;;;;;OAOG;IACH,mCAHW,MAAM,GAAC,SAAS,GAAC,MAAM,GACrB,QAAQ,UAAU,CAAC,CAmB/B;IAED;;;;;;;;;OASG;IACH,0BAmCC;IAED;;;;;;;;OAQG;IACH,2BAuCC;IAED;;OAEG;IACH,eAFW,MAAM,YAOhB;IAED;;OAEG;IACH,oBAFW,MAAM,QAOhB;IAED;;;;;OAKG;IACH,aAHW,SAAS,GACP,QAAQ,SAAS,EAAE,CAAC,CAwBhC;IAED;;;;;OAKG;IACH,mBAHW,SAAS,GACP,QAAQ,SAAS,EAAE,CAAC,CAWhC;CACF;;;;;iBA7Ra,OAAO,gBAAgB,CAAC;gBACxB,OAAO,0BAA0B,EAAE,iBAAiB;aACpD,QAAQ,UAAU,CAAC;mBACR,IAAI;;cA9BhB,OAAO,SAAS,CAAC;;;;QAuBhB,MAAM;WACN,SAAS,EAAE;;;eAhBX,SAAS;sBACT,gBAAgB;;;;;;iCAKJ,OAAO,EAAE,KAAK,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;iBAbpC,OAAO,eAAe,CAAC;eACvB,OAAO,4BAA4B,EAAE,OAAO;wBAC5C,OAAO,sBAAsB,CAAC;uBAQxB,SAAS,KAAK,QAAQ,MAAM,EAAE,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dialer/index.js"],"names":[],"mappings":";AAgCA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;IACE;;;OAGG;IACH,iKAFW,gBAAgB,GAAG,aAAa,EAyC1C;IA3BC,oDAAsC;IACtC,iDAAwC;IACxC,mDAA0B;IAC1B,2BAvCsB,OAAO,EAAE,KAAK,OAAO,EAAE,CAuCX;IAClC,yBAAwC;IACxC,uBAAoC;IACpC,gBAA0B;IAC1B,wBAAsC;IACtC,iBAAuE;IAEvE,uCAAuC;IACvC,eADW,IAAI,MAAM,EAAE,WAAW,CAAC,CAKjC;IAEF,0FAA0F;IAC1F;yBAD0C,GAAG,KAAK,IAAI;sBAAgB,KAAK,KAAK,IAAI;OAKlF;IAOJ;;OAEG;IACH,gBAcC;IAED;;;;;;;;;OASG;IACH,oBALW,MAAM,GAAC,SAAS,GAAC,MAAM;;oBAGrB,QAAQ,UAAU,CAAC,CA8B/B;IAED;;;;;;;OAOG;IACH,mCAHW,MAAM,GAAC,SAAS,GAAC,MAAM,GACrB,QAAQ,UAAU,CAAC,CAmB/B;IAED;;;;;;;;;OASG;IACH,0BAyCC;IAED;;;;;;;;OAQG;IACH,2BA0CC;IAED;;OAEG;IACH,eAFW,MAAM,YAOhB;IAED;;OAEG;IACH,oBAFW,MAAM,QAOhB;IAED;;;;;OAKG;IACH,aAHW,SAAS,GACP,QAAQ,SAAS,EAAE,CAAC,CAwBhC;IAED;;;;;OAKG;IACH,mBAHW,SAAS,GACP,QAAQ,SAAS,EAAE,CAAC,CAWhC;CACF;;;;;iBAtTa,OAAO,gBAAgB,CAAC;gBACxB,OAAO,0BAA0B,EAAE,iBAAiB;aACpD,QAAQ,UAAU,CAAC;mBACR,IAAI;;cAhChB,OAAO,SAAS,CAAC;;;;QAyBhB,MAAM;WACN,SAAS,EAAE;;;eAjBX,SAAS;sBACT,gBAAgB;qBAChB,eAAe;;;;;;iCAKH,OAAO,EAAE,KAAK,OAAO,EAAE;;;;;;;;;;;;;;;;;;;;;;;iBAfpC,OAAO,qBAAqB,EAAE,SAAS;eACvC,OAAO,qBAAqB,EAAE,OAAO;wBACrC,OAAO,sBAAsB,CAAC;uBAC9B,OAAO,UAAU,EAAE,eAAe;uBAS5B,SAAS,KAAK,QAAQ,MAAM,EAAE,CAAC"}

package/dist/src/errors.d.ts

@@ -11,6 +11,8 @@ export namespace codes {
     export const DHT_NOT_STARTED: string;
     const CONN_ENCRYPTION_REQUIRED_1: string;
     export { CONN_ENCRYPTION_REQUIRED_1 as CONN_ENCRYPTION_REQUIRED };
+    export const ERR_PEER_DIAL_INTERCEPTED: string;
+    export const ERR_CONNECTION_INTERCEPTED: string;
     export const ERR_INVALID_PROTOCOLS_FOR_STREAM: string;
     export const ERR_CONNECTION_ENDED: string;
     export const ERR_CONNECTION_FAILED: string;

package/dist/src/fetch/constants.d.ts

@@ -0,0 +1,2 @@
+export const PROTOCOL: string;
+//# sourceMappingURL=constants.d.ts.map

package/dist/src/fetch/constants.d.ts.map

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

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

@@ -0,0 +1,76 @@
+export = FetchProtocol;
+/**
+ * @typedef {import('../')} Libp2p
+ * @typedef {import('multiaddr').Multiaddr} Multiaddr
+ * @typedef {import('peer-id')} PeerId
+ * @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
+ * @typedef {(key: string) => Promise<Uint8Array | null>} LookupFunction
+ */
+/**
+ * A simple libp2p protocol for requesting a value corresponding to a key from a peer.
+ * Developers can register one or more lookup function for retrieving the value corresponding to
+ * a given key.  Each lookup function must act on a distinct part of the overall key space, defined
+ * by a fixed prefix that all keys that should be routed to that lookup function will start with.
+ */
+declare class FetchProtocol {
+    /**
+     * @param {Libp2p} libp2p
+     */
+    constructor(libp2p: Libp2p);
+    _lookupFunctions: Map<any, any>;
+    _libp2p: import("../");
+    /**
+     * Invoked when a fetch request is received.  Reads the request message off the given stream and
+     * responds based on looking up the key in the request via the lookup callback that corresponds
+     * to the key's prefix.
+     *
+     * @param {object} options
+     * @param {MuxedStream} options.stream
+     * @param {string} options.protocol
+     */
+    handleMessage(options: {
+        stream: MuxedStream;
+        protocol: 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>;
+    /**
+     * Given a key, finds the appropriate function for looking up its corresponding value, based on
+     * the key's prefix.
+     *
+     * @param {string} key
+     */
+    _getLookupFunction(key: string): any;
+    /**
+     * Registers a new lookup callback that can map keys to values, for a given set of keys that
+     * share the same prefix.
+     *
+     * @param {string} prefix
+     * @param {LookupFunction} lookup
+     */
+    registerLookupFunction(prefix: string, lookup: LookupFunction): void;
+    /**
+     * Registers a new lookup callback that can map keys to values, for a given set of keys that
+     * share the same prefix.
+     *
+     * @param {string} prefix
+     * @param {LookupFunction} [lookup]
+     */
+    unregisterLookupFunction(prefix: string, lookup?: LookupFunction | undefined): void;
+}
+declare namespace FetchProtocol {
+    export { PROTOCOL, Libp2p, Multiaddr, PeerId, MuxedStream, LookupFunction };
+}
+type MuxedStream = import('libp2p-interfaces/src/stream-muxer/types').MuxedStream;
+type PeerId = import('peer-id');
+type Multiaddr = import('multiaddr').Multiaddr;
+type LookupFunction = (key: string) => Promise<Uint8Array | null>;
+type Libp2p = import('../');
+import { PROTOCOL } from "./constants";
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/fetch/index.js"],"names":[],"mappings":";AAcA;;;;;;GAMG;AAEH;;;;;GAKG;AACH;IACE;;OAEG;IACH,oBAFW,MAAM,EAMhB;IAHC,gCAAiC;IACjC,uBAAqB;IA0CvB;;;;;;;;OAQG;IACH;QAHgC,MAAM,EAA3B,WAAW;QACK,QAAQ,EAAxB,MAAM;sBAsBhB;IAnED;;;;;;OAMG;IACH,YAJW,MAAM,GAAC,SAAS,OAChB,MAAM,GACJ,QAAQ,UAAU,GAAG,IAAI,CAAC,CA+BtC;IAiCD;;;;;OAKG;IACH,wBAFW,MAAM,OAShB;IAED;;;;;;OAMG;IACH,+BAHW,MAAM,gCAQhB;IAED;;;;;;OAMG;IACH,iCAHW,MAAM,6CAahB;CACF;;;;mBAxIY,OAAO,0CAA0C,EAAE,WAAW;cAD9D,OAAO,SAAS,CAAC;iBADjB,OAAO,WAAW,EAAE,SAAS;4BAGvB,MAAM,KAAK,QAAQ,UAAU,GAAG,IAAI,CAAC;cAJ3C,OAAO,KAAK,CAAC"}

package/dist/src/fetch/proto.d.ts

@@ -0,0 +1,134 @@
+import * as $protobuf from "protobufjs";
+/** Properties of a FetchRequest. */
+export interface IFetchRequest {
+
+    /** FetchRequest identifier */
+    identifier?: (string|null);
+}
+
+/** Represents a FetchRequest. */
+export class FetchRequest implements IFetchRequest {
+
+    /**
+     * Constructs a new FetchRequest.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IFetchRequest);
+
+    /** FetchRequest identifier. */
+    public identifier: string;
+
+    /**
+     * Encodes the specified FetchRequest message. Does not implicitly {@link FetchRequest.verify|verify} messages.
+     * @param m FetchRequest message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IFetchRequest, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes a FetchRequest message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns FetchRequest
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): FetchRequest;
+
+    /**
+     * Creates a FetchRequest message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns FetchRequest
+     */
+    public static fromObject(d: { [k: string]: any }): FetchRequest;
+
+    /**
+     * Creates a plain object from a FetchRequest message. Also converts values to other types if specified.
+     * @param m FetchRequest
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: FetchRequest, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this FetchRequest to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+/** Properties of a FetchResponse. */
+export interface IFetchResponse {
+
+    /** FetchResponse status */
+    status?: (FetchResponse.StatusCode|null);
+
+    /** FetchResponse data */
+    data?: (Uint8Array|null);
+}
+
+/** Represents a FetchResponse. */
+export class FetchResponse implements IFetchResponse {
+
+    /**
+     * Constructs a new FetchResponse.
+     * @param [p] Properties to set
+     */
+    constructor(p?: IFetchResponse);
+
+    /** FetchResponse status. */
+    public status: FetchResponse.StatusCode;
+
+    /** FetchResponse data. */
+    public data: Uint8Array;
+
+    /**
+     * Encodes the specified FetchResponse message. Does not implicitly {@link FetchResponse.verify|verify} messages.
+     * @param m FetchResponse message or plain object to encode
+     * @param [w] Writer to encode to
+     * @returns Writer
+     */
+    public static encode(m: IFetchResponse, w?: $protobuf.Writer): $protobuf.Writer;
+
+    /**
+     * Decodes a FetchResponse message from the specified reader or buffer.
+     * @param r Reader or buffer to decode from
+     * @param [l] Message length if known beforehand
+     * @returns FetchResponse
+     * @throws {Error} If the payload is not a reader or valid buffer
+     * @throws {$protobuf.util.ProtocolError} If required fields are missing
+     */
+    public static decode(r: ($protobuf.Reader|Uint8Array), l?: number): FetchResponse;
+
+    /**
+     * Creates a FetchResponse message from a plain object. Also converts values to their respective internal types.
+     * @param d Plain object
+     * @returns FetchResponse
+     */
+    public static fromObject(d: { [k: string]: any }): FetchResponse;
+
+    /**
+     * Creates a plain object from a FetchResponse message. Also converts values to other types if specified.
+     * @param m FetchResponse
+     * @param [o] Conversion options
+     * @returns Plain object
+     */
+    public static toObject(m: FetchResponse, o?: $protobuf.IConversionOptions): { [k: string]: any };
+
+    /**
+     * Converts this FetchResponse to JSON.
+     * @returns JSON object
+     */
+    public toJSON(): { [k: string]: any };
+}
+
+export namespace FetchResponse {
+
+    /** StatusCode enum. */
+    enum StatusCode {
+        OK = 0,
+        NOT_FOUND = 1,
+        ERROR = 2
+    }
+}

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

@@ -31,7 +31,7 @@ declare class IdentifyService {
         libp2p: import('../');
     });
     _libp2p: import("../");
-    peerStore: import("../peer-store");
+    peerStore: import("../peer-store/types").PeerStore;
     addressManager: import("../address-manager");
     connectionManager: import("../connection-manager");
     peerId: PeerId;
@@ -55,6 +55,8 @@ declare class IdentifyService {
         agentVersion: string;
         protocolVersion: string;
     };
+    start(): Promise<void>;
+    stop(): Promise<void>;
     /**
      * Send an Identify Push update to the list of connections
      *
@@ -64,10 +66,8 @@ declare class IdentifyService {
     push(connections: Connection[]): Promise<void[]>;
     /**
      * Calls `push` for all peers in the `peerStore` that are connected
-     *
-     * @returns {void}
      */
-    pushToPeerStore(): void;
+    pushToPeerStore(): Promise<void>;
     /**
      * Requests the `Identify` message from peer associated with the given `connection`.
      * If the identified peer does not match the `PeerId` associated with the connection,

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/identify/index.js"],"names":[],"mappings":";AAkCA;;;GAGG;AAEH;;;GAGG;AAEH;IACE;;OAEG;IACH,8BAFW,OAAO,KAAK,CAAC;;;MAOvB;IAkSD;;;;;OAKG;IACH,+BAHW,UAAU,GAAG,MAAM,GACjB,SAAS,GAAC,IAAI,CAW1B;IA/SD;;;;OAIG;IACH;QAFkC,MAAM,EAA7B,OAAO,KAAK,CAAC;OAyCvB;IAtCC,uBAAqB;IACrB,mCAAiC;IACjC,6CAA2C;IAC3C,mDAAiD;IACjD,eAA2B;IAwK7B;;;;;;;;OAQG;IACH;oBALW,UAAU;gBACV,WAAW;kBACX,MAAM;QACJ,QAAQ,IAAI,CAAC,GAAC,SAAS,CAWnC;IArLC,4BAA0D;IAC1D,gCAAkE;IAGlE;sBAjCU,MAAM;;MAoCf;IAwBH;;;;;OAKG;IACH,kBAHW,UAAU,EAAE,GACV,QAAQ,IAAI,EAAE,CAAC,CA4B3B;IAED;;;;OAIG;IACH,mBAFa,IAAI,CAiBhB;IAED;;;;;;;;OAQG;IACH,qBAHW,UAAU,GACR,QAAQ,IAAI,CAAC,CAmEzB;IAsBD;;;;;;;;;OASG;IACH,wBA6BC;IAED;;;;;;;;OAQG;IACH,oBAsCC;CAkBF;;;;;;;;;;;;mBAnUY,OAAO,0CAA0C,EAAE,WAAW;;kBAK7D,MAAM"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/identify/index.js"],"names":[],"mappings":";AAkCA;;;GAGG;AAEH;;;GAGG;AAEH;IACE;;OAEG;IACH,8BAFW,OAAO,KAAK,CAAC;;;MAOvB;IA2SD;;;;;OAKG;IACH,+BAHW,UAAU,GAAG,MAAM,GACjB,SAAS,GAAC,IAAI,CAW1B;IAxTD;;;;OAIG;IACH;QAFkC,MAAM,EAA7B,OAAO,KAAK,CAAC;OAuCvB;IApCC,uBAAqB;IACrB,mDAAiC;IACjC,6CAA2C;IAC3C,mDAAiD;IACjD,eAA2B;IA6K7B;;;;;;;;OAQG;IACH;oBALW,UAAU;gBACV,WAAW;kBACX,MAAM;QACJ,QAAQ,IAAI,CAAC,GAAC,SAAS,CAWnC;IA1LC,4BAA0D;IAC1D,gCAAkE;IAGlE;sBAjCU,MAAM;;MAoCf;IAsBH,uBAGC;IAED,sBAEC;IAED;;;;;OAKG;IACH,kBAHW,UAAU,EAAE,GACV,QAAQ,IAAI,EAAE,CAAC,CA4B3B;IAED;;OAEG;IACH,iCAeC;IAED;;;;;;;;OAQG;IACH,qBAHW,UAAU,GACR,QAAQ,IAAI,CAAC,CAmEzB;IAsBD;;;;;;;;;OASG;IACH,wBA6BC;IAED;;;;;;;;OAQG;IACH,oBA0CC;CAkBF;;;;;;;;;;;;mBA5UY,OAAO,0CAA0C,EAAE,WAAW;;kBAK7D,MAAM"}