@libp2p/interface 0.0.1-6fdaa7dc

package/dist/src/events.d.ts

@@ -0,0 +1,28 @@
+export interface EventCallback<EventType> {
+    (evt: EventType): void;
+}
+export interface EventObject<EventType> {
+    handleEvent: EventCallback<EventType>;
+}
+export type EventHandler<EventType> = EventCallback<EventType> | EventObject<EventType>;
+/**
+ * Adds types to the EventTarget class. Hopefully this won't be necessary forever.
+ *
+ * https://github.com/microsoft/TypeScript/issues/28357
+ * https://github.com/microsoft/TypeScript/issues/43477
+ * https://github.com/microsoft/TypeScript/issues/299
+ * etc
+ */
+export declare class EventEmitter<EventMap extends Record<string, any>> extends EventTarget {
+    #private;
+    listenerCount(type: string): number;
+    addEventListener<K extends keyof EventMap>(type: K, listener: EventHandler<EventMap[K]> | null, options?: boolean | AddEventListenerOptions): void;
+    removeEventListener<K extends keyof EventMap>(type: K, listener?: EventHandler<EventMap[K]> | null, options?: boolean | EventListenerOptions): void;
+    dispatchEvent(event: Event): boolean;
+    safeDispatchEvent<Detail>(type: keyof EventMap, detail: CustomEventInit<Detail>): boolean;
+}
+export declare const CustomEvent: {
+    new <T>(type: string, eventInitDict?: CustomEventInit<T> | undefined): CustomEvent<T>;
+    prototype: CustomEvent<any>;
+};
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../src/events.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,aAAa,CAAC,SAAS;IAAI,CAAC,GAAG,EAAE,SAAS,GAAG,IAAI,CAAA;CAAE;AACpE,MAAM,WAAW,WAAW,CAAC,SAAS;IAAI,WAAW,EAAE,aAAa,CAAC,SAAS,CAAC,CAAA;CAAE;AACjF,MAAM,MAAM,YAAY,CAAC,SAAS,IAAI,aAAa,CAAC,SAAS,CAAC,GAAG,WAAW,CAAC,SAAS,CAAC,CAAA;AAOvF;;;;;;;GAOG;AACH,qBAAa,YAAY,CAAC,QAAQ,SAAS,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAE,SAAQ,WAAW;;IAGjF,aAAa,CAAE,IAAI,EAAE,MAAM,GAAG,MAAM;IAUpC,gBAAgB,CAAC,CAAC,SAAS,MAAM,QAAQ,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,uBAAuB,GAAG,IAAI;IAiBlJ,mBAAmB,CAAC,CAAC,SAAS,MAAM,QAAQ,EAAE,IAAI,EAAE,CAAC,EAAE,QAAQ,CAAC,EAAE,YAAY,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,OAAO,CAAC,EAAE,OAAO,GAAG,oBAAoB,GAAG,IAAI;IAcnJ,aAAa,CAAE,KAAK,EAAE,KAAK,GAAG,OAAO;IAerC,iBAAiB,CAAC,MAAM,EAAE,IAAI,EAAE,MAAM,QAAQ,EAAE,MAAM,EAAE,eAAe,CAAC,MAAM,CAAC,GAAG,OAAO;CAG1F;AAoBD,eAAO,MAAM,WAAW;;;CAAgD,CAAA"}

package/dist/src/events.js

@@ -0,0 +1,70 @@
+/**
+ * Adds types to the EventTarget class. Hopefully this won't be necessary forever.
+ *
+ * https://github.com/microsoft/TypeScript/issues/28357
+ * https://github.com/microsoft/TypeScript/issues/43477
+ * https://github.com/microsoft/TypeScript/issues/299
+ * etc
+ */
+export class EventEmitter extends EventTarget {
+    #listeners = new Map();
+    listenerCount(type) {
+        const listeners = this.#listeners.get(type);
+        if (listeners == null) {
+            return 0;
+        }
+        return listeners.length;
+    }
+    addEventListener(type, listener, options) {
+        super.addEventListener(type, listener, options);
+        let list = this.#listeners.get(type);
+        if (list == null) {
+            list = [];
+            this.#listeners.set(type, list);
+        }
+        list.push({
+            callback: listener,
+            once: (options !== true && options !== false && options?.once) ?? false
+        });
+    }
+    removeEventListener(type, listener, options) {
+        super.removeEventListener(type.toString(), listener ?? null, options);
+        let list = this.#listeners.get(type);
+        if (list == null) {
+            return;
+        }
+        list = list.filter(({ callback }) => callback !== listener);
+        this.#listeners.set(type, list);
+    }
+    dispatchEvent(event) {
+        const result = super.dispatchEvent(event);
+        let list = this.#listeners.get(event.type);
+        if (list == null) {
+            return result;
+        }
+        list = list.filter(({ once }) => !once);
+        this.#listeners.set(event.type, list);
+        return result;
+    }
+    safeDispatchEvent(type, detail) {
+        return this.dispatchEvent(new CustomEvent(type, detail));
+    }
+}
+/**
+ * CustomEvent is a standard event but it's not supported by node.
+ *
+ * Remove this when https://github.com/nodejs/node/issues/40678 is closed.
+ *
+ * Ref: https://developer.mozilla.org/en-US/docs/Web/API/CustomEvent
+ */
+class CustomEventPolyfill extends Event {
+    /** Returns any custom data event was created with. Typically used for synthetic events. */
+    detail;
+    constructor(message, data) {
+        super(message, data);
+        // @ts-expect-error could be undefined
+        this.detail = data?.detail;
+    }
+}
+export const CustomEvent = globalThis.CustomEvent ?? CustomEventPolyfill;
+//# sourceMappingURL=events.js.map

package/dist/src/events.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","sourceRoot":"","sources":["../../src/events.ts"],"names":[],"mappings":"AASA;;;;;;;GAOG;AACH,MAAM,OAAO,YAAmD,SAAQ,WAAW;IACjF,UAAU,GAAG,IAAI,GAAG,EAAmB,CAAA;IAEvC,aAAa,CAAE,IAAY;QACzB,MAAM,SAAS,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAE3C,IAAI,SAAS,IAAI,IAAI,EAAE;YACrB,OAAO,CAAC,CAAA;SACT;QAED,OAAO,SAAS,CAAC,MAAM,CAAA;IACzB,CAAC;IAGD,gBAAgB,CAAE,IAAY,EAAE,QAA6B,EAAE,OAA2C;QACxG,KAAK,CAAC,gBAAgB,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,CAAC,CAAA;QAE/C,IAAI,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAEpC,IAAI,IAAI,IAAI,IAAI,EAAE;YAChB,IAAI,GAAG,EAAE,CAAA;YACT,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;SAChC;QAED,IAAI,CAAC,IAAI,CAAC;YACR,QAAQ,EAAE,QAAQ;YAClB,IAAI,EAAE,CAAC,OAAO,KAAK,IAAI,IAAI,OAAO,KAAK,KAAK,IAAI,OAAO,EAAE,IAAI,CAAC,IAAI,KAAK;SACxE,CAAC,CAAA;IACJ,CAAC;IAGD,mBAAmB,CAAE,IAAY,EAAE,QAA8B,EAAE,OAAwC;QACzG,KAAK,CAAC,mBAAmB,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE,QAAQ,IAAI,IAAI,EAAE,OAAO,CAAC,CAAA;QAErE,IAAI,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAA;QAEpC,IAAI,IAAI,IAAI,IAAI,EAAE;YAChB,OAAM;SACP;QAED,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,QAAQ,EAAE,EAAE,EAAE,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAA;QAC3D,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;IACjC,CAAC;IAED,aAAa,CAAE,KAAY;QACzB,MAAM,MAAM,GAAG,KAAK,CAAC,aAAa,CAAC,KAAK,CAAC,CAAA;QAEzC,IAAI,IAAI,GAAG,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAA;QAE1C,IAAI,IAAI,IAAI,IAAI,EAAE;YAChB,OAAO,MAAM,CAAA;SACd;QAED,IAAI,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,EAAE,IAAI,EAAE,EAAE,EAAE,CAAC,CAAC,IAAI,CAAC,CAAA;QACvC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,KAAK,CAAC,IAAI,EAAE,IAAI,CAAC,CAAA;QAErC,OAAO,MAAM,CAAA;IACf,CAAC;IAED,iBAAiB,CAAS,IAAoB,EAAE,MAA+B;QAC7E,OAAO,IAAI,CAAC,aAAa,CAAC,IAAI,WAAW,CAAS,IAAc,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5E,CAAC;CACF;AAED;;;;;;GAMG;AACH,MAAM,mBAA6B,SAAQ,KAAK;IAC9C,2FAA2F;IACpF,MAAM,CAAG;IAEhB,YAAa,OAAe,EAAE,IAAgC;QAC5D,KAAK,CAAC,OAAO,EAAE,IAAI,CAAC,CAAA;QACpB,sCAAsC;QACtC,IAAI,CAAC,MAAM,GAAG,IAAI,EAAE,MAAM,CAAA;IAC5B,CAAC;CACF;AAED,MAAM,CAAC,MAAM,WAAW,GAAG,UAAU,CAAC,WAAW,IAAI,mBAAmB,CAAA"}

package/dist/src/index.d.ts

@@ -0,0 +1,575 @@
+/**
+ * @packageDocumentation
+ *
+ * Exports a `Libp2p` type for modules to use as a type argument.
+ *
+ * @example
+ *
+ * ```typescript
+ * import type { Libp2p } from '@libp2p/interface'
+ *
+ * function doSomethingWithLibp2p (node: Libp2p) {
+ *   // ...
+ * }
+ * ```
+ */
+import type { Connection, Stream } from './connection/index.js';
+import type { ContentRouting } from './content-routing/index.js';
+import type { EventEmitter } from './events.js';
+import type { KeyChain } from './keychain/index.js';
+import type { Metrics } from './metrics/index.js';
+import type { PeerId } from './peer-id/index.js';
+import type { PeerInfo } from './peer-info/index.js';
+import type { PeerRouting } from './peer-routing/index.js';
+import type { Address, Peer, PeerStore } from './peer-store/index.js';
+import type { Startable } from './startable.js';
+import type { StreamHandler, StreamHandlerOptions } from './stream-handler/index.js';
+import type { Topology } from './topology/index.js';
+import type { Listener } from './transport/index.js';
+import type { Multiaddr } from '@multiformats/multiaddr';
+/**
+ * Used by the connection manager to sort addresses into order before dialling
+ */
+export interface AddressSorter {
+    (a: Address, b: Address): -1 | 0 | 1;
+}
+/**
+ * Event detail emitted when peer data changes
+ */
+export interface PeerUpdate {
+    peer: Peer;
+    previous?: Peer;
+}
+/**
+ * Peer data signed by the remote Peer's public key
+ */
+export interface SignedPeerRecord {
+    addresses: Multiaddr[];
+    seq: bigint;
+}
+/**
+ * Data returned from a successful identify response
+ */
+export interface IdentifyResult {
+    /**
+     * The remote Peer's PeerId
+     */
+    peerId: PeerId;
+    /**
+     * The unsigned addresses they are listening on. Note - any multiaddrs present
+     * in the signed peer record should be preferred to the value here.
+     */
+    listenAddrs: Multiaddr[];
+    /**
+     * The protocols the remote peer supports
+     */
+    protocols: string[];
+    /**
+     * The remote protocol version
+     */
+    protocolVersion?: string;
+    /**
+     * The remote agent version
+     */
+    agentVersion?: string;
+    /**
+     * The public key part of the remote PeerId - this is only useful for older
+     * RSA-based PeerIds, the more modern Ed25519 and secp256k1 types have the
+     * public key embedded in them
+     */
+    publicKey?: Uint8Array;
+    /**
+     * If set this is the address that the remote peer saw the identify request
+     * originate from
+     */
+    observedAddr?: Multiaddr;
+    /**
+     * If sent by the remote peer this is the deserialized signed peer record
+     */
+    signedPeerRecord?: SignedPeerRecord;
+}
+/**
+ * Once you have a libp2p instance, you can listen to several events it emits,
+ * so that you can be notified of relevant network events.
+ *
+ * Event names are `noun:verb` so the first part is the name of the object
+ * being acted on and the second is the action.
+ */
+export interface Libp2pEvents<T extends ServiceMap = ServiceMap> {
+    /**
+     * This event is dispatched when a new network peer is discovered.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.addEventListener('peer:discovery', (event) => {
+     *    const peerInfo = event.detail
+     *    // ...
+     * })
+     * ```
+     */
+    'peer:discovery': CustomEvent<PeerInfo>;
+    /**
+     * This event will be triggered any time a new peer connects.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.addEventListener('peer:connect', (event) => {
+     *   const peerId = event.detail
+     *   // ...
+     * })
+     * ```
+     */
+    'peer:connect': CustomEvent<PeerId>;
+    /**
+     * This event will be triggered any time we are disconnected from another peer, regardless of
+     * the circumstances of that disconnection. If we happen to have multiple connections to a
+     * peer, this event will **only** be triggered when the last connection is closed.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.addEventListener('peer:disconnect', (event) => {
+     *   const peerId = event.detail
+     *   // ...
+     * })
+     * ```
+     */
+    'peer:disconnect': CustomEvent<PeerId>;
+    /**
+     * This event is dispatched after a remote peer has successfully responded to the identify
+     * protocol. Note that for this to be emitted, both peers must have an identify service
+     * configured.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.addEventListener('peer:identify', (event) => {
+     *   const identifyResult = event.detail
+     *   // ...
+     * })
+     * ```
+     */
+    'peer:identify': CustomEvent<IdentifyResult>;
+    /**
+     * This event is dispatched when the peer store data for a peer has been
+     * updated - e.g. their multiaddrs, protocols etc have changed.
+     *
+     * If they were previously known to this node, the old peer data will be
+     * set in the `previous` field.
+     *
+     * This may be in response to the identify protocol running, a manual
+     * update or some other event.
+     */
+    'peer:update': CustomEvent<PeerUpdate>;
+    /**
+     * This event is dispatched when the current node's peer record changes -
+     * for example a transport started listening on a new address or a new
+     * protocol handler was registered.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.addEventListener('self:peer:update', (event) => {
+     *   const { peer } = event.detail
+     *   // ...
+     * })
+     * ```
+     */
+    'self:peer:update': CustomEvent<PeerUpdate>;
+    /**
+     * This event is dispatched when a transport begins listening on a new address
+     */
+    'transport:listening': CustomEvent<Listener>;
+    /**
+     * This event is dispatched when a transport stops listening on an address
+     */
+    'transport:close': CustomEvent<Listener>;
+    /**
+     * This event is dispatched when the connection manager has more than the
+     * configured allowable max connections and has closed some connections to
+     * bring the node back under the limit.
+     */
+    'connection:prune': CustomEvent<Connection[]>;
+    /**
+     * This event notifies listeners when new incoming or outgoing connections
+     * are opened.
+     */
+    'connection:open': CustomEvent<Connection>;
+    /**
+     * This event notifies listeners when incoming or outgoing connections are
+     * closed.
+     */
+    'connection:close': CustomEvent<Connection>;
+    /**
+     * This event notifies listeners that the node has started
+     *
+     * ```js
+     * libp2p.addEventListener('start', (event) => {
+     *   console.info(libp2p.isStarted()) // true
+     * })
+     * ```
+     */
+    'start': CustomEvent<Libp2p<T>>;
+    /**
+     * This event notifies listeners that the node has stopped
+     *
+     * ```js
+     * libp2p.addEventListener('stop', (event) => {
+     *   console.info(libp2p.isStarted()) // false
+     * })
+     * ```
+     */
+    'stop': CustomEvent<Libp2p<T>>;
+}
+/**
+ * A map of user defined services available on the libp2p node via the
+ * `services` key
+ *
+ * @example
+ *
+ * ```js
+ * const node = await createLibp2p({
+ *   // ...other options
+ *   services: {
+ *     myService: myService({
+ *       // ...service options
+ *     })
+ *   }
+ * })
+ *
+ * // invoke methods on the service
+ * node.services.myService.anOperation()
+ * ```
+ */
+export type ServiceMap = Record<string, unknown>;
+export type PendingDialStatus = 'queued' | 'active' | 'error' | 'success';
+/**
+ * An item in the dial queue
+ */
+export interface PendingDial {
+    /**
+     * A unique identifier for this dial
+     */
+    id: string;
+    /**
+     * The current status of the dial
+     */
+    status: PendingDialStatus;
+    /**
+     * If known, this is the peer id that libp2p expects to be dialling
+     */
+    peerId?: PeerId;
+    /**
+     * The list of multiaddrs that will be dialled. The returned connection will
+     * use the first address that succeeds, all other dials part of this pending
+     * dial will be cancelled.
+     */
+    multiaddrs: Multiaddr[];
+}
+/**
+ * Libp2p nodes implement this interface.
+ */
+export interface Libp2p<T extends ServiceMap = ServiceMap> extends Startable, EventEmitter<Libp2pEvents<T>> {
+    /**
+     * The PeerId is a unique identifier for a node on the network.
+     *
+     * It is the hash of an RSA public key or, for Ed25519 or secp256k1 keys,
+     * the key itself.
+     *
+     * @example
+     *
+     * ```js
+     * console.info(libp2p.peerId)
+     * // PeerId(12D3Foo...)
+     * ````
+     */
+    peerId: PeerId;
+    /**
+     * The peer store holds information we know about other peers on the network.
+     * - multiaddrs, supported protocols, etc.
+     *
+     * @example
+     *
+     * ```js
+     * const peer = await libp2p.peerStore.get(peerId)
+     * console.info(peer)
+     * // { id: PeerId(12D3Foo...), addresses: [] ... }
+     * ```
+     */
+    peerStore: PeerStore;
+    /**
+     * The peer routing subsystem allows the user to find peers on the network
+     * or to find peers close to binary keys.
+     *
+     * @example
+     *
+     * ```js
+     * const peerInfo = await libp2p.peerRouting.findPeer(peerId)
+     * console.info(peerInfo)
+     * // { id: PeerId(12D3Foo...), multiaddrs: [] ... }
+     * ```
+     *
+     * @example
+     *
+     * ```js
+     * for await (const peerInfo of libp2p.peerRouting.getClosestPeers(key)) {
+     *   console.info(peerInfo)
+     *   // { id: PeerId(12D3Foo...), multiaddrs: [] ... }
+     * }
+     * ```
+     */
+    peerRouting: PeerRouting;
+    /**
+     * The content routing subsystem allows the user to find providers for content,
+     * let the network know they are providers for content, and get/put values to
+     * the DHT.
+     *
+     * @example
+     *
+     * ```js
+     * for await (const peerInfo of libp2p.contentRouting.findProviders(cid)) {
+     *   console.info(peerInfo)
+     *   // { id: PeerId(12D3Foo...), multiaddrs: [] ... }
+     * }
+     * ```
+     */
+    contentRouting: ContentRouting;
+    /**
+     * The keychain contains the keys used by the current node, and can create new
+     * keys, export them, import them, etc.
+     *
+     * @example
+     *
+     * ```js
+     * const keyInfo = await libp2p.keychain.createKey('new key')
+     * console.info(keyInfo)
+     * // { id: '...', name: 'new key' }
+     * ```
+     */
+    keychain: KeyChain;
+    /**
+     * The metrics subsystem allows recording values to assess the health/performance
+     * of the running node.
+     *
+     * @example
+     *
+     * ```js
+     * const metric = libp2p.metrics.registerMetric({
+     *   'my-metric'
+     * })
+     *
+     * // later
+     * metric.update(5)
+     * ```
+     */
+    metrics?: Metrics;
+    /**
+     * Get a deduplicated list of peer advertising multiaddrs by concatenating
+     * the listen addresses used by transports with any configured
+     * announce addresses as well as observed addresses reported by peers.
+     *
+     * If Announce addrs are specified, configured listen addresses will be
+     * ignored though observed addresses will still be included.
+     *
+     * @example
+     *
+     * ```js
+     * const listenMa = libp2p.getMultiaddrs()
+     * // [ <Multiaddr 047f00000106f9ba - /ip4/127.0.0.1/tcp/63930> ]
+     * ```
+     */
+    getMultiaddrs: () => Multiaddr[];
+    /**
+     * Returns a list of supported protocols
+     *
+     * @example
+     *
+     * ```js
+     * const protocols = libp2p.getProtocols()
+     * // [ '/ipfs/ping/1.0.0', '/ipfs/id/1.0.0' ]
+     * ```
+     */
+    getProtocols: () => string[];
+    /**
+     * Return a list of all connections this node has open, optionally filtering
+     * by a PeerId
+     *
+     * @example
+     *
+     * ```js
+     * for (const connection of libp2p.getConnections()) {
+     *   console.log(peerId, connection.remoteAddr.toString())
+     *   // Logs the PeerId string and the observed remote multiaddr of each Connection
+     * }
+     * ```
+     */
+    getConnections: (peerId?: PeerId) => Connection[];
+    /**
+     * Return the list of dials currently in progress or queued to start
+     *
+     * @example
+     *
+     * ```js
+     * for (const pendingDial of libp2p.getDialQueue()) {
+     *   console.log(pendingDial)
+     * }
+     * ```
+     */
+    getDialQueue: () => PendingDial[];
+    /**
+     * Return a list of all peers we currently have a connection open to
+     */
+    getPeers: () => PeerId[];
+    /**
+     * Dials to the provided peer. If successful, the known metadata of the
+     * peer will be added to the nodes `peerStore`.
+     *
+     * If a PeerId is passed as the first argument, the peer will need to have known multiaddrs for it in the PeerStore.
+     *
+     * @example
+     *
+     * ```js
+     * const conn = await libp2p.dial(remotePeerId)
+     *
+     * // create a new stream within the connection
+     * const { stream, protocol } = await conn.newStream(['/echo/1.1.0', '/echo/1.0.0'])
+     *
+     * // protocol negotiated: 'echo/1.0.0' means that the other party only supports the older version
+     *
+     * // ...
+     * await conn.close()
+     * ```
+     */
+    dial: (peer: PeerId | Multiaddr | Multiaddr[], options?: AbortOptions) => Promise<Connection>;
+    /**
+     * Dials to the provided peer and tries to handshake with the given protocols in order.
+     * If successful, the known metadata of the peer will be added to the nodes `peerStore`,
+     * and the `MuxedStream` will be returned together with the successful negotiated protocol.
+     *
+     * @example
+     *
+     * ```js
+     * import { pipe } from 'it-pipe'
+     *
+     * const { stream, protocol } = await libp2p.dialProtocol(remotePeerId, protocols)
+     *
+     * // Use this new stream like any other duplex stream
+     * pipe([1, 2, 3], stream, consume)
+     * ```
+     */
+    dialProtocol: (peer: PeerId | Multiaddr | Multiaddr[], protocols: string | string[], options?: AbortOptions) => Promise<Stream>;
+    /**
+     * Attempts to gracefully close an open connection to the given peer. If the connection is not closed in the grace period, it will be forcefully closed.
+     *
+     * @example
+     *
+     * ```js
+     * await libp2p.hangUp(remotePeerId)
+     * ```
+     */
+    hangUp: (peer: PeerId | Multiaddr) => Promise<void>;
+    /**
+     * Sets up [multistream-select routing](https://github.com/multiformats/multistream-select) of protocols to their application handlers. Whenever a stream is opened on one of the provided protocols, the handler will be called. `handle` must be called in order to register a handler and support for a given protocol. This also informs other peers of the protocols you support.
+     *
+     * `libp2p.handle(protocols, handler, options)`
+     *
+     * In the event of a new handler for the same protocol being added, the first one is discarded.
+     *
+     * @example
+     *
+     * ```js
+     * const handler = ({ connection, stream, protocol }) => {
+     *   // use stream or connection according to the needs
+     * }
+     *
+     * libp2p.handle('/echo/1.0.0', handler, {
+     *   maxInboundStreams: 5,
+     *   maxOutboundStreams: 5
+     * })
+     * ```
+     */
+    handle: (protocol: string | string[], handler: StreamHandler, options?: StreamHandlerOptions) => Promise<void>;
+    /**
+     * Removes the handler for each protocol. The protocol
+     * will no longer be supported on streams.
+     *
+     * @example
+     *
+     * ```js
+     * libp2p.unhandle(['/echo/1.0.0'])
+     * ```
+     */
+    unhandle: (protocols: string[] | string) => Promise<void>;
+    /**
+     * Register a topology to be informed when peers are encountered that
+     * support the specified protocol
+     *
+     * @example
+     *
+     * ```js
+     * const id = await libp2p.register('/echo/1.0.0', {
+     *   onConnect: (peer, connection) => {
+     *     // handle connect
+     *   },
+     *   onDisconnect: (peer, connection) => {
+     *     // handle disconnect
+     *   }
+     * })
+     * ```
+     */
+    register: (protocol: string, topology: Topology) => Promise<string>;
+    /**
+     * Unregister topology to no longer be informed when peers connect or
+     * disconnect.
+     *
+     * @example
+     *
+     * ```js
+     * const id = await libp2p.register(...)
+     *
+     * libp2p.unregister(id)
+     * ```
+     */
+    unregister: (id: string) => void;
+    /**
+     * Returns the public key for the passed PeerId. If the PeerId is of the 'RSA' type
+     * this may mean searching the DHT if the key is not present in the KeyStore.
+     * A set of user defined services
+     */
+    getPublicKey: (peer: PeerId, options?: AbortOptions) => Promise<Uint8Array>;
+    /**
+     * A set of user defined services
+     */
+    services: T;
+}
+/**
+ * An object that contains an AbortSignal as
+ * the optional `signal` property.
+ *
+ * @example
+ *
+ * ```js
+ * const controller = new AbortController()
+ *
+ * aLongRunningOperation({
+ *   signal: controller.signal
+ * })
+ *
+ * // later
+ *
+ * controller.abort()
+ */
+export interface AbortOptions {
+    signal?: AbortSignal;
+}
+/**
+ * Returns a new type with all fields marked optional.
+ *
+ * Borrowed from the tsdef module.
+ */
+export type RecursivePartial<T> = {
+    [P in keyof T]?: T[P] extends Array<infer I> ? Array<RecursivePartial<I>> : T[P] extends (...args: any[]) => any ? T[P] : RecursivePartial<T[P]>;
+};
+//# sourceMappingURL=index.d.ts.map

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

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