fluencelabs/js-libp2p
1
0
Fork 0
mirror of https://github.com/fluencelabs/js-libp2p synced 2025-04-25 10:32:14 +00:00
Code Issues Projects Releases Wiki Activity

chore: use psot install

Browse Source
This commit is contained in:
Vasco Santos 2020-12-02 22:24:47 +01:00
parent f568f16a31
commit 64f9241041
135 changed files with 208136 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
.gitignore vendored
View File

@ -29,14 +29,11 @@ coverage
# node-waf configuration
.lock-wscript
build
# Dependency directory
# https://www.npmjs.org/doc/misc/npm-faq.html#should-i-check-my-node_modules-folder-into-git
node_modules
lib
dist
test/test-data/go-ipfs-repo/LOCK
test/test-data/go-ipfs-repo/LOG
test/test-data/go-ipfs-repo/LOG.old

2
dist/index.min.js vendored Normal file
View File

File diff suppressed because one or more lines are too long

17
dist/index.min.js.LICENSE.txt vendored Normal file
View File

@ -0,0 +1,17 @@
/*!
* The buffer module from node.js, for the browser.
*
* @author Feross Aboukhadijeh <http://feross.org>
* @license MIT
*/
/*! ieee754. BSD-3-Clause License. Feross Aboukhadijeh <https://feross.org/opensource> */
/**
* [js-sha3]{@link https://github.com/emn178/js-sha3}
*
* @version 0.8.0
* @author Chen, Yi-Cyuan [emn178@gmail.com]
* @copyright Chen, Yi-Cyuan 2015-2018
* @license MIT
*/

50
dist/src/address-manager/index.d.ts vendored Normal file
View File

@ -0,0 +1,50 @@
export = AddressManager;
/**
* @typedef {import('multiaddr')} Multiaddr
*/
/**
* @typedef {Object} AddressManagerOptions
* @property {string[]} [listen = []] - list of multiaddrs string representation to listen.
* @property {string[]} [announce = []] - list of multiaddrs string representation to announce.
*/
declare class AddressManager {
/**
* Responsible for managing the peer addresses.
* Peers can specify their listen and announce addresses.
* The listen addresses will be used by the libp2p transports to listen for new connections,
* while the announce addresses will be used for the peer addresses' to other peers in the network.
*
* @class
* @param {AddressManagerOptions} [options]
*/
constructor({ listen, announce }?: AddressManagerOptions | undefined);
listen: Set<string>;
announce: Set<string>;
/**
* Get peer listen multiaddrs.
*
* @returns {Multiaddr[]}
*/
getListenAddrs(): Multiaddr[];
/**
* Get peer announcing multiaddrs.
*
* @returns {Multiaddr[]}
*/
getAnnounceAddrs(): Multiaddr[];
}
declare namespace AddressManager {
export { Multiaddr, AddressManagerOptions };
}
type Multiaddr = import("multiaddr");
type AddressManagerOptions = {
/**
* - list of multiaddrs string representation to listen.
*/
listen?: string[] | undefined;
/**
* - list of multiaddrs string representation to announce.
*/
announce?: string[] | undefined;
};
//# sourceMappingURL=index.d.ts.map

1
dist/src/address-manager/index.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/address-manager/index.js"],"names":[],"mappings":";AAIA;;GAEG;AAEH;;;;GAIG;AACH;IACE;;;;;;;;OAQG;IACH,sEAGC;IAFC,oBAA6B;IAC7B,sBAAiC;IAGnC;;;;OAIG;IACH,kBAFa,SAAS,EAAE,CAIvB;IAED;;;;OAIG;IACH,oBAFa,SAAS,EAAE,CAIvB;CACF"}

106
dist/src/circuit/auto-relay.d.ts vendored Normal file
View File

@ -0,0 +1,106 @@
export = AutoRelay;
/**
* @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
* @typedef {import('../peer-store/address-book').Address} Address
*/
/**
* @typedef {Object} AutoRelayProperties
* @property {import('../')} libp2p
*
* @typedef {Object} AutoRelayOptions
* @property {number} [maxListeners = 1] - maximum number of relays to listen.
*/
declare class AutoRelay {
/**
* Creates an instance of AutoRelay.
*
* @class
* @param {AutoRelayProperties & AutoRelayOptions} props
*/
constructor({ libp2p, maxListeners }: AutoRelayProperties & AutoRelayOptions);
_libp2p: import("..");
_peerId: import("peer-id");
_peerStore: import("../peer-store");
_connectionManager: import("../connection-manager");
_transportManager: import("../transport-manager");
_addressSorter: (addresses: import("../peer-store/address-book").Address[]) => import("../peer-store/address-book").Address[];
maxListeners: number;
/**
* @type {Set<string>}
*/
_listenRelays: Set<string>;
/**
* Check if a peer supports the relay protocol.
* If the protocol is not supported, check if it was supported before and remove it as a listen relay.
* If the protocol is supported, check if the peer supports **HOP** and add it as a listener if
* inside the threshold.
*
* @param {Object} props
* @param {PeerId} props.peerId
* @param {string[]} props.protocols
* @returns {Promise<void>}
*/
_onProtocolChange({ peerId, protocols }: {
peerId: import("peer-id");
protocols: string[];
}): Promise<void>;
/**
* Peer disconnects.
*
* @param {Connection} connection - connection to the peer
* @returns {void}
*/
_onPeerDisconnected(connection: Connection): void;
/**
* Attempt to listen on the given relay connection.
*
* @private
* @param {Connection} connection - connection to the peer
* @param {string} id - peer identifier string
* @returns {Promise<void>}
*/
private _addListenRelay;
/**
* Remove listen relay.
*
* @private
* @param {string} id - peer identifier string.
* @returns {void}
*/
private _removeListenRelay;
/**
* Try to listen on available hop relay connections.
* The following order will happen while we do not have enough relays.
* 1. Check the metadata store for known relays, try to listen on the ones we are already connected.
* 2. Dial and try to listen on the peers we know that support hop but are not connected.
* 3. Search the network.
*
* @param {string[]} [peersToIgnore]
* @returns {Promise<void>}
*/
_listenOnAvailableHopRelays(peersToIgnore?: string[] | undefined): Promise<void>;
}
declare namespace AutoRelay {
export { Connection, Address, AutoRelayProperties, AutoRelayOptions };
}
type Connection = import("libp2p-interfaces/src/connection/connection");
type AutoRelayProperties = {
libp2p: import('../');
};
type AutoRelayOptions = {
/**
* - maximum number of relays to listen.
*/
maxListeners?: number | undefined;
};
type Address = {
/**
* peer multiaddr.
*/
multiaddr: import("multiaddr");
/**
* obtained from a signed peer record.
*/
isCertified: boolean;
};
//# sourceMappingURL=auto-relay.d.ts.map

1
dist/src/circuit/auto-relay.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"auto-relay.d.ts","sourceRoot":"","sources":["../../../src/circuit/auto-relay.js"],"names":[],"mappings":";AAsBA;;;GAGG;AAEH;;;;;;GAMG;AAEH;IACE;;;;;OAKG;IACH,sCAFW,mBAAmB,GAAG,gBAAgB,EAsBhD;IAnBC,sBAAqB;IACrB,2BAA4B;IAC5B,oCAAkC;IAClC,oDAAkD;IAClD,kDAAgD;IAChD,8HAAiD;IAEjD,qBAAgC;IAEhC;;OAEG;IACH,eAFU,IAAI,MAAM,CAAC,CAES;IAShC;;;;;;;;;;OAUG;IACH;QAJyB,MAAM;QACJ,SAAS,EAAzB,MAAM,EAAE;QACN,QAAQ,IAAI,CAAC,CAsCzB;IAED;;;;;OAKG;IACH,gCAHW,UAAU,GACR,IAAI,CAYhB;IAED;;;;;;;OAOG;IACH,wBA0BC;IAED;;;;;;OAMG;IACH,2BAKC;IAED;;;;;;;;;OASG;IACH,mEAFa,QAAQ,IAAI,CAAC,CA2EzB;CACF;;;;;;YA5Oa,OAAO,KAAK,CAAC"}

70
dist/src/circuit/circuit/hop.d.ts vendored Normal file
View File

@ -0,0 +1,70 @@
export type CircuitRequest = {
type: import("../../types").CircuitType;
dstPeer: import("../../types").CircuitPeer;
srcPeer: import("../../types").CircuitPeer;
};
export type Connection = import("libp2p-interfaces/src/connection/connection");
export type StreamHandlerT = import("./stream-handler")<import("../../types").CircuitRequest>;
export type Transport = import("../transport");
export type HopRequest = {
connection: Connection;
request: CircuitRequest;
streamHandler: import("./stream-handler")<import("../../types").CircuitRequest>;
circuit: Transport;
};
/**
* @typedef {import('../../types').CircuitRequest} CircuitRequest
* @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
* @typedef {import('./stream-handler')<CircuitRequest>} StreamHandlerT
* @typedef {import('../transport')} Transport
*/
/**
* @typedef {Object} HopRequest
* @property {Connection} connection
* @property {CircuitRequest} request
* @property {StreamHandlerT} streamHandler
* @property {Transport} circuit
*/
/**
* @param {HopRequest} options
* @returns {Promise<void>}
*/
export function handleHop({ connection, request, streamHandler, circuit }: HopRequest): Promise<void>;
/**
* Performs a HOP request to a relay peer, to request a connection to another
* peer. A new, virtual, connection will be created between the two via the relay.
*
* @param {object} options
* @param {Connection} options.connection - Connection to the relay
* @param {CircuitRequest} options.request
* @returns {Promise<Connection>}
*/
export function hop({ connection, request }: {
connection: Connection;
request: CircuitRequest;
}): Promise<Connection>;
/**
* Performs a CAN_HOP request to a relay peer, in order to understand its capabilities.
*
* @param {object} options
* @param {Connection} options.connection - Connection to the relay
* @returns {Promise<boolean>}
*/
export function canHop({ connection }: {
connection: Connection;
}): Promise<boolean>;
/**
* Creates an unencoded CAN_HOP response based on the Circuits configuration
*
* @param {Object} options
* @param {Connection} options.connection
* @param {StreamHandlerT} options.streamHandler
* @param {Transport} options.circuit
* @private
*/
export function handleCanHop({ connection, streamHandler, circuit }: {
connection: Connection;
streamHandler: import("./stream-handler")<import("../../types").CircuitRequest>;
circuit: Transport;
}): void;
//# sourceMappingURL=hop.d.ts.map

1
dist/src/circuit/circuit/hop.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"hop.d.ts","sourceRoot":"","sources":["../../../../src/circuit/circuit/hop.js"],"names":[],"mappings":";;;;;;;;;gBA4Bc,UAAU;aACV,cAAc;;aAEd,SAAS;;AAZvB;;;;;GAKG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AACH,2EAHW,UAAU,GACR,QAAQ,IAAI,CAAC,CAuEzB;AAED;;;;;;;;GAQG;AACH;IAJ+B,UAAU,EAA9B,UAAU;IACc,OAAO,EAA/B,cAAc;IACZ,QAAQ,UAAU,CAAC,CAsB/B;AAED;;;;;;GAMG;AACH;IAH+B,UAAU,EAA9B,UAAU;IACR,QAAQ,OAAO,CAAC,CAqB5B;AAED;;;;;;;;GAQG;AACH;IAL+B,UAAU,EAA9B,UAAU;IACc,aAAa;IAClB,OAAO,EAA1B,SAAS;SAcnB"}

18
dist/src/circuit/circuit/stop.d.ts vendored Normal file
View File

@ -0,0 +1,18 @@
export function handleStop({ connection, request, streamHandler }: {
connection: Connection;
request: CircuitRequest;
streamHandler: import("./stream-handler")<import("../../types").CircuitRequest>;
}): Promise<MuxedStream> | void;
export function stop({ connection, request }: {
connection: Connection;
request: CircuitRequest;
}): Promise<MuxedStream | void>;
export type Connection = import("libp2p-interfaces/src/connection/connection");
export type MuxedStream = import("libp2p-interfaces/src/stream-muxer/types").MuxedStream;
export type CircuitRequest = {
type: import("../../types").CircuitType;
dstPeer: import("../../types").CircuitPeer;
srcPeer: import("../../types").CircuitPeer;
};
export type StreamHandlerT = import("./stream-handler")<import("../../types").CircuitRequest>;
//# sourceMappingURL=stop.d.ts.map

1
dist/src/circuit/circuit/stop.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"stop.d.ts","sourceRoot":"","sources":["../../../../src/circuit/circuit/stop.js"],"names":[],"mappings":"AA6B4B;IALG,UAAU,EAA9B,UAAU;IACc,OAAO,EAA/B,cAAc;IACU,aAAa;IACnC,QAAQ,WAAW,CAAC,GAAC,IAAI,CAqBrC;AAWqB;IAJS,UAAU,EAA9B,UAAU;IACc,OAAO,EAA/B,cAAc;IACZ,QAAQ,WAAW,GAAC,IAAI,CAAC,CAoBrC"}

56
dist/src/circuit/circuit/stream-handler.d.ts vendored Normal file
View File

@ -0,0 +1,56 @@
export = StreamHandler;
/**
* @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
*/
/**
* @template T
*/
declare class StreamHandler<T> {
/**
* Create a stream handler for connection
*
* @class
* @param {object} options
* @param {MuxedStream} options.stream - A duplex iterable
* @param {number} [options.maxLength = 4096] - max bytes length of message
*/
constructor({ stream, maxLength }: {
stream: MuxedStream;
maxLength: number | undefined;
});
stream: import("libp2p-interfaces/src/stream-muxer/types").MuxedStream;
shake: any;
decoder: AsyncGenerator<Buffer | import("bl"), import("bl"), unknown>;
/**
* Read and decode message
*
* @async
* @returns {Promise<T|undefined>}
*/
read(): Promise<T | undefined>;
/**
* Encode and write array of buffers
*
* @param {CircuitPB} msg - An unencoded CircuitRelay protobuf message
* @returns {void}
*/
write(msg: any): void;
/**
* Return the handshake rest stream and invalidate handler
*
* @returns {*} A duplex iterable
*/
rest(): any;
end(msg: any): void;
/**
* Close the stream
*
* @returns {void}
*/
close(): void;
}
declare namespace StreamHandler {
export { MuxedStream };
}
type MuxedStream = import("libp2p-interfaces/src/stream-muxer/types").MuxedStream;
//# sourceMappingURL=stream-handler.d.ts.map

1
dist/src/circuit/circuit/stream-handler.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"stream-handler.d.ts","sourceRoot":"","sources":["../../../../src/circuit/circuit/stream-handler.js"],"names":[],"mappings":";AAWA;;GAEG;AAEH;;GAEG;AACH;IACE;;;;;;;OAOG;IACH;QAHgC,MAAM,EAA3B,WAAW;QACM,SAAS;OAOpC;IAJC,uEAAoB;IAEpB,WAAmC;IACnC,sEAAoF;IAGtF;;;;;OAKG;IACH,+BAWC;IAED;;;;;OAKG;IACH,iBAFa,IAAI,CAMhB;IAED;;;;OAIG;IACH,YAGC;IAED,oBAGC;IAED;;;;OAIG;IACH,SAFa,IAAI,CAKhB;CACF"}

10
dist/src/circuit/circuit/utils.d.ts vendored Normal file
View File

@ -0,0 +1,10 @@
export type StreamHandler = import("./stream-handler")<any>;
export type CircuitStatus = 100 | 220 | 221 | 250 | 251 | 260 | 261 | 262 | 270 | 280 | 320 | 321 | 350 | 351 | 390 | 400;
/**
* Validate incomming HOP/STOP message
*
* @param {*} msg - A CircuitRelay unencoded protobuf message
* @param {StreamHandler} streamHandler
*/
export function validateAddrs(msg: any, streamHandler: import("./stream-handler")<any>): void;
//# sourceMappingURL=utils.d.ts.map

1
dist/src/circuit/circuit/utils.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../../src/circuit/circuit/utils.js"],"names":[],"mappings":";;AAuBA;;;;;GAKG;AACH,8FAsBC"}

7
dist/src/circuit/constants.d.ts vendored Normal file
View File

@ -0,0 +1,7 @@
export const ADVERTISE_BOOT_DELAY: number;
export const ADVERTISE_TTL: number;
export const CIRCUIT_PROTO_CODE: number;
export const HOP_METADATA_KEY: string;
export const HOP_METADATA_VALUE: string;
export const RELAY_RENDEZVOUS_NS: string;
//# sourceMappingURL=constants.d.ts.map

1
dist/src/circuit/constants.d.ts.map vendored Normal file
View File

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

69
dist/src/circuit/index.d.ts vendored Normal file
View File

@ -0,0 +1,69 @@
export = Relay;
/**
* @typedef {import('../')} Libp2p
*
* @typedef {Object} RelayAdvertiseOptions
* @property {number} [bootDelay = ADVERTISE_BOOT_DELAY]
* @property {boolean} [enabled = true]
* @property {number} [ttl = ADVERTISE_TTL]
*
* @typedef {Object} HopOptions
* @property {boolean} [enabled = false]
* @property {boolean} [active = false]
*
* @typedef {Object} AutoRelayOptions
* @property {number} [maxListeners = 2] - maximum number of relays to listen.
* @property {boolean} [enabled = false]
*/
declare class Relay {
/**
* Creates an instance of Relay.
*
* @class
* @param {Libp2p} libp2p
*/
constructor(libp2p: Libp2p);
_libp2p: import("..");
_options: any;
_autoRelay: import("./auto-relay");
/**
* Advertise hop relay service in the network.
*
* @returns {Promise<void>}
*/
_advertiseService(): Promise<void>;
/**
* Start Relay service.
*
* @returns {void}
*/
start(): void;
_timeout: any;
/**
* Stop Relay service.
*
* @returns {void}
*/
stop(): void;
}
declare namespace Relay {
export { Libp2p, RelayAdvertiseOptions, HopOptions, AutoRelayOptions };
}
type Libp2p = import("..");
type RelayAdvertiseOptions = {
bootDelay?: number | undefined;
enabled?: boolean | undefined;
ttl?: number | undefined;
};
type HopOptions = {
enabled?: boolean | undefined;
active?: boolean | undefined;
};
type AutoRelayOptions = {
/**
* - maximum number of relays to listen.
*/
maxListeners?: number | undefined;
enabled?: boolean | undefined;
};
//# sourceMappingURL=index.d.ts.map

1
dist/src/circuit/index.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/circuit/index.js"],"names":[],"mappings":";AAoBA;;;;;;;;;;;;;;;GAeG;AAEH;IACE;;;;;OAKG;IACH,oBAFW,MAAM,EAkBhB;IAfC,sBAAqB;IACrB,cAQC;IAGD,mCAA0G;IA8B5G;;;;OAIG;IACH,qBAFa,QAAQ,IAAI,CAAC,CAezB;IA3CD;;;;OAIG;IACH,SAFa,IAAI,CAWhB;IAJG,cAEC;IAIL;;;;OAIG;IACH,QAFa,IAAI,CAIhB;CAqBF"}

5
dist/src/circuit/listener.d.ts vendored Normal file
View File

@ -0,0 +1,5 @@
declare function _exports(libp2p: import('../')): Listener;
export = _exports;
export type Multiaddr = import("multiaddr");
export type Listener = import("libp2p-interfaces/src/transport/types").Listener;
//# sourceMappingURL=listener.d.ts.map

1
dist/src/circuit/listener.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"listener.d.ts","sourceRoot":"","sources":["../../../src/circuit/listener.js"],"names":[],"mappings":"AAciB,kCAHN,OAAO,KAAK,CAAC,GACX,QAAQ,CA+DpB"}

2
dist/src/circuit/multicodec.d.ts vendored Normal file
View File

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

1
dist/src/circuit/multicodec.d.ts.map vendored Normal file
View File

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

5
dist/src/circuit/protocol/index.d.ts vendored Normal file
View File

@ -0,0 +1,5 @@
declare const _exports: {
CircuitRelay: import('../../types').CircuitMessageProto;
};
export = _exports;
//# sourceMappingURL=index.d.ts.map

1
dist/src/circuit/protocol/index.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/circuit/protocol/index.js"],"names":[],"mappings":"wBAGW;IAAC,YAAY,EAAE,OAAO,aAAa,EAAE,mBAAmB,CAAA;CAAC"}

84
dist/src/circuit/transport.d.ts vendored Normal file
View File

@ -0,0 +1,84 @@
export = Circuit;
/**
* @typedef {import('multiaddr')} Multiaddr
* @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
* @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
* @typedef {import('../types').CircuitRequest} CircuitRequest
*/
declare class Circuit {
/**
* Checks if the given value is a Transport instance.
*
* @param {any} other
* @returns {other is Transport}
*/
static isTransport(other: any): other is Transport;
/**
* Creates an instance of the Circuit Transport.
*
* @class
* @param {object} options
* @param {import('../')} options.libp2p
* @param {import('../upgrader')} options.upgrader
*/
constructor({ libp2p, upgrader }: {
libp2p: import('../');
upgrader: import('../upgrader');
});
_dialer: import("../dialer");
_registrar: import("../registrar");
_connectionManager: import("../connection-manager");
_upgrader: import("../upgrader");
_options: any;
_libp2p: import("..");
peerId: import("peer-id");
/**
* @param {Object} props
* @param {Connection} props.connection
* @param {MuxedStream} props.stream
*/
_onProtocol({ connection, stream }: {
connection: Connection;
stream: MuxedStream;
}): Promise<void>;
/**
* Dial a peer over a relay
*
* @param {Multiaddr} ma - the multiaddr of the peer to dial
* @param {Object} options - dial options
* @param {AbortSignal} [options.signal] - An optional abort signal
* @returns {Promise<Connection>} - the connection
*/
dial(ma: Multiaddr, options: {
signal: AbortSignal | undefined;
}): Promise<Connection>;
/**
* Create a listener
*
* @param {any} options
* @param {Function} handler
* @returns {import('libp2p-interfaces/src/transport/types').Listener}
*/
createListener(options: any, handler: Function): import('libp2p-interfaces/src/transport/types').Listener;
handler: Function | undefined;
/**
* Filter check for all Multiaddrs that this transport can dial on
*
* @param {Multiaddr[]} multiaddrs
* @returns {Multiaddr[]}
*/
filter(multiaddrs: Multiaddr[]): Multiaddr[];
get [Symbol.toStringTag](): string;
}
declare namespace Circuit {
export { Multiaddr, Connection, MuxedStream, CircuitRequest };
}
type Connection = import("libp2p-interfaces/src/connection/connection");
type MuxedStream = import("libp2p-interfaces/src/stream-muxer/types").MuxedStream;
type Multiaddr = import("multiaddr");
type CircuitRequest = {
type: import("../types").CircuitType;
dstPeer: import("../types").CircuitPeer;
srcPeer: import("../types").CircuitPeer;
};
//# sourceMappingURL=transport.d.ts.map

1
dist/src/circuit/transport.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"transport.d.ts","sourceRoot":"","sources":["../../../src/circuit/transport.js"],"names":[],"mappings":";AAsBA;;;;;GAKG;AAEH;IAiLE;;;;;OAKG;IACH,0BAHW,GAAG,sBAKb;IAxLD;;;;;;;OAOG;IACH;QAHkC,MAAM,EAA7B,OAAO,KAAK,CAAC;QACkB,QAAQ,EAAvC,OAAO,aAAa,CAAC;OAY/B;IATC,6BAA4B;IAC5B,mCAAkC;IAClC,oDAAkD;IAClD,iCAAyB;IACzB,cAAoC;IACpC,sBAAqB;IACrB,0BAA2B;IAK7B;;;;OAIG;IACH;QAH6B,UAAU,EAA5B,UAAU;QACS,MAAM,EAAzB,WAAW;sBA2DrB;IAED;;;;;;;OAOG;IACH,SALW,SAAS;QAEa,MAAM;QAC1B,QAAQ,UAAU,CAAC,CA+C/B;IAED;;;;;;OAMG;IACH,wBAJW,GAAG,sBAED,OAAO,uCAAuC,EAAE,QAAQ,CAYpE;IAHC,8BAAsB;IAKxB;;;;;OAKG;IACH,mBAHW,SAAS,EAAE,GACT,SAAS,EAAE,CAQvB;IAED,mCAEC;CAWF"}

2
dist/src/circuit/utils.d.ts vendored Normal file
View File

@ -0,0 +1,2 @@
export function namespaceToCid(namespace: string): Promise<import("cids")>;
//# sourceMappingURL=utils.d.ts.map

1
dist/src/circuit/utils.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"utils.d.ts","sourceRoot":"","sources":["../../../src/circuit/utils.js"],"names":[],"mappings":"AAagC,0CAHrB,MAAM,GACJ,uBAAY,CAOxB"}

2
dist/src/config.d.ts vendored Normal file
View File

@ -0,0 +1,2 @@
export function validate(opts: any): any;
//# sourceMappingURL=config.d.ts.map

1
dist/src/config.d.ts.map vendored Normal file
View File

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

203
dist/src/connection-manager/index.d.ts vendored Normal file
View File

@ -0,0 +1,203 @@
/// <reference types="node" />
export = ConnectionManager;
declare const ConnectionManager_base: typeof import("events").EventEmitter;
/**
* @typedef {import('../')} Libp2p
* @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
*/
/**
* @typedef {Object} ConnectionManagerOptions
* @property {number} [maxConnections = Infinity] - The maximum number of connections allowed.
* @property {number} [minConnections = 0] - The minimum number of connections to avoid pruning.
* @property {number} [maxData = Infinity] - The max data (in and out), per average interval to allow.
* @property {number} [maxSentData = Infinity] - The max outgoing data, per average interval to allow.
* @property {number} [maxReceivedData = Infinity] - The max incoming data, per average interval to allow.
* @property {number} [maxEventLoopDelay = Infinity] - The upper limit the event loop can take to run.
* @property {number} [pollInterval = 2000] - How often, in milliseconds, metrics and latency should be checked.
* @property {number} [movingAverageInterval = 60000] - How often, in milliseconds, to compute averages.
* @property {number} [defaultPeerValue = 1] - The value of the peer.
* @property {boolean} [autoDial = true] - Should preemptively guarantee connections are above the low watermark.
* @property {number} [autoDialInterval = 10000] - How often, in milliseconds, it should preemptively guarantee connections are above the low watermark.
*/
/**
*
* @fires ConnectionManager#peer:connect Emitted when a new peer is connected.
* @fires ConnectionManager#peer:disconnect Emitted when a peer is disconnected.
*/
declare class ConnectionManager extends ConnectionManager_base {
/**
* Responsible for managing known connections.
*
* @class
* @param {Libp2p} libp2p
* @param {ConnectionManagerOptions} options
*/
constructor(libp2p: Libp2p, options?: ConnectionManagerOptions);
_libp2p: import("..");
_peerId: string;
_options: any;
/**
* Map of peer identifiers to their peer value for pruning connections.
*
* @type {Map<string, number>}
*/
_peerValues: Map<string, number>;
/**
* Map of connections per peer
*
* @type {Map<string, Connection[]>}
*/
connections: Map<string, Connection[]>;
_started: boolean;
_timer: any;
_autoDialTimeout: any;
/**
* Checks the libp2p metrics to determine if any values have exceeded
* the configured maximums.
*
* @private
*/
private _checkMetrics;
/**
* Proactively tries to connect to known peers stored in the PeerStore.
* It will keep the number of connections below the upper limit and sort
* the peers to connect based on wether we know their keys and protocols.
*
* @async
* @private
*/
private _autoDial;
/**
* Get current number of open connections.
*/
get size(): number;
/**
* Starts the Connection Manager. If Metrics are not enabled on libp2p
* only event loop and connection limits will be monitored.
*/
start(): void;
_latencyMonitor: import("./latency-monitor") | undefined;
/**
* If the event loop is slow, maybe close a connection
*
* @private
* @param {*} summary - The LatencyMonitor summary
*/
private _onLatencyMeasure;
/**
* Stops the Connection Manager
*
* @async
*/
stop(): Promise<void>;
/**
* Cleans up the connections
*
* @async
*/
_close(): Promise<void>;
/**
* Sets the value of the given peer. Peers with lower values
* will be disconnected first.
*
* @param {PeerId} peerId
* @param {number} value - A number between 0 and 1
* @returns {void}
*/
setPeerValue(peerId: import("peer-id"), value: number): void;
/**
* Tracks the incoming connection and check the connection limit
*
* @param {Connection} connection
* @returns {void}
*/
onConnect(connection: Connection): void;
/**
* Removes the connection from tracking
*
* @param {Connection} connection
* @returns {void}
*/
onDisconnect(connection: Connection): void;
/**
* Get a connection with a peer.
*
* @param {PeerId} peerId
* @returns {Connection|null}
*/
get(peerId: import("peer-id")): Connection | null;
/**
* Get all open connections with a peer.
*
* @param {PeerId} peerId
* @returns {Connection[]}
*/
getAll(peerId: import("peer-id")): Connection[];
/**
* If the `value` of `name` has exceeded its limit, maybe close a connection
*
* @private
* @param {string} name - The name of the field to check limits for
* @param {number} value - The current value of the field
*/
private _checkMaxLimit;
/**
* If we have more connections than our maximum, close a connection
* to the lowest valued peer.
*
* @private
*/
private _maybeDisconnectOne;
}
declare namespace ConnectionManager {
export { Libp2p, Connection, ConnectionManagerOptions };
}
type Connection = import("libp2p-interfaces/src/connection/connection");
type Libp2p = import("..");
type ConnectionManagerOptions = {
/**
* - The maximum number of connections allowed.
*/
maxConnections?: number | undefined;
/**
* - The minimum number of connections to avoid pruning.
*/
minConnections?: number | undefined;
/**
* - The max data (in and out), per average interval to allow.
*/
maxData?: number | undefined;
/**
* - The max outgoing data, per average interval to allow.
*/
maxSentData?: number | undefined;
/**
* - The max incoming data, per average interval to allow.
*/
maxReceivedData?: number | undefined;
/**
* - The upper limit the event loop can take to run.
*/
maxEventLoopDelay?: number | undefined;
/**
* - How often, in milliseconds, metrics and latency should be checked.
*/
pollInterval?: number | undefined;
/**
* - How often, in milliseconds, to compute averages.
*/
movingAverageInterval?: number | undefined;
/**
* - The value of the peer.
*/
defaultPeerValue?: number | undefined;
/**
* - Should preemptively guarantee connections are above the low watermark.
*/
autoDial?: boolean | undefined;
/**
* - How often, in milliseconds, it should preemptively guarantee connections are above the low watermark.
*/
autoDialInterval?: number | undefined;
};
//# sourceMappingURL=index.d.ts.map

1
dist/src/connection-manager/index.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection-manager/index.js"],"names":[],"mappings":";;;AAiCA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AAEH;;;;GAIG;AACH;IACE;;;;;;OAMG;IACH,oBAHW,MAAM,YACN,wBAAwB,EAkClC;IA7BC,sBAAqB;IACrB,gBAA0C;IAE1C,cAAqF;IAOrF;;;;OAIG;IACH,aAFU,IAAI,MAAM,EAAE,MAAM,CAAC,CAED;IAE5B;;;;OAIG;IACH,aAFU,IAAI,MAAM,EAAE,UAAU,EAAE,CAAC,CAEP;IAE5B,kBAAqB;IACrB,YAAkB;IAClB,sBAA4B;IAoF9B;;;;;OAKG;IACH,sBAYC;IA8GD;;;;;;;OAOG;IACH,kBAqCC;IA5PD;;OAEG;IACH,mBAGC;IAED;;;OAGG;IACH,cAiBC;IAXC,yDAGE;IAgKJ;;;;;OAKG;IACH,0BAEC;IA9JD;;;;OAIG;IACH,sBAQC;IAED;;;;OAIG;IACH,wBAWC;IAED;;;;;;;OAOG;IACH,+CAHW,MAAM,GACJ,IAAI,CAOhB;IAsBD;;;;;OAKG;IACH,sBAHW,UAAU,GACR,IAAI,CAqBhB;IAED;;;;;OAKG;IACH,yBAHW,UAAU,GACR,IAAI,CAchB;IAED;;;;;OAKG;IACH,gCAFa,UAAU,GAAC,IAAI,CAQ3B;IAED;;;;;OAKG;IACH,mCAFa,UAAU,EAAE,CAexB;IAYD;;;;;;OAMG;IACH,uBAOC;IAiDD;;;;;OAKG;IACH,4BAiBC;CACF"}

134
dist/src/connection-manager/latency-monitor.d.ts vendored Normal file
View File

@ -0,0 +1,134 @@
/// <reference types="node" />
export = LatencyMonitor;
declare const LatencyMonitor_base: typeof import("events").EventEmitter;
/**
* @typedef {Object} SummaryObject
* @property {number} events How many events were called
* @property {number} minMS What was the min time for a cb to be called
* @property {number} maxMS What was the max time for a cb to be called
* @property {number} avgMs What was the average time for a cb to be called
* @property {number} lengthMs How long this interval was in ms
*
* @typedef {Object} LatencyMonitorOptions
* @property {number} [latencyCheckIntervalMs=500] - How often to add a latency check event (ms)
* @property {number} [dataEmitIntervalMs=5000] - How often to summarize latency check events. null or 0 disables event firing
* @property {Function} [asyncTestFn] - What cb-style async function to use
* @property {number} [latencyRandomPercentage=5] - What percent (+/-) of latencyCheckIntervalMs should we randomly use? This helps avoid alignment to other events.
*/
/**
* A class to monitor latency of any async function which works in a browser or node. This works by periodically calling
* the asyncTestFn and timing how long it takes the callback to be called. It can also periodically emit stats about this.
* This can be disabled and stats can be pulled via setting dataEmitIntervalMs = 0.
*
* @extends {EventEmitter}
*
* The default implementation is an event loop latency monitor. This works by firing periodic events into the event loop
* and timing how long it takes to get back.
*
* @example
* const monitor = new LatencyMonitor();
* monitor.on('data', (summary) => console.log('Event Loop Latency: %O', summary));
*
* @example
* const monitor = new LatencyMonitor({latencyCheckIntervalMs: 1000, dataEmitIntervalMs: 60000, asyncTestFn:ping});
* monitor.on('data', (summary) => console.log('Ping Pong Latency: %O', summary));
*/
declare class LatencyMonitor extends LatencyMonitor_base {
/**
* @class
* @param {LatencyMonitorOptions} [options]
*/
constructor({ latencyCheckIntervalMs, dataEmitIntervalMs, asyncTestFn, latencyRandomPercentage }?: LatencyMonitorOptions | undefined);
/**
* Start internal timers
*
* @private
*/
private _startTimers;
_emitIntervalID: NodeJS.Timeout | undefined;
/**
* Stop internal timers
*
* @private
*/
private _stopTimers;
_checkLatencyID: NodeJS.Timeout | undefined;
/**
* Emit summary only if there were events. It might not have any events if it was forced via a page hidden/show
*
* @private
*/
private _emitSummary;
/**
* Calling this function will end the collection period. If a timing event was already fired and somewhere in the queue,
* it will not count for this time period
*
* @returns {SummaryObject}
*/
getSummary(): SummaryObject;
_latencyData: {
startTime: any;
minMs: number;
maxMs: number;
events: number;
totalMs: number;
} | undefined;
/**
* Randomly calls an async fn every roughly latencyCheckIntervalMs (plus some randomness). If no async fn is found,
* it will simply report on event loop latency.
*
* @private
*/
private _checkLatency;
_initLatencyData(): {
startTime: any;
minMs: number;
maxMs: number;
events: number;
totalMs: number;
};
}
declare namespace LatencyMonitor {
export { SummaryObject, LatencyMonitorOptions };
}
type SummaryObject = {
/**
* How many events were called
*/
events: number;
/**
* What was the min time for a cb to be called
*/
minMS: number;
/**
* What was the max time for a cb to be called
*/
maxMS: number;
/**
* What was the average time for a cb to be called
*/
avgMs: number;
/**
* How long this interval was in ms
*/
lengthMs: number;
};
type LatencyMonitorOptions = {
/**
* - How often to add a latency check event (ms)
*/
latencyCheckIntervalMs?: number | undefined;
/**
* - How often to summarize latency check events. null or 0 disables event firing
*/
dataEmitIntervalMs?: number | undefined;
/**
* - What cb-style async function to use
*/
asyncTestFn?: Function | undefined;
/**
* - What percent (+/-) of latencyCheckIntervalMs should we randomly use? This helps avoid alignment to other events.
*/
latencyRandomPercentage?: number | undefined;
};
//# sourceMappingURL=latency-monitor.d.ts.map

1
dist/src/connection-manager/latency-monitor.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"latency-monitor.d.ts","sourceRoot":"","sources":["../../../src/connection-manager/latency-monitor.js"],"names":[],"mappings":";;;AAaA;;;;;;;;;;;;;GAaG;AAEH;;;;;;;;;;;;;;;;;GAiBG;AACH;IACE;;;OAGG;IACH,sIA8DC;IAED;;;;OAIG;IACH,qBAYC;IALG,4CAAsF;IAO1F;;;;OAIG;IACH,oBASC;IANG,4CAAgC;IAQpC;;;;OAIG;IACH,qBAKC;IAED;;;;;OAKG;IACH,cAFa,aAAa,CAkBzB;IAJC;;;;;;kBAA2C;IAM7C;;;;;OAKG;IACH,sBAgDC;IAED;;;;;;MAQC;CACF;;;;;;;;YA5Oa,MAAM;;;;WACN,MAAM;;;;WACN,MAAM;;;;WACN,MAAM;;;;cACN,MAAM"}

62
dist/src/connection-manager/visibility-change-emitter.d.ts vendored Normal file
View File

@ -0,0 +1,62 @@
/// <reference types="node" />
export = VisibilityChangeEmitter;
declare const VisibilityChangeEmitter_base: typeof import("events").EventEmitter;
/**
* Listen to page visibility change events (i.e. when the page is focused / blurred) by an event emitter.
*
* Warning: This does not work on all browsers, but should work on all modern browsers
*
* @example
*
* const myVisibilityEmitter = new VisibilityChangeEmitter();
*
* myVisibilityEmitter.on('visibilityChange', (pageInFocus) => {
* if ( pageInFocus ){
* // Page is in focus
* console.log('In focus');
* }
* else {
* // Page is blurred
* console.log('Out of focus');
* }
* });
* // To access the visibility state directly, call:
* console.log('Am I focused now? ' + myVisibilityEmitter.isVisible());
*/
declare class VisibilityChangeEmitter extends VisibilityChangeEmitter_base {
/**
* document.hidden and document.visibilityChange are the two variables we need to check for;
* Since these variables are named differently in different browsers, this function sets
* the appropriate name based on the browser being used. Once executed, tha actual names of
* document.hidden and document.visibilityChange are found in this._hidden and this._visibilityChange
* respectively
*
* @private
*/
private _initializeVisibilityVarNames;
_hidden: string | undefined;
_visibilityChange: string | undefined;
/**
* Adds an event listener on the document that listens to changes in document.visibilityChange
* (or whatever name by which the visibilityChange variable is known in the browser)
*
* @private
*/
private _addVisibilityChangeListener;
/**
* The function returns ```true``` if the page is visible or ```false``` if the page is not visible and
* ```undefined``` if the page visibility API is not supported by the browser.
*
* @returns {boolean | void} whether the page is now visible or not (undefined is unknown)
*/
isVisible(): boolean | void;
/**
* The function that is called when document.visibilityChange has changed
* It emits an event called visibilityChange and sends the value of document.hidden as a
* parameter
*
* @private
*/
private _handleVisibilityChange;
}
//# sourceMappingURL=visibility-change-emitter.d.ts.map

1
dist/src/connection-manager/visibility-change-emitter.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"visibility-change-emitter.d.ts","sourceRoot":"","sources":["../../../src/connection-manager/visibility-change-emitter.js"],"names":[],"mappings":";;;AAYA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IAgBE;;;;;;;;OAQG;IACH,sCAkBC;IAFC,4BAAqB;IACrB,sCAAyC;IAG3C;;;;;OAKG;IACH,qCAQC;IAED;;;;;OAKG;IACH,aAFa,OAAO,GAAG,IAAI,CAQ1B;IAED;;;;;;OAMG;IACH,gCAKC;CACF"}

10
dist/src/constants.d.ts vendored Normal file
View File

@ -0,0 +1,10 @@
export const DIAL_TIMEOUT: number;
export const MAX_PARALLEL_DIALS: number;
export const MAX_PER_PEER_DIALS: number;
export namespace METRICS {
const computeThrottleMaxQueueSize: number;
const computeThrottleTimeout: number;
const movingAverageIntervals: number[];
const maxOldPeersRetention: number;
}
//# sourceMappingURL=constants.d.ts.map

1
dist/src/constants.d.ts.map vendored Normal file
View File

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

93
dist/src/content-routing.d.ts vendored Normal file
View File

@ -0,0 +1,93 @@
export = ContentRouting;
/**
* @typedef {import('peer-id')} PeerId
* @typedef {import('multiaddr')} Multiaddr
* @typedef {import('cids')} CID
*/
/**
* @typedef {Object} GetData
* @property {PeerId} from
* @property {Uint8Array} val
*/
declare class ContentRouting {
/**
* @class
* @param {import('./')} libp2p
*/
constructor(libp2p: import('./'));
libp2p: import(".");
routers: any;
dht: any;
/**
* Iterates over all content routers in series to find providers of the given key.
* Once a content router succeeds, iteration will stop.
*
* @param {CID} key - The CID key of the content to find
* @param {object} [options]
* @param {number} [options.timeout] - How long the query should run
* @param {number} [options.maxNumProviders] - maximum number of providers to find
* @returns {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>}
*/
findProviders(key: CID, options?: {
timeout?: number | undefined;
maxNumProviders?: number | undefined;
} | undefined): AsyncIterable<{
id: PeerId;
multiaddrs: Multiaddr[];
}>;
/**
* Iterates over all content routers in parallel to notify it is
* a provider of the given key.
*
* @param {CID} key - The CID key of the content to find
* @returns {Promise<void>}
*/
provide(key: CID): Promise<void>;
/**
* Store the given key/value pair in the DHT.
*
* @param {Uint8Array} key
* @param {Uint8Array} value
* @param {Object} [options] - put options
* @param {number} [options.minPeers] - minimum number of peers required to successfully put
* @returns {Promise<void>}
*/
put(key: Uint8Array, value: Uint8Array, options?: {
minPeers?: number | undefined;
} | undefined): Promise<void>;
/**
* Get the value to the given key.
* Times out after 1 minute by default.
*
* @param {Uint8Array} key
* @param {Object} [options] - get options
* @param {number} [options.timeout] - optional timeout (default: 60000)
* @returns {Promise<GetData>}
*/
get(key: Uint8Array, options?: {
timeout?: number | undefined;
} | undefined): Promise<GetData>;
/**
* Get the `n` values to the given key without sorting.
*
* @param {Uint8Array} key
* @param {number} nVals
* @param {Object} [options] - get options
* @param {number} [options.timeout] - optional timeout (default: 60000)
* @returns {Promise<GetData[]>}
*/
getMany(key: Uint8Array, nVals: number, options?: {
timeout?: number | undefined;
} | undefined): Promise<GetData[]>;
}
declare namespace ContentRouting {
export { PeerId, Multiaddr, CID, GetData };
}
type CID = import("cids");
type PeerId = import("peer-id");
type Multiaddr = import("multiaddr");
type GetData = {
from: PeerId;
val: Uint8Array;
};
//# sourceMappingURL=content-routing.d.ts.map

1
dist/src/content-routing.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"content-routing.d.ts","sourceRoot":"","sources":["../../src/content-routing.js"],"names":[],"mappings":";AAQA;;;;GAIG;AAEH;;;;GAIG;AAEH;IACE;;;OAGG;IACH,oBAFW,OAAO,IAAI,CAAC,EAWtB;IARC,oBAAoB;IACpB,aAAmD;IACnD,SAAsB;IAQxB;;;;;;;;;OASG;IACH,mBANW,GAAG;;;oBAID,cAAc;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,SAAS,EAAE,CAAA;KAAE,CAAC,CAqBlE;IAED;;;;;;OAMG;IACH,aAHW,GAAG,GACD,QAAQ,IAAI,CAAC,CAQzB;IAED;;;;;;;;OAQG;IACH,SANW,UAAU,SACV,UAAU;;oBAGR,QAAQ,IAAI,CAAC,CAQzB;IAED;;;;;;;;OAQG;IACH,SALW,UAAU;;oBAGR,QAAQ,OAAO,CAAC,CAQ5B;IAED;;;;;;;;OAQG;IACH,aANW,UAAU,SACV,MAAM;;oBAGJ,QAAQ,OAAO,EAAE,CAAC,CAQ9B;CACF;;;;;;;;UApHa,MAAM;SACN,UAAU"}

55
dist/src/dialer/dial-request.d.ts vendored Normal file
View File

@ -0,0 +1,55 @@
export = DialRequest;
/**
* @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
* @typedef {import('./')} Dialer
* @typedef {import('multiaddr')} Multiaddr
*/
/**
* @typedef {Object} DialOptions
* @property {AbortSignal} signal
*
* @typedef {Object} DialRequestOptions
* @property {Multiaddr[]} addrs
* @property {(m: Multiaddr, options: DialOptions) => Promise<Connection>} dialAction
* @property {Dialer} dialer
*/
declare class DialRequest {
/**
* Manages running the `dialAction` on multiple provided `addrs` in parallel
* up to a maximum determined by the number of tokens returned
* from `dialer.getTokens`. Once a DialRequest is created, it can be
* started using `DialRequest.run(options)`. Once a single dial has succeeded,
* all other dials in the request will be cancelled.
*
* @class
* @param {DialRequestOptions} options
*/
constructor({ addrs, dialAction, dialer }: DialRequestOptions);
addrs: import("multiaddr")[];
dialer: import(".");
dialAction: (m: Multiaddr, options: DialOptions) => Promise<Connection>;
/**
* @async
* @param {object} [options]
* @param {AbortSignal} [options.signal] - An AbortController signal
* @returns {Promise<Connection>}
*/
run(options?: {
signal?: AbortSignal | undefined;
} | undefined): Promise<Connection>;
}
declare namespace DialRequest {
export { Connection, Dialer, Multiaddr, DialOptions, DialRequestOptions };
}
type Multiaddr = import("multiaddr");
type DialOptions = {
signal: AbortSignal;
};
type Connection = import("libp2p-interfaces/src/connection/connection");
type DialRequestOptions = {
addrs: Multiaddr[];
dialAction: (m: Multiaddr, options: DialOptions) => Promise<Connection>;
dialer: Dialer;
};
type Dialer = import(".");
//# sourceMappingURL=dial-request.d.ts.map

1
dist/src/dialer/dial-request.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"dial-request.d.ts","sourceRoot":"","sources":["../../../src/dialer/dial-request.js"],"names":[],"mappings":";AAQA;;;;GAIG;AAEH;;;;;;;;GAQG;AAEH;IACE;;;;;;;;;OASG;IACH,2CAFW,kBAAkB,EAU5B;IAHC,6BAAkB;IAClB,oBAAoB;IACpB,gBAtBc,SAAS,WAAW,WAAW,KAAK,QAAQ,UAAU,CAAC,CAsBzC;IAG9B;;;;;OAKG;IACH;;oBAFa,QAAQ,UAAU,CAAC,CAuC/B;CACF;;;;;;YAzEa,WAAW;;;;WAGX,SAAS,EAAE;oBACP,SAAS,WAAW,WAAW,KAAK,QAAQ,UAAU,CAAC;YAC3D,MAAM"}

157
dist/src/dialer/index.d.ts vendored Normal file
View File

@ -0,0 +1,157 @@
export = Dialer;
/**
* @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
* @typedef {import('multiaddr')} Multiaddr
* @typedef {import('peer-id')} PeerId
* @typedef {import('../peer-store')} PeerStore
* @typedef {import('../peer-store/address-book').Address} Address
* @typedef {import('../transport-manager')} TransportManager
*/
/**
* @typedef {Object} DialerProperties
* @property {PeerStore} peerStore
* @property {TransportManager} transportManager
*
* @typedef {(addr:Multiaddr) => Promise<string[]>} Resolver
*
* @typedef {Object} DialerOptions
* @property {(addresses: Address[]) => Address[]} [options.addressSorter = publicAddressesFirst] - Sort the known addresses of a peer before trying to dial.
* @property {number} [concurrency = MAX_PARALLEL_DIALS] - Number of max concurrent dials.
* @property {number} [perPeerLimit = MAX_PER_PEER_DIALS] - Number of max concurrent dials per peer.
* @property {number} [timeout = DIAL_TIMEOUT] - How long a dial attempt is allowed to take.
* @property {Record<string, Resolver>} [resolvers = {}] - multiaddr resolvers to use when dialing
*
* @typedef DialTarget
* @property {string} id
* @property {Multiaddr[]} addrs
*
* @typedef PendingDial
* @property {DialRequest} dialRequest
* @property {TimeoutController} controller
* @property {Promise} promise
* @property {function():void} destroy
*/
declare class Dialer {
/**
* @class
* @param {DialerProperties & DialerOptions} options
*/
constructor({ transportManager, peerStore, addressSorter, concurrency, timeout, perPeerLimit, resolvers }: DialerProperties & DialerOptions);
transportManager: import("../transport-manager");
peerStore: import("../peer-store");
addressSorter: (addresses: Address[]) => Address[];
concurrency: number;
timeout: number;
perPeerLimit: number;
tokens: number[];
_pendingDials: Map<any, any>;
/**
* Clears any pending dials
*/
destroy(): void;
/**
* Connects to a given `peer` by dialing all of its known addresses.
* The dial to the first address that is successfully able to upgrade a connection
* will be used.
*
* @param {PeerId|Multiaddr|string} peer - The peer to dial
* @param {object} [options]
* @param {AbortSignal} [options.signal] - An AbortController signal
* @returns {Promise<Connection>}
*/
connectToPeer(peer: PeerId | Multiaddr | string, options?: {
signal?: AbortSignal | undefined;
} | undefined): Promise<Connection>;
/**
* Creates a DialTarget. The DialTarget is used to create and track
* the DialRequest to a given peer.
* If a multiaddr is received it should be the first address attempted.
*
* @private
* @param {PeerId|Multiaddr|string} peer - A PeerId or Multiaddr
* @returns {Promise<DialTarget>}
*/
private _createDialTarget;
/**
* Creates a PendingDial that wraps the underlying DialRequest
*
* @private
* @param {DialTarget} dialTarget
* @param {object} [options]
* @param {AbortSignal} [options.signal] - An AbortController signal
* @returns {PendingDial}
*/
private _createPendingDial;
getTokens(num: any): number[];
releaseToken(token: any): void;
/**
* Resolve multiaddr recursively.
*
* @param {Multiaddr} ma
* @returns {Promise<Multiaddr[]>}
*/
_resolve(ma: Multiaddr): Promise<Multiaddr[]>;
/**
* Resolve a given multiaddr. If this fails, an empty array will be returned
*
* @param {Multiaddr} ma
* @returns {Promise<Multiaddr[]>}
*/
_resolveRecord(ma: Multiaddr): Promise<Multiaddr[]>;
}
declare namespace Dialer {
export { Connection, Multiaddr, PeerId, PeerStore, Address, TransportManager, DialerProperties, Resolver, DialerOptions, DialTarget, PendingDial };
}
type Address = {
/**
* peer multiaddr.
*/
multiaddr: import("multiaddr");
/**
* obtained from a signed peer record.
*/
isCertified: boolean;
};
type PeerId = import("peer-id");
type Multiaddr = import("multiaddr");
type Connection = import("libp2p-interfaces/src/connection/connection");
type DialerProperties = {
peerStore: PeerStore;
transportManager: TransportManager;
};
type DialerOptions = {
/**
* - Sort the known addresses of a peer before trying to dial.
*/
addressSorter?: ((addresses: Address[]) => Address[]) | undefined;
/**
* - Number of max concurrent dials.
*/
concurrency?: number | undefined;
/**
* - Number of max concurrent dials per peer.
*/
perPeerLimit?: number | undefined;
/**
* - How long a dial attempt is allowed to take.
*/
timeout?: number | undefined;
/**
* - multiaddr resolvers to use when dialing
*/
resolvers?: Record<string, (addr: Multiaddr) => Promise<string[]>> | undefined;
};
type PeerStore = import("../peer-store");
type TransportManager = import("../transport-manager");
type Resolver = (addr: Multiaddr) => Promise<string[]>;
type DialTarget = {
id: string;
addrs: Multiaddr[];
};
type PendingDial = {
dialRequest: import("./dial-request");
controller: any;
promise: Promise<any>;
destroy: () => void;
};
//# sourceMappingURL=index.d.ts.map

1
dist/src/dialer/index.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/dialer/index.js"],"names":[],"mappings":";AAsBA;;;;;;;GAOG;AAEH;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;IACE;;;OAGG;IACH,2GAFW,gBAAgB,GAAG,aAAa,EAuB1C;IAZC,iDAAwC;IACxC,mCAA0B;IAC1B,2BAjCsB,OAAO,EAAE,KAAK,OAAO,EAAE,CAiCX;IAClC,oBAA8B;IAC9B,gBAAsB;IACtB,qBAAgC;IAChC,iBAAkE;IAClE,6BAA8B;IAOhC;;OAEG;IACH,gBASC;IAED;;;;;;;;;OASG;IACH,oBALW,MAAM,GAAC,SAAS,GAAC,MAAM;;oBAGrB,QAAQ,UAAU,CAAC,CAwB/B;IAED;;;;;;;;OAQG;IACH,0BA0BC;IAED;;;;;;;;OAQG;IACH,2BA6BC;IAED,8BAKC;IAED,+BAKC;IAED;;;;;OAKG;IACH,aAHW,SAAS,GACP,QAAQ,SAAS,EAAE,CAAC,CAwBhC;IAED;;;;;OAKG;IACH,mBAHW,SAAS,GACP,QAAQ,SAAS,EAAE,CAAC,CAWhC;CACF;;;;;;;;;;;;;;;;;;eA5Oa,SAAS;sBACT,gBAAgB;;;;;;iCAKJ,OAAO,EAAE,KAAK,OAAO,EAAE;;;;;;;;;;;;;;;;sCAH9B,SAAS,KAAK,QAAQ,MAAM,EAAE,CAAC;;;;uBAA/B,SAAS,KAAK,QAAQ,MAAM,EAAE,CAAC;;QAUpC,MAAM;WACN,SAAS,EAAE;;;;;;mBAMA,IAAI"}

34
dist/src/errors.d.ts vendored Normal file
View File

@ -0,0 +1,34 @@
export namespace messages {
const NOT_STARTED_YET: string;
const DHT_DISABLED: string;
const CONN_ENCRYPTION_REQUIRED: string;
}
export namespace codes {
const DHT_DISABLED_1: string;
export { DHT_DISABLED_1 as DHT_DISABLED };
export const PUBSUB_NOT_STARTED: string;
export const DHT_NOT_STARTED: string;
const CONN_ENCRYPTION_REQUIRED_1: string;
export { CONN_ENCRYPTION_REQUIRED_1 as CONN_ENCRYPTION_REQUIRED };
export const ERR_CONNECTION_ENDED: string;
export const ERR_CONNECTION_FAILED: string;
export const ERR_NODE_NOT_STARTED: string;
export const ERR_ALREADY_ABORTED: string;
export const ERR_NO_VALID_ADDRESSES: string;
export const ERR_DISCOVERED_SELF: string;
export const ERR_DUPLICATE_TRANSPORT: string;
export const ERR_ENCRYPTION_FAILED: string;
export const ERR_HOP_REQUEST_FAILED: string;
export const ERR_INVALID_KEY: string;
export const ERR_INVALID_MESSAGE: string;
export const ERR_INVALID_PARAMETERS: string;
export const ERR_INVALID_PEER: string;
export const ERR_MUXER_UNAVAILABLE: string;
export const ERR_TIMEOUT: string;
export const ERR_TRANSPORT_UNAVAILABLE: string;
export const ERR_TRANSPORT_DIAL_FAILED: string;
export const ERR_UNSUPPORTED_PROTOCOL: string;
export const ERR_INVALID_MULTIADDR: string;
export const ERR_SIGNATURE_NOT_VALID: string;
}
//# sourceMappingURL=errors.d.ts.map

1
dist/src/errors.d.ts.map vendored Normal file
View File

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

20
dist/src/get-peer.d.ts vendored Normal file
View File

@ -0,0 +1,20 @@
export = getPeer;
/**
* @typedef {import('multiaddr')} Multiaddr
*/
/**
* Converts the given `peer` to a `Peer` object.
* If a multiaddr is received, the addressBook is updated.
*
* @param {PeerId|Multiaddr|string} peer
* @returns {{ id: PeerId, multiaddrs: Multiaddr[]|undefined }}
*/
declare function getPeer(peer: import("peer-id") | Multiaddr | string): {
id: import("peer-id");
multiaddrs: Multiaddr[] | undefined;
};
declare namespace getPeer {
export { Multiaddr };
}
type Multiaddr = import("multiaddr");
//# sourceMappingURL=get-peer.d.ts.map

1
dist/src/get-peer.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"get-peer.d.ts","sourceRoot":"","sources":["../../src/get-peer.js"],"names":[],"mappings":";AAQA;;GAEG;AAEH;;;;;;GAMG;AACH,+BAHW,oBAAO,SAAS,GAAC,MAAM,GACrB;IAAE,EAAE,oBAAS;IAAC,UAAU,EAAE,SAAS,EAAE,GAAC,SAAS,CAAA;CAAE,CAwB7D"}

5
dist/src/identify/consts.d.ts vendored Normal file
View File

@ -0,0 +1,5 @@
export var PROTOCOL_VERSION: string;
export var AGENT_VERSION: string;
export var MULTICODEC_IDENTIFY: string;
export var MULTICODEC_IDENTIFY_PUSH: string;
//# sourceMappingURL=consts.d.ts.map

1
dist/src/identify/consts.d.ts.map vendored Normal file
View File

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

97
dist/src/identify/index.d.ts vendored Normal file
View File

@ -0,0 +1,97 @@
export = IdentifyService;
/**
* @typedef {import('libp2p-interfaces/src/connection').Connection} Connection
* @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxedStream} MuxedStream
*/
declare class IdentifyService {
/**
* Takes the `addr` and converts it to a Multiaddr if possible
*
* @param {Uint8Array | string} addr
* @returns {multiaddr|null}
*/
static getCleanMultiaddr(addr: Uint8Array | string): import("multiaddr") | null;
/**
* @class
* @param {Object} options
* @param {import('../')} options.libp2p
*/
constructor({ libp2p }: {
libp2p: import('../');
});
_libp2p: import("..");
peerStore: import("../peer-store");
connectionManager: import("../connection-manager");
peerId: import("peer-id");
/**
* A handler to register with Libp2p to process identify messages.
*
* @param {Object} options
* @param {Connection} options.connection
* @param {MuxedStream} options.stream
* @param {string} options.protocol
* @returns {Promise<void>|undefined}
*/
handleMessage({ connection, stream, protocol }: {
connection: Connection;
stream: MuxedStream;
protocol: string;
}): Promise<void> | undefined;
/**
* Send an Identify Push update to the list of connections
*
* @param {Connection[]} connections
* @returns {Promise<void[]>}
*/
push(connections: Connection[]): Promise<void[]>;
/**
* Calls `push` for all peers in the `peerStore` that are connected
*
* @returns {void}
*/
pushToPeerStore(): 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,
* an error will be thrown.
*
* @async
* @param {Connection} connection
* @returns {Promise<void>}
*/
identify(connection: Connection): Promise<void>;
/**
* Sends the `Identify` response with the Signed Peer Record
* to the requesting peer over the given `connection`
*
* @private
* @param {Object} options
* @param {MuxedStream} options.stream
* @param {Connection} options.connection
* @returns {Promise<void>}
*/
private _handleIdentify;
/**
* Reads the Identify Push message from the given `connection`
*
* @private
* @param {object} options
* @param {MuxedStream} options.stream
* @param {Connection} options.connection
* @returns {Promise<void>}
*/
private _handlePush;
}
declare namespace IdentifyService {
export { multicodecs, Message as Messsage, Connection, MuxedStream };
}
type Connection = import("libp2p-interfaces/src/connection/connection");
type MuxedStream = import("libp2p-interfaces/src/stream-muxer/types").MuxedStream;
declare namespace multicodecs {
export { MULTICODEC_IDENTIFY as IDENTIFY };
export { MULTICODEC_IDENTIFY_PUSH as IDENTIFY_PUSH };
}
declare const Message: any;
declare const MULTICODEC_IDENTIFY: string;
declare const MULTICODEC_IDENTIFY_PUSH: string;
//# sourceMappingURL=index.d.ts.map

1
dist/src/identify/index.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/identify/index.js"],"names":[],"mappings":";AA+BA;;;GAGG;AAEH;IA+QE;;;;;OAKG;IACH,+BAHW,UAAU,GAAG,MAAM,GACjB,sBAAU,IAAI,CAW1B;IA7RD;;;;OAIG;IACH;QAFkC,MAAM,EAA7B,OAAO,KAAK,CAAC;OA4BvB;IAzBC,sBAAqB;IACrB,mCAAiC;IACjC,mDAAiD;IACjD,0BAA2B;IAwJ7B;;;;;;;;OAQG;IACH;QAL+B,UAAU,EAA9B,UAAU;QACW,MAAM,EAA3B,WAAW;QACK,QAAQ,EAAxB,MAAM;QACJ,QAAQ,IAAI,CAAC,GAAC,SAAS,CAWnC;IAlJD;;;;;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,CA+DzB;IAsBD;;;;;;;;;OASG;IACH,wBA6BC;IAED;;;;;;;;OAQG;IACH,oBAqCC;CAkBF;;;;;;;;;;AAlTD,2BAAoC"}

3
dist/src/identify/message.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
declare const _exports: any;
export = _exports;
//# sourceMappingURL=message.d.ts.map

1
dist/src/identify/message.d.ts.map vendored Normal file
View File

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

288
dist/src/index.d.ts vendored Normal file
View File

@ -0,0 +1,288 @@
/// <reference types="node" />
export = Libp2p;
declare const Libp2p_base: typeof import("events").EventEmitter;
/**
* @typedef {import('multiaddr')} Multiaddr
* @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} TransportFactory
* @typedef {import('libp2p-interfaces/src/stream-muxer/types').MuxerFactory} MuxerFactory
* @typedef {import('libp2p-interfaces/src/crypto/types').Crypto} Crypto
* @typedef {import('libp2p-interfaces/src/pubsub')} Pubsub
*/
/**
* @typedef {Object} PeerStoreOptions
* @property {boolean} persistence
*
* @typedef {Object} PeerDiscoveryOptions
* @property {boolean} autoDial
*
* @typedef {Object} RelayOptions
* @property {boolean} enabled
* @property {import('./circuit').RelayAdvertiseOptions} advertise
* @property {import('./circuit').HopOptions} hop
* @property {import('./circuit').AutoRelayOptions} autoRelay
*
* @typedef {Object} Libp2pConfig
* @property {Object} [dht] dht module options
* @property {PeerDiscoveryOptions} [peerDiscovery]
* @property {Pubsub} [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
*
* @typedef {Object} Libp2pOptions
* @property {Libp2pModules} modules libp2p modules to use
* @property {import('./address-manager').AddressManagerOptions} [addresses]
* @property {import('./connection-manager').ConnectionManagerOptions} [connectionManager]
* @property {import('./dialer').DialerOptions} [dialer]
* @property {import('./metrics').MetricsOptions} [metrics]
* @property {Object} [keychain]
* @property {import('./transport-manager').TransportManagerOptions} [transportManager]
* @property {PeerStoreOptions & import('./peer-store/persistent').PersistentPeerStoreOptions} [peerStore]
* @property {Libp2pConfig} [config]
* @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
*/
declare class Libp2p extends Libp2p_base {
/**
* Like `new Libp2p(options)` except it will create a `PeerId`
* instance if one is not provided in options.
*
* @param {Libp2pOptions & CreateOptions} options - Libp2p configuration options
* @returns {Promise<Libp2p>}
*/
static create(options: Libp2pOptions & CreateOptions): Promise<Libp2p>;
/**
* Libp2p node.
*
* @class
* @param {Libp2pOptions} _options
*/
constructor(_options: Libp2pOptions);
_options: any;
/** @type {PeerId} */
peerId: import("peer-id");
datastore: any;
peerStore: import("./peer-store");
addresses: any;
addressManager: import("./address-manager");
_modules: any;
_config: any;
_transport: any[];
_discovery: Map<any, any>;
connectionManager: import("./connection-manager");
metrics: import("./metrics") | undefined;
keychain: import("./keychain") | undefined;
upgrader: import("./upgrader");
transportManager: import("./transport-manager");
registrar: import("./registrar");
/**
* Registers the `handler` for each protocol
*
* @param {string[]|string} protocols
* @param {({ connection: Connection, stream: MuxedStream, protocol: string }) => void} handler
*/
handle(protocols: string[] | string, handler: ({ connection: Connection, stream: MuxedStream, protocol: string }: {
connection: any;
stream: any;
protocol: any;
}) => void): void;
dialer: import("./dialer");
relay: import("./circuit") | undefined;
identifyService: import("./identify") | undefined;
_dht: any;
/** @type {Pubsub} */
pubsub: import("libp2p-interfaces/src/pubsub");
peerRouting: import("./peer-routing");
contentRouting: import("./content-routing");
/**
* Called whenever peer discovery services emit `peer` events.
* Known peers may be emitted.
*
* @private
* @param {{ id: PeerId, multiaddrs: Multiaddr[], protocols: string[] }} peer
*/
private _onDiscoveryPeer;
/**
* Starts the libp2p node and all its subsystems
*
* @returns {Promise<void>}
*/
start(): Promise<void>;
/**
* Stop the libp2p node by closing its listeners and open connections
*
* @async
* @returns {Promise<void>}
*/
stop(): Promise<void>;
_isStarted: boolean | undefined;
/**
* Load keychain keys from the datastore.
* Imports the private key as 'self', if needed.
*
* @async
* @returns {Promise<void>}
*/
loadKeychain(): Promise<void>;
isStarted(): boolean | undefined;
/**
* Gets a Map of the current connections. The keys are the stringified
* `PeerId` of the peer. The value is an array of Connections to that peer.
*
* @returns {Map<string, Connection[]>}
*/
get connections(): Map<string, import("libp2p-interfaces/src/connection/connection")[]>;
/**
* Dials to the provided peer. If successful, the known metadata of the
* peer will be added to the nodes `peerStore`
*
* @param {PeerId|Multiaddr|string} peer - The peer to dial
* @param {object} [options]
* @param {AbortSignal} [options.signal]
* @returns {Promise<Connection>}
*/
dial(peer: import("peer-id") | Multiaddr | string, options?: {
signal?: AbortSignal | undefined;
} | undefined): Promise<Connection>;
/**
* Dials to the provided peer and handshakes with the given protocol.
* If successful, the known metadata of the peer will be added to the nodes `peerStore`,
* and the `Connection` will be returned
*
* @async
* @param {PeerId|Multiaddr|string} peer - The peer to dial
* @param {string[]|string} protocols
* @param {object} [options]
* @param {AbortSignal} [options.signal]
* @returns {Promise<Connection|*>}
*/
dialProtocol(peer: import("peer-id") | Multiaddr | string, protocols: string[] | string, options?: {
signal?: AbortSignal | undefined;
} | undefined): Promise<Connection | any>;
/**
* Get peer advertising multiaddrs by concating the addresses used
* by transports to listen with the announce addresses.
* Duplicated addresses and noAnnounce addresses are filtered out.
*
* @returns {Multiaddr[]}
*/
get multiaddrs(): import("multiaddr")[];
/**
* Disconnects all connections to the given `peer`
*
* @param {PeerId|Multiaddr|string} peer - the peer to close connections to
* @returns {Promise<void>}
*/
hangUp(peer: import("peer-id") | Multiaddr | string): Promise<void>;
/**
* Pings the given peer in order to obtain the operation latency.
*
* @param {PeerId|Multiaddr|string} peer - The peer to ping
* @returns {Promise<number>}
*/
ping(peer: import("peer-id") | Multiaddr | string): Promise<number>;
/**
* Removes the handler for each protocol. The protocol
* will no longer be supported on streams.
*
* @param {string[]|string} protocols
*/
unhandle(protocols: string[] | string): void;
_onStarting(): Promise<void>;
/**
* Called when libp2p has started and before it returns
*
* @private
*/
private _onDidStart;
/**
* Will dial to the given `peerId` if the current number of
* connected peers is less than the configured `ConnectionManager`
* minConnections.
*
* @private
* @param {PeerId} peerId
*/
private _maybeConnect;
/**
* Initializes and starts peer discovery services
*
* @async
* @private
*/
private _setupPeerDiscovery;
}
declare namespace Libp2p {
export { Multiaddr, Connection, MuxedStream, TransportFactory, MuxerFactory, Crypto, Pubsub, PeerStoreOptions, PeerDiscoveryOptions, RelayOptions, Libp2pConfig, Libp2pModules, Libp2pOptions, CreateOptions };
}
type Multiaddr = import("multiaddr");
type Connection = import("libp2p-interfaces/src/connection/connection");
type Libp2pOptions = {
/**
* libp2p modules to use
*/
modules: Libp2pModules;
addresses?: import("./address-manager").AddressManagerOptions | undefined;
connectionManager?: import("./connection-manager").ConnectionManagerOptions | undefined;
dialer?: import("./dialer").DialerOptions | undefined;
metrics?: import("./metrics").MetricsOptions | undefined;
keychain?: any;
transportManager?: import("./transport-manager").TransportManagerOptions | undefined;
peerStore?: (PeerStoreOptions & import("./peer-store/persistent").PersistentPeerStoreOptions) | undefined;
config?: Libp2pConfig | undefined;
peerId: import("peer-id");
};
type CreateOptions = {
peerId: import("peer-id");
};
type MuxedStream = import("libp2p-interfaces/src/stream-muxer/types").MuxedStream;
type TransportFactory = import("libp2p-interfaces/src/transport/types").TransportFactory<any, any>;
type MuxerFactory = import("libp2p-interfaces/src/stream-muxer/types").MuxerFactory;
type Crypto = import("libp2p-interfaces/src/crypto/types").Crypto;
type Pubsub = import("libp2p-interfaces/src/pubsub");
type PeerStoreOptions = {
persistence: boolean;
};
type PeerDiscoveryOptions = {
autoDial: boolean;
};
type RelayOptions = {
enabled: boolean;
advertise: import('./circuit').RelayAdvertiseOptions;
hop: import('./circuit').HopOptions;
autoRelay: import('./circuit').AutoRelayOptions;
};
type Libp2pConfig = {
/**
* dht module options
*/
dht?: any;
peerDiscovery?: PeerDiscoveryOptions | undefined;
/**
* pubsub module options
*/
pubsub?: import("libp2p-interfaces/src/pubsub") | undefined;
relay?: RelayOptions | undefined;
/**
* transport options indexed by transport key
*/
transport?: Record<string, any> | undefined;
};
type Libp2pModules = {
transport: import("libp2p-interfaces/src/transport/types").TransportFactory<any, any>[];
streamMuxer: MuxerFactory[];
connEncryption: Crypto[];
};
//# sourceMappingURL=index.d.ts.map

1
dist/src/index.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.js"],"names":[],"mappings":";;;AAmCA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH;IACE;;;;;;OAMG;IACH,uBAHW,aAAa,GAAG,aAAa,GAC3B,QAAQ,MAAM,CAAC,CAW3B;IAED;;;;;OAKG;IACH,sBAFW,aAAa,EAsKvB;IAhKC,cAAwC;IAExC,qBAAqB;IACrB,0BAAkC;IAClC,eAAwC;IAExC,kCAM0C;IAG1C,eAAwC;IACxC,4CAAiE;IAEjE,cAAqC;IACrC,aAAmC;IACnC,kBAAoB;IACpB,0BAA2B;IAM3B,kDAGE;IAIA,yCAGE;IASF,2CAIE;IAMJ,+BAKE;IAGF,gDAIE;IAGF,iCAGE;IAkTJ;;;;;OAKG;IACH,kBAHW,MAAM,EAAE,GAAC,MAAM;;;;UACwD,IAAI,QAUrF;IAlTC,2BAQE;IAWA,uCAA4B;IAW5B,kDAA4D;IAc5D,UAQE;IAOF,qBAAqB;IACrB,+CAA8D;IAKhE,sCAAwC;IACxC,4CAA8C;IAyThD;;;;;;OAMG;IACH,yBAQC;IA7SD;;;;OAIG;IACH,SAFa,QAAQ,IAAI,CAAC,CAezB;IAED;;;;;OAKG;IACH,QAFa,QAAQ,IAAI,CAAC,CAuCzB;IAjCG,gCAAuB;IAmC3B;;;;;;OAMG;IACH,gBAFa,QAAQ,IAAI,CAAC,CAYzB;IAED,iCAEC;IAED;;;;;OAKG;IACH,wFAEC;IAED;;;;;;;;OAQG;IACH,WALW,oBAAO,SAAS,GAAC,MAAM;;oBAGrB,QAAQ,UAAU,CAAC,CAI/B;IAED;;;;;;;;;;;OAWG;IACH,mBANW,oBAAO,SAAS,GAAC,MAAM,aACvB,MAAM,EAAE,GAAC,MAAM;;oBAGb,QAAQ,UAAU,MAAE,CAAC,CAkBjC;IAED;;;;;;OAMG;IACH,wCAUC;IAED;;;;;OAKG;IACH,aAHW,oBAAO,SAAS,GAAC,MAAM,GACrB,QAAQ,IAAI,CAAC,CAgBzB;IAED;;;;;OAKG;IACH,WAHW,oBAAO,SAAS,GAAC,MAAM,GACrB,QAAQ,MAAM,CAAC,CAW3B;IAkBD;;;;;OAKG;IACH,oBAFW,MAAM,EAAE,GAAC,MAAM,QAUzB;IAED,6BAuBC;IAED;;;;OAIG;IACH,oBAuBC;IAmBD;;;;;;;OAOG;IACH,sBAaC;IAED;;;;;OAKG;IACH,4BA6CC;CACF;;;;;;;;;;aA9lBa,aAAa;;;;;;;;;;;;;;;;;;;;iBAxBb,OAAO;;;cAGP,OAAO;;;aAGP,OAAO;eACP,OAAO,WAAW,EAAE,qBAAqB;SACzC,OAAO,WAAW,EAAE,UAAU;eAC9B,OAAO,WAAW,EAAE,gBAAgB;;;;;;;;;;;;;;;;;;;eAUpC,4EAAkB;iBAClB,YAAY,EAAE;oBACd,MAAM,EAAE"}

11
dist/src/insecure/plaintext.d.ts vendored Normal file
View File

@ -0,0 +1,11 @@
export type Connection = import("libp2p-interfaces/src/connection/connection");
export const protocol: "/plaintext/2.0.0";
export declare function secureInbound(localId: any, conn: any, remoteId: any): Promise<{
conn: any;
remotePeer: import("peer-id");
}>;
export declare function secureOutbound(localId: any, conn: any, remoteId: any): Promise<{
conn: any;
remotePeer: import("peer-id");
}>;
//# sourceMappingURL=plaintext.d.ts.map

1
dist/src/insecure/plaintext.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"plaintext.d.ts","sourceRoot":"","sources":["../../../src/insecure/plaintext.js"],"names":[],"mappings":";AAYA,0CAAmC;AA4DlB;;;GAEd;AACe;;;GAEf"}

3
dist/src/insecure/proto.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
declare const _exports: any;
export = _exports;
//# sourceMappingURL=proto.d.ts.map

1
dist/src/insecure/proto.d.ts.map vendored Normal file
View File

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

40
dist/src/keychain/cms.d.ts vendored Normal file
View File

@ -0,0 +1,40 @@
export = CMS;
/**
* Cryptographic Message Syntax (aka PKCS #7)
*
* CMS describes an encapsulation syntax for data protection. It
* is used to digitally sign, digest, authenticate, or encrypt
* arbitrary message content.
*
* See RFC 5652 for all the details.
*/
declare class CMS {
/**
* Creates a new instance with a keychain
*
* @param {import('./index')} keychain - the available keys
*/
constructor(keychain: import('./index'));
keychain: import(".");
/**
* Creates some protected data.
*
* The output Uint8Array contains the PKCS #7 message in DER.
*
* @param {string} name - The local key name.
* @param {Uint8Array} plain - The data to encrypt.
* @returns {Promise<Uint8Array>}
*/
encrypt(name: string, plain: Uint8Array): Promise<Uint8Array>;
/**
* Reads some protected data.
*
* The keychain must contain one of the keys used to encrypt the data. If none of the keys
* exists, an Error is returned with the property 'missingKeys'. It is array of key ids.
*
* @param {Uint8Array} cmsData - The CMS encrypted data to decrypt.
* @returns {Promise<Uint8Array>}
*/
decrypt(cmsData: Uint8Array): Promise<Uint8Array>;
}
//# sourceMappingURL=cms.d.ts.map

1
dist/src/keychain/cms.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"cms.d.ts","sourceRoot":"","sources":["../../../src/keychain/cms.js"],"names":[],"mappings":";AAWA;;;;;;;;GAQG;AACH;IACE;;;;OAIG;IACH,sBAFW,OAAO,SAAS,CAAC,EAQ3B;IADC,sBAAwB;IAG1B;;;;;;;;OAQG;IACH,cAJW,MAAM,SACN,UAAU,GACR,QAAQ,UAAU,CAAC,CAqB/B;IAED;;;;;;;;OAQG;IACH,iBAHW,UAAU,GACR,QAAQ,UAAU,CAAC,CAkD/B;CACF"}

143
dist/src/keychain/index.d.ts vendored Normal file
View File

@ -0,0 +1,143 @@
export = Keychain;
/**
* Information about a key.
*
* @typedef {Object} KeyInfo
*
* @property {string} id - The universally unique key id.
* @property {string} name - The local key name.
*/
/**
* Manages the lifecycle of a key. Keys are encrypted at rest using PKCS #8.
*
* A key in the store has two entries
* - '/info/*key-name*', contains the KeyInfo for the key
* - '/pkcs8/*key-name*', contains the PKCS #8 for the key
*
*/
declare class Keychain {
/**
* Generates the options for a keychain. A random salt is produced.
*
* @returns {object}
*/
static generateOptions(): object;
/**
* Gets an object that can encrypt/decrypt protected data.
* The default options for a keychain.
*
* @returns {object}
*/
static get options(): any;
/**
* Creates a new instance of a key chain.
*
* @param {DS} store - where the key are.
* @param {object} options
* @class
*/
constructor(store: any, options: object);
store: any;
opts: any;
/**
* Gets an object that can encrypt/decrypt protected data
* using the Cryptographic Message Syntax (CMS).
*
* CMS describes an encapsulation syntax for data protection. It
* is used to digitally sign, digest, authenticate, or encrypt
* arbitrary message content.
*
* @returns {CMS}
*/
get cms(): import("./cms");
/**
* Create a new key.
*
* @param {string} name - The local key name; cannot already exist.
* @param {string} type - One of the key types; 'rsa'.
* @param {int} [size] - The key size in bits. Used for rsa keys only.
* @returns {KeyInfo}
*/
createKey(name: string, type: string, size?: any): KeyInfo;
/**
* List all the keys.
*
* @returns {KeyInfo[]}
*/
listKeys(): KeyInfo[];
/**
* Find a key by it's id.
*
* @param {string} id - The universally unique key identifier.
* @returns {KeyInfo}
*/
findKeyById(id: string): KeyInfo;
/**
* Find a key by it's name.
*
* @param {string} name - The local key name.
* @returns {KeyInfo}
*/
findKeyByName(name: string): KeyInfo;
/**
* Remove an existing key.
*
* @param {string} name - The local key name; must already exist.
* @returns {KeyInfo}
*/
removeKey(name: string): KeyInfo;
/**
* Rename a key
*
* @param {string} oldName - The old local key name; must already exist.
* @param {string} newName - The new local key name; must not already exist.
* @returns {KeyInfo}
*/
renameKey(oldName: string, newName: string): KeyInfo;
/**
* Export an existing key as a PEM encrypted PKCS #8 string
*
* @param {string} name - The local key name; must already exist.
* @param {string} password - The password
* @returns {string}
*/
exportKey(name: string, password: string): string;
/**
* Import a new key from a PEM encoded PKCS #8 string
*
* @param {string} name - The local key name; must not already exist.
* @param {string} pem - The PEM encoded PKCS #8 string
* @param {string} password - The password.
* @returns {KeyInfo}
*/
importKey(name: string, pem: string, password: string): KeyInfo;
importPeer(name: any, peer: any): Promise<void | {
name: any;
id: any;
}>;
/**
* Gets the private key as PEM encoded PKCS #8 string.
*
* @param {string} name
* @returns {string}
* @private
*/
private _getPrivateKey;
}
declare namespace Keychain {
export { KeyInfo };
}
/**
* Information about a key.
*/
type KeyInfo = {
/**
* - The universally unique key id.
*/
id: string;
/**
* - The local key name.
*/
name: string;
};
//# sourceMappingURL=index.d.ts.map

1
dist/src/keychain/index.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/keychain/index.js"],"names":[],"mappings":";AAkFA;;;;;;;GAOG;AAEH;;;;;;;GAOG;AACH;IAsDE;;;;OAIG;IACH,0BAFa,MAAM,CAOlB;IAED;;;;;OAKG;IACH,0BAEC;IAzED;;;;;;OAMG;IACH,iCAHW,MAAM,EAiChB;IA1BC,WAAkB;IAElB,UAAiD;IA0BnD;;;;;;;;;OASG;IACH,2BAEC;IAwBD;;;;;;;OAOG;IACH,gBALW,MAAM,QACN,MAAM,eAEJ,OAAO,CA8CnB;IAED;;;;OAIG;IACH,YAFa,OAAO,EAAE,CAcrB;IAED;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CASnB;IAED;;;;;OAKG;IACH,oBAHW,MAAM,GACJ,OAAO,CAcnB;IAED;;;;;OAKG;IACH,gBAHW,MAAM,GACJ,OAAO,CAcnB;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,WACN,MAAM,GACJ,OAAO,CAkCnB;IAED;;;;;;OAMG;IACH,gBAJW,MAAM,YACN,MAAM,GACJ,MAAM,CAmBlB;IAED;;;;;;;OAOG;IACH,gBALW,MAAM,OACN,MAAM,YACN,MAAM,GACJ,OAAO,CAuCnB;IAED;;;OA6BC;IAED;;;;;;OAMG;IACH,uBAYC;CACF;;;;;;;;;;;QA7Xa,MAAM;;;;UACN,MAAM"}

13
dist/src/keychain/util.d.ts vendored Normal file
View File

@ -0,0 +1,13 @@
export function certificateForKey(key: any, privateKey: any): Uint8Array;
/**
* Finds the first item in a collection that is matched in the
* `asyncCompare` function.
*
* `asyncCompare` is an async function that must
* resolve to either `true` or `false`.
*
* @param {Array} array
* @param {function(*)} asyncCompare - An async function that returns a boolean
*/
export function findAsync(array: any[], asyncCompare: (arg0: any) => any): Promise<any>;
//# sourceMappingURL=util.d.ts.map

1
dist/src/keychain/util.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"util.d.ts","sourceRoot":"","sources":["../../../src/keychain/util.js"],"names":[],"mappings":"AAmB4B,8DAFf,UAAU,CAqDtB;AAED;;;;;;;;;GASG;AACH,wFAKC"}

154
dist/src/metrics/index.d.ts vendored Normal file
View File

@ -0,0 +1,154 @@
export = Metrics;
/**
* @typedef {import('peer-id')} PeerId
* @typedef {import('libp2p-interfaces/src/transport/types').MultiaddrConnection} MultiaddrConnection
*/
/**
* @typedef MetricsProperties
* @property {import('../connection-manager')} connectionManager
*
* @typedef MetricsOptions
* @property {number} [computeThrottleMaxQueueSize = defaultOptions.computeThrottleMaxQueueSize]
* @property {number} [computeThrottleTimeout = defaultOptions.computeThrottleTimeout]
* @property {number[]} [movingAverageIntervals = defaultOptions.movingAverageIntervals]
* @property {number} [maxOldPeersRetention = defaultOptions.maxOldPeersRetention]
*/
declare class Metrics {
/**
* Merges `other` into `target`. `target` will be modified
* and returned.
*
* @param {Stats} target
* @param {Stats} other
* @returns {Stats}
*/
static mergeStats(target: import("./stats"), other: import("./stats")): import("./stats");
/**
* @class
* @param {MetricsProperties & MetricsOptions} options
*/
constructor(options: MetricsProperties & MetricsOptions);
_options: any;
_globalStats: import("./stats");
_peerStats: Map<any, any>;
_protocolStats: Map<any, any>;
_oldPeers: any;
_running: boolean;
/**
* Takes the metadata for a message and tracks it in the
* appropriate categories. If the protocol is present, protocol
* stats will also be tracked.
*
* @private
* @param {object} params
* @param {PeerId} params.remotePeer - Remote peer
* @param {string} [params.protocol] - Protocol string the stream is running
* @param {string} params.direction - One of ['in','out']
* @param {number} params.dataLength - Size of the message
* @returns {void}
*/
private _onMessage;
_connectionManager: import("../connection-manager");
/**
* Must be called for stats to saved. Any data pushed for tracking
* will be ignored.
*/
start(): void;
/**
* Stops all averages timers and prevents new data from being tracked.
* Once `stop` is called, `start` must be called to resume stats tracking.
*/
stop(): void;
/**
* Gets the global `Stats` object
*
* @returns {Stats}
*/
get global(): import("./stats");
/**
* Returns a list of `PeerId` strings currently being tracked
*
* @returns {string[]}
*/
get peers(): string[];
/**
* Returns the `Stats` object for the given `PeerId` whether it
* is a live peer, or in the disconnected peer LRU cache.
*
* @param {PeerId} peerId
* @returns {Stats}
*/
forPeer(peerId: PeerId): import("./stats");
/**
* Returns a list of all protocol strings currently being tracked.
*
* @returns {string[]}
*/
get protocols(): string[];
/**
* Returns the `Stats` object for the given `protocol`.
*
* @param {string} protocol
* @returns {Stats}
*/
forProtocol(protocol: string): import("./stats");
/**
* Should be called when all connections to a given peer
* have closed. The `Stats` collection for the peer will
* be stopped and moved to an LRU for temporary retention.
*
* @param {PeerId} peerId
*/
onPeerDisconnected(peerId: PeerId): void;
/**
* Replaces the `PeerId` string with the given `peerId`.
* If stats are already being tracked for the given `peerId`, the
* placeholder stats will be merged with the existing stats.
*
* @param {PeerId} placeholder - A peerId string
* @param {PeerId} peerId
* @returns {void}
*/
updatePlaceholder(placeholder: PeerId, peerId: PeerId): void;
/**
* Tracks data running through a given Duplex Iterable `stream`. If
* the `peerId` is not provided, a placeholder string will be created and
* returned. This allows lazy tracking of a peer when the peer is not yet known.
* When the `PeerId` is known, `Metrics.updatePlaceholder` should be called
* with the placeholder string returned from here, and the known `PeerId`.
*
* @param {Object} options
* @param {MultiaddrConnection} options.stream - A duplex iterable stream
* @param {PeerId} [options.remotePeer] - The id of the remote peer that's connected
* @param {string} [options.protocol] - The protocol the stream is running
* @returns {MultiaddrConnection} The peerId string or placeholder string
*/
trackStream({ stream, remotePeer, protocol }: {
stream: MultiaddrConnection;
remotePeer: import("peer-id") | undefined;
protocol: string | undefined;
}): MultiaddrConnection;
}
declare namespace Metrics {
export { PeerId, MultiaddrConnection, MetricsProperties, MetricsOptions };
}
type PeerId = import("peer-id");
type MultiaddrConnection = {
sink: import("libp2p-interfaces/src/stream-muxer/types").Sink;
source: () => AsyncIterable<Uint8Array>;
close: (err?: Error | undefined) => Promise<void>;
conn: unknown;
remoteAddr: import("multiaddr");
localAddr?: import("multiaddr") | undefined;
timeline: import("libp2p-interfaces/src/transport/types").MultiaddrConnectionTimeline;
};
type MetricsProperties = {
connectionManager: import('../connection-manager');
};
type MetricsOptions = {
computeThrottleMaxQueueSize?: number | undefined;
computeThrottleTimeout?: number | undefined;
movingAverageIntervals?: number[] | undefined;
maxOldPeersRetention?: number | undefined;
};
//# sourceMappingURL=index.d.ts.map

1
dist/src/metrics/index.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/metrics/index.js"],"names":[],"mappings":";AAoBA;;;GAGG;AAEH;;;;;;;;;GASG;AAEH;IAwNE;;;;;;;OAOG;IACH,0FASC;IAxOD;;;OAGG;IACH,qBAFW,iBAAiB,GAAG,cAAc,EAc5C;IAXC,cAAqD;IACrD,gCAA6D;IAC7D,0BAA2B;IAC3B,8BAA+B;IAC/B,eAA+D;IAC/D,kBAAqB;IAiGvB;;;;;;;;;;;;OAYG;IACH,mBAwBC;IApIC,oDAAmD;IAMrD;;;OAGG;IACH,cAEC;IAED;;;OAGG;IACH,aASC;IAED;;;;OAIG;IACH,gCAEC;IAED;;;;OAIG;IACH,sBAEC;IAED;;;;;;OAMG;IACH,gBAHW,MAAM,qBAMhB;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;;OAKG;IACH,sBAHW,MAAM,qBAKhB;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;;;;;;;;;;;;;;;uBAnPa,OAAO,uBAAuB,CAAC"}

3
dist/src/metrics/old-peers.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
declare function _exports(maxSize: number): any;
export = _exports;
//# sourceMappingURL=old-peers.d.ts.map

1
dist/src/metrics/old-peers.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"old-peers.d.ts","sourceRoot":"","sources":["../../../src/metrics/old-peers.js"],"names":[],"mappings":"AAUiB,mCAHN,MAAM,GACJ,GAAG,CAOf"}

121
dist/src/metrics/stats.d.ts vendored Normal file
View File

@ -0,0 +1,121 @@
/// <reference types="node" />
export = Stats;
declare const Stats_base: typeof import("events").EventEmitter;
declare class Stats extends Stats_base {
/**
* A queue based manager for stat processing
*
* @class
* @param {string[]} initialCounters
* @param {any} options
*/
constructor(initialCounters: string[], options: any);
_options: any;
_queue: any[];
_stats: {};
_frequencyLastTime: number;
_frequencyAccumulators: {};
_movingAverages: {};
/**
* If there are items in the queue, they will will be processed and
* the frequency for all items will be updated based on the Timestamp
* of the last item in the queue. The `update` event will also be emitted
* with the latest stats.
*
* If there are no items in the queue, no action is taken.
*
* @private
* @returns {void}
*/
private _update;
/**
* Initializes the internal timer if there are items in the queue. This
* should only need to be called if `Stats.stop` was previously called, as
* `Stats.push` will also start the processing.
*
* @returns {void}
*/
start(): void;
/**
* Stops processing and computing of stats by clearing the internal
* timer.
*
* @returns {void}
*/
stop(): void;
_timeout: any;
/**
* Returns a clone of the current stats.
*
* @returns {Object}
*/
get snapshot(): any;
/**
* Returns a clone of the internal movingAverages
*
* @returns {MovingAverage}
*/
get movingAverages(): any;
/**
* Returns a plain JSON object of the stats
*
* @returns {*}
*/
toJSON(): any;
/**
* Pushes the given operation data to the queue, along with the
* current Timestamp, then resets the update timer.
*
* @param {string} counter
* @param {number} inc
* @returns {void}
*/
push(counter: string, inc: number): void;
/**
* Resets the timeout for triggering updates.
*
* @private
* @returns {void}
*/
private _resetComputeTimeout;
/**
* Calculates and returns the timeout for the next update based on
* the urgency of the update.
*
* @private
* @returns {number}
*/
private _nextTimeout;
/**
* For each key in the stats, the frequency and moving averages
* will be updated via Stats._updateFrequencyFor based on the time
* difference between calls to this method.
*
* @private
* @param {Timestamp} latestTime
* @returns {void}
*/
private _updateFrequency;
/**
* Updates the `movingAverages` for the given `key` and also
* resets the `frequencyAccumulator` for the `key`.
*
* @private
* @param {string} key
* @param {number} timeDiffMS - Time in milliseconds
* @param {Timestamp} latestTime - Time in ticks
* @returns {void}
*/
private _updateFrequencyFor;
/**
* For the given operation, `op`, the stats and `frequencyAccumulator`
* will be updated or initialized if they don't already exist.
*
* @private
* @param {{string, number}[]} op
* @throws {InvalidNumber}
* @returns {void}
*/
private _applyOp;
}
//# sourceMappingURL=stats.d.ts.map

1
dist/src/metrics/stats.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"stats.d.ts","sourceRoot":"","sources":["../../../src/metrics/stats.js"],"names":[],"mappings":";;;AAQA;IACE;;;;;;OAMG;IACH,6BAHW,MAAM,EAAE,WACR,GAAG,EA4Bb;IAvBC,cAAuB;IACvB,cAAgB;IAChB,WAAgB;IAEhB,2BAAoC;IACpC,2BAAgC;IAEhC,oBAAyB;IA4H3B;;;;;;;;;;OAUG;IACH,gBAaC;IAlID;;;;;;OAMG;IACH,SAFa,IAAI,CAMhB;IAED;;;;;OAKG;IACH,QAFa,IAAI,CAOhB;IAFG,cAAoB;IAIxB;;;;OAIG;IACH,oBAEC;IAED;;;;OAIG;IACH,0BAEC;IAED;;;;OAIG;IACH,cAkBC;IAED;;;;;;;OAOG;IACH,cAJW,MAAM,OACN,MAAM,GACJ,IAAI,CAKhB;IAED;;;;;OAKG;IACH,6BAEC;IAED;;;;;;OAMG;IACH,qBAKC;IA4BD;;;;;;;;OAQG;IACH,yBAQC;IAED;;;;;;;;;OASG;IACH,4BAsBC;IAED;;;;;;;;OAQG;IACH,iBAqBC;CACF"}

63
dist/src/peer-routing.d.ts vendored Normal file
View File

@ -0,0 +1,63 @@
export = PeerRouting;
/**
* @typedef {import('peer-id')} PeerId
* @typedef {import('multiaddr')} Multiaddr
*/
declare class PeerRouting {
/**
* @class
* @param {import('./')} libp2p
*/
constructor(libp2p: import('./'));
_peerId: import("peer-id");
_peerStore: import("./peer-store");
_routers: any;
_refreshManagerOptions: any;
/**
* Recurrent task to find closest peers and add their addresses to the Address Book.
*/
_findClosestPeersTask(): Promise<void>;
/**
* Start peer routing service.
*/
start(): void;
_timeoutId: any;
/**
* Stop peer routing service.
*/
stop(): void;
/**
* Iterates over all peer routers in series to find the given peer.
*
* @param {string} id - The id of the peer to find
* @param {object} [options]
* @param {number} [options.timeout] - How long the query should run
* @returns {Promise<{ id: PeerId, multiaddrs: Multiaddr[] }>}
*/
findPeer(id: string, options?: {
timeout?: number | undefined;
} | undefined): Promise<{
id: PeerId;
multiaddrs: Multiaddr[];
}>;
/**
* Attempt to find the closest peers on the network to the given key.
*
* @param {Uint8Array} key - A CID like key
* @param {Object} [options]
* @param {number} [options.timeout=30e3] - How long the query can take.
* @returns {AsyncIterable<{ id: PeerId, multiaddrs: Multiaddr[] }>}
*/
getClosestPeers(key: Uint8Array, options?: {
timeout?: number | undefined;
} | undefined): AsyncIterable<{
id: PeerId;
multiaddrs: Multiaddr[];
}>;
}
declare namespace PeerRouting {
export { PeerId, Multiaddr };
}
type PeerId = import("peer-id");
type Multiaddr = import("multiaddr");
//# sourceMappingURL=peer-routing.d.ts.map

1
dist/src/peer-routing.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"peer-routing.d.ts","sourceRoot":"","sources":["../../src/peer-routing.js"],"names":[],"mappings":";AAeA;;;GAGG;AACH;IACE;;;OAGG;IACH,oBAFW,OAAO,IAAI,CAAC,EAetB;IAZC,2BAA4B;IAC5B,mCAAkC;IAClC,cAAiD;IAOjD,4BAAwE;IAkB1E;;OAEG;IACH,uCAQC;IAxBD;;OAEG;IACH,cAQC;IAHC,gBAEC;IAgBH;;OAEG;IACH,aAEC;IAED;;;;;;;OAOG;IACH,aALW,MAAM;;oBAGJ,QAAQ;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,SAAS,EAAE,CAAA;KAAE,CAAC,CAiB5D;IAED;;;;;;;OAOG;IACH,qBALW,UAAU;;oBAGR,cAAc;QAAE,EAAE,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,SAAS,EAAE,CAAA;KAAE,CAAC,CAqBlE;CACF"}

120
dist/src/peer-store/address-book.d.ts vendored Normal file
View File

@ -0,0 +1,120 @@
export = AddressBook;
declare const AddressBook_base: typeof import("./book");
/**
* @typedef {import('multiaddr')} Multiaddr
* @typedef {import('./')} PeerStore
*/
/**
* @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 AddressBook_base {
/**
* The AddressBook is responsible for keeping the known multiaddrs of a peer.
*
* @class
* @param {PeerStore} peerStore
*/
constructor(peerStore: PeerStore);
/**
* 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: import("../record/envelope")): boolean;
/**
* Get the raw Envelope for a peer. Returns
* undefined if no Envelope is found.
*
* @param {PeerId} peerId
* @returns {Uint8Array|undefined}
*/
getRawEnvelope(peerId: import("peer-id")): 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: import("peer-id")): Promise<import("../record/envelope") | void> | undefined;
/**
* 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: import("peer-id"), multiaddrs: Multiaddr[]): AddressBook;
/**
* Transforms received multiaddrs into Address.
*
* @private
* @param {Multiaddr[]} multiaddrs
* @param {boolean} [isCertified]
* @returns {Address[]}
*/
private _toAddresses;
/**
* 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: import("peer-id"), addressSorter?: ((addresses: Address[]) => Address[]) | undefined): Multiaddr[] | undefined;
}
declare namespace AddressBook {
export { Multiaddr, PeerStore, Address, CertifiedRecord, Entry };
}
type Multiaddr = import("multiaddr");
type Address = {
/**
* peer multiaddr.
*/
multiaddr: Multiaddr;
/**
* obtained from a signed peer record.
*/
isCertified: boolean;
};
type PeerStore = import(".");
type CertifiedRecord = {
/**
* raw envelope.
*/
raw: Uint8Array;
/**
* seq counter.
*/
seqNumber: number;
};
type Entry = {
/**
* peer Addresses.
*/
addresses: Address[];
/**
* certified peer record.
*/
record: CertifiedRecord;
};
//# sourceMappingURL=address-book.d.ts.map

1
dist/src/peer-store/address-book.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"address-book.d.ts","sourceRoot":"","sources":["../../../src/peer-store/address-book.js"],"names":[],"mappings":";;AAmBA;;;GAGG;AAEH;;;;;;;;;;;;GAYG;AAEH;;GAEG;AACH;IACE;;;;;OAKG;IACH,uBAFW,SAAS,EA0BnB;IAED;;;;;;;OAOG;IACH,2DAFa,OAAO,CA8CnB;IAED;;;;;;OAMG;IACH,2CAFa,UAAU,GAAC,SAAS,CAUhC;IAED;;;;;;OAMG;IACH,0CAFa,QAAQ,+BAAS,IAAI,CAAC,GAAC,SAAS,CAU5C;IAuDD;;;;;;;OAOG;IACH,2CAHW,SAAS,EAAE,GACT,WAAW,CA0CvB;IAmBD;;;;;;;OAOG;IACH,qBAqBC;IAED;;;;;;;;OAQG;IACH,6EAHuB,OAAO,EAAE,KAAK,OAAO,EAAE,gBACjC,SAAS,EAAE,GAAC,SAAS,CAsBjC;CACF;;;;;;;;;eA7Ta,SAAS;;;;iBACT,OAAO;;;;;;;SAGP,UAAU;;;;eACV,MAAM;;;;;;eAGN,OAAO,EAAE;;;;YACT,eAAe"}

80
dist/src/peer-store/book.d.ts vendored Normal file
View File

@ -0,0 +1,80 @@
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: import("peer-id"), 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: import("peer-id"), data: any, { emit }?: {
emit?: boolean | undefined;
} | undefined): void;
/**
* Emit data.
*
* @protected
* @param {PeerId} peerId
* @param {any} [data]
*/
protected _emit(peerId: import("peer-id"), 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: import("peer-id")): any[] | any | undefined;
/**
* Deletes the provided peer from the book.
*
* @param {PeerId} peerId
* @returns {boolean}
*/
delete(peerId: import("peer-id")): boolean;
}
declare namespace Book {
export { PeerStore };
}
type PeerStore = import(".");
//# sourceMappingURL=book.d.ts.map

1
dist/src/peer-store/book.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"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,UAA3C,GAAG,KAAK,GAAG,EAAE;OAc9B;IAXC,iBAAoB;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,qCAFW,GAAG,EAAE,GAAC,GAAG,QAInB;IAED;;;;;;;;;OASG;IACH,oDALW,GAAG;;oBAGD,IAAI,CAUhB;IAED;;;;;;OAMG;IACH,kDAFW,GAAG,QAOb;IAED;;;;;;OAMG;IACH,gCAFa,GAAG,EAAE,GAAC,GAAG,GAAC,SAAS,CAW/B;IAED;;;;;OAKG;IACH,mCAFa,OAAO,CAcnB;CACF"}

129
dist/src/peer-store/index.d.ts vendored Normal file
View File

@ -0,0 +1,129 @@
/// <reference types="node" />
export = PeerStore;
declare const PeerStore_base: typeof import("events").EventEmitter;
/**
* @typedef {import('./address-book').Address} Address
*/
/**
* @extends {EventEmitter}
*
* @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.
*/
declare class PeerStore extends PeerStore_base {
/**
* 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.
*/
/**
* Responsible for managing known peers, as well as their addresses, protocols and metadata.
*
* @param {object} options
* @param {PeerId} options.peerId
* @class
*/
constructor({ peerId }: {
peerId: import("peer-id");
});
_peerId: import("peer-id");
/**
* AddressBook containing a map of peerIdStr to Address.
*/
addressBook: import("./address-book");
/**
* KeyBook containing a map of peerIdStr to their PeerId with public keys.
*/
keyBook: import("./key-book");
/**
* MetadataBook containing a map of peerIdStr to their metadata Map.
*/
metadataBook: import("./metadata-book");
/**
* ProtoBook containing a map of peerIdStr to supported protocols.
*/
protoBook: import("./proto-book");
/**
* Start the PeerStore.
*/
start(): void;
/**
* Stop the PeerStore.
*/
stop(): void;
/**
* Get all the stored information of every peer known.
*
* @returns {Map<string, Peer>}
*/
get peers(): Map<string, {
/**
* peer's peer-id instance.
*/
id: import("peer-id");
/**
* 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 the information of the given peer in every book.
*
* @param {PeerId} peerId
* @returns {boolean} true if found and removed
*/
delete(peerId: import("peer-id")): boolean;
/**
* Get the stored information of a given peer.
*
* @param {PeerId} peerId
* @returns {Peer|undefined}
*/
get(peerId: import("peer-id")): {
/**
* peer's peer-id instance.
*/
id: import("peer-id");
/**
* 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;
}
declare namespace PeerStore {
export { Address };
}
type Address = {
/**
* peer multiaddr.
*/
multiaddr: import("multiaddr");
/**
* obtained from a signed peer record.
*/
isCertified: boolean;
};
//# sourceMappingURL=index.d.ts.map

1
dist/src/peer-store/index.d.ts.map vendored Normal file
View File

@ -0,0 +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;OA2BhC;IArBC,2BAAqB;IAErB;;OAEG;IACH,sCAAwC;IAExC;;OAEG;IACH,8BAAgC;IAEhC;;OAEG;IACH,wCAA0C;IAE1C;;OAEG;IACH,kCAAoC;IAGtC;;OAEG;IACH,cAAW;IAEX;;OAEG;IACH,aAAU;IAEV;;;;OAIG;IACH;;;;;;;;mBArDc,OAAO,EAAE;;;;mBACT,MAAM,EAAE;;;;kBACR,IAAI,MAAM,EAAE,UAAU,CAAC,GAAC,SAAS;OAoE9C;IAED;;;;;OAKG;IACH,mCAFa,OAAO,CASnB;IAED;;;;;OAKG;IACH;;;;;;;;mBA7Fc,OAAO,EAAE;;;;mBACT,MAAM,EAAE;;;;kBACR,IAAI,MAAM,EAAE,UAAU,CAAC,GAAC,SAAS;kBA+G9C;CACF"}

24
dist/src/peer-store/key-book.d.ts vendored Normal file
View File

@ -0,0 +1,24 @@
export = KeyBook;
declare const KeyBook_base: typeof import("./book");
/**
* @typedef {import('./')} PeerStore
* @typedef {import('libp2p-crypto').PublicKey} PublicKey
*/
/**
* @extends {Book}
*/
declare class KeyBook extends KeyBook_base {
/**
* The KeyBook is responsible for keeping the known public keys of a peer.
*
* @class
* @param {PeerStore} peerStore
*/
constructor(peerStore: PeerStore);
}
declare namespace KeyBook {
export { PeerStore, PublicKey };
}
type PeerStore = import(".");
type PublicKey = import("libp2p-crypto").PublicKey;
//# sourceMappingURL=key-book.d.ts.map

1
dist/src/peer-store/key-book.d.ts.map vendored Normal file
View File

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

49
dist/src/peer-store/metadata-book.d.ts vendored Normal file
View File

@ -0,0 +1,49 @@
export = MetadataBook;
declare const MetadataBook_base: typeof import("./book");
/**
* @typedef {import('./')} PeerStore
*/
/**
* @extends {Book}
*
* @fires MetadataBook#change:metadata
*/
declare class MetadataBook extends MetadataBook_base {
/**
* The MetadataBook is responsible for keeping the known supported
* protocols of a peer.
*
* @class
* @param {PeerStore} peerStore
*/
constructor(peerStore: PeerStore);
/**
* Set data into the datastructure
*
* @override
*/
_setValue(peerId: any, key: any, value: any, { emit }?: {
emit?: boolean | undefined;
}): void;
/**
* Get specific metadata value, if it exists
*
* @param {PeerId} peerId
* @param {string} key
* @returns {Uint8Array | undefined}
*/
getValue(peerId: import("peer-id"), key: string): Uint8Array | undefined;
/**
* Deletes the provided peer metadata key from the book.
*
* @param {PeerId} peerId
* @param {string} key
* @returns {boolean}
*/
deleteValue(peerId: import("peer-id"), key: string): boolean;
}
declare namespace MetadataBook {
export { PeerStore };
}
type PeerStore = import(".");
//# sourceMappingURL=metadata-book.d.ts.map

1
dist/src/peer-store/metadata-book.d.ts.map vendored Normal file
View File

@ -0,0 +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;;;;OAIG;IACH;;aAeC;IAgBD;;;;;;OAMG;IACH,yCAHW,MAAM,GACJ,UAAU,GAAG,SAAS,CASlC;IAsBD;;;;;;OAMG;IACH,4CAHW,MAAM,GACJ,OAAO,CAgBnB;CACF"}

6
dist/src/peer-store/persistent/consts.d.ts vendored Normal file
View File

@ -0,0 +1,6 @@
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

1
dist/src/peer-store/persistent/consts.d.ts.map vendored Normal file
View File

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

123
dist/src/peer-store/persistent/index.d.ts vendored Normal file
View File

@ -0,0 +1,123 @@
export = PersistentPeerStore;
declare const PersistentPeerStore_base: typeof import("..");
/**
* @typedef {Object} PersistentPeerStoreProperties
* @property {PeerId} peerId
* @property {any} 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 PersistentPeerStore_base {
/**
* @class
* @param {PersistentPeerStoreProperties & PersistentPeerStoreOptions} properties
*/
constructor({ peerId, datastore, threshold }: PersistentPeerStoreProperties & PersistentPeerStoreOptions);
/**
* Backend datastore used to persist data.
*/
_datastore: any;
/**
* 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 {Object} batch
*/
private _batchAddressBook;
/**
* Add Key book data of the peer to the batch.
*
* @private
* @param {PeerId} peerId
* @param {Object} batch
*/
private _batchKeyBook;
/**
* Add metadata book data of the peer to the batch.
*
* @private
* @param {PeerId} peerId
* @param {Object} batch
*/
private _batchMetadataBook;
/**
* Add proto book data of the peer to the batch.
*
* @private
* @param {PeerId} peerId
* @param {Object} 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 { PersistentPeerStoreProperties, PersistentPeerStoreOptions };
}
type PersistentPeerStoreProperties = {
peerId: import("peer-id");
datastore: any;
};
type PersistentPeerStoreOptions = {
/**
* - Number of dirty peers allowed before commit data.
*/
threshold?: number | undefined;
};
//# sourceMappingURL=index.d.ts.map

1
dist/src/peer-store/persistent/index.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/peer-store/persistent/index.js"],"names":[],"mappings":";;AAuBA;;;;;;;GAOG;AAEH;;GAEG;AACH;IACE;;;OAGG;IACH,8CAFW,6BAA6B,GAAG,0BAA0B,EAwBpE;IAnBC;;OAEG;IACH,gBAA2B;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,0BA4BC;IAED;;;;;;OAMG;IACH,sBAiBC;IAED;;;;;;OAMG;IACH,2BAkBC;IAED;;;;;;OAMG;IACH,wBAmBC;IAED;;;;;;;;OAQG;IACH,+BAwDC;CACF;;;;;;eAjXa,GAAG"}

3
dist/src/peer-store/persistent/pb/address-book.proto.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
declare const _exports: any;
export = _exports;
//# sourceMappingURL=address-book.proto.d.ts.map

1
dist/src/peer-store/persistent/pb/address-book.proto.d.ts.map vendored Normal file
View File

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

3
dist/src/peer-store/persistent/pb/proto-book.proto.d.ts vendored Normal file
View File

@ -0,0 +1,3 @@
declare const _exports: any;
export = _exports;
//# sourceMappingURL=proto-book.proto.d.ts.map

1
dist/src/peer-store/persistent/pb/proto-book.proto.d.ts.map vendored Normal file
View File

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

43
dist/src/peer-store/proto-book.d.ts vendored Normal file
View File

@ -0,0 +1,43 @@
export = ProtoBook;
declare const ProtoBook_base: typeof import("./book");
/**
* @typedef {import('./')} PeerStore
*/
/**
* @extends {Book}
*
* @fires ProtoBook#change:protocols
*/
declare class ProtoBook extends ProtoBook_base {
/**
* The ProtoBook is responsible for keeping the known supported
* protocols of a peer.
*
* @class
* @param {PeerStore} peerStore
*/
constructor(peerStore: PeerStore);
/**
* Adds known protocols of a provided peer.
* If the peer was not known before, it will be added.
*
* @param {PeerId} peerId
* @param {string[]} protocols
* @returns {ProtoBook}
*/
add(peerId: import("peer-id"), protocols: string[]): ProtoBook;
/**
* Removes known protocols of a provided peer.
* If the protocols did not exist before, nothing will be done.
*
* @param {PeerId} peerId
* @param {string[]} protocols
* @returns {ProtoBook}
*/
remove(peerId: import("peer-id"), protocols: string[]): ProtoBook;
}
declare namespace ProtoBook {
export { PeerStore };
}
type PeerStore = import(".");
//# sourceMappingURL=proto-book.d.ts.map

1
dist/src/peer-store/proto-book.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"proto-book.d.ts","sourceRoot":"","sources":["../../../src/peer-store/proto-book.js"],"names":[],"mappings":";;AAeA;;GAEG;AAEH;;;;GAIG;AACH;IACE;;;;;;OAMG;IACH,uBAFW,SAAS,EAoBnB;IAyCD;;;;;;;OAOG;IACH,0CAHW,MAAM,EAAE,GACN,SAAS,CA2BrB;IAED;;;;;;;OAOG;IACH,6CAHW,MAAM,EAAE,GACN,SAAS,CA+BrB;CACF"}

3
dist/src/ping/constants.d.ts vendored Normal file
View File

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

1
dist/src/ping/constants.d.ts.map vendored Normal file
View File

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

33
dist/src/ping/index.d.ts vendored Normal file
View File

@ -0,0 +1,33 @@
export = ping;
/**
* @typedef {import('../')} Libp2p
* @typedef {import('multiaddr')} Multiaddr
* @typedef {import('peer-id')} PeerId
*/
/**
* Ping a given peer and wait for its response, getting the operation latency.
*
* @param {Libp2p} node
* @param {PeerId|Multiaddr} peer
* @returns {Promise<number>}
*/
declare function ping(node: Libp2p, peer: PeerId | Multiaddr): Promise<number>;
declare namespace ping {
export { mount, unmount, Libp2p, Multiaddr, PeerId };
}
type Libp2p = import("..");
type PeerId = import("peer-id");
type Multiaddr = import("multiaddr");
/**
* Subscribe ping protocol handler.
*
* @param {Libp2p} node
*/
declare function mount(node: Libp2p): void;
/**
* Unsubscribe ping protocol handler.
*
* @param {Libp2p} node
*/
declare function unmount(node: Libp2p): void;
//# sourceMappingURL=index.d.ts.map

1
dist/src/ping/index.d.ts.map vendored Normal file
View File

@ -0,0 +1 @@
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/ping/index.js"],"names":[],"mappings":";AAgBA;;;;GAIG;AAEH;;;;;;GAMG;AACH,4BAJW,MAAM,QACN,MAAM,GAAC,SAAS,GACd,QAAQ,MAAM,CAAC,CAyB3B;;;;;;;AAED;;;;GAIG;AACH,6BAFW,MAAM,QAIhB;AAED;;;;GAIG;AACH,+BAFW,MAAM,QAIhB"}

2
dist/src/ping/util.d.ts vendored Normal file
View File

@ -0,0 +1,2 @@
export function rnd(length: any): Uint8Array;
//# sourceMappingURL=util.d.ts.map

Some files were not shown because too many files have changed in this diff Show More