@libp2p/interface-internal 0.0.1-05abd49f → 0.0.1-1f7e18b0

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

@@ -1,15 +1,8 @@
-import type { AbortOptions } from '@libp2p/interface';
+import type { AbortOptions, PendingDial } from '@libp2p/interface';
 import type { Connection, MultiaddrConnection } from '@libp2p/interface/connection';
 import type { PeerId } from '@libp2p/interface/peer-id';
 import type { PeerMap } from '@libp2p/peer-collections';
 import type { Multiaddr } from '@multiformats/multiaddr';
-export type PendingDialStatus = 'queued' | 'active' | 'error' | 'success';
-export interface PendingDial {
-    id: string;
-    status: PendingDialStatus;
-    peerId?: PeerId;
-    multiaddrs: Multiaddr[];
-}
 export interface ConnectionManager {
     /**
      * Return connections, optionally filtering by a PeerId
@@ -45,7 +38,7 @@ export interface ConnectionManager {
     /**
      * Close our connections to a peer
      */
-    closeConnections: (peer: PeerId) => Promise<void>;
+    closeConnections: (peer: PeerId, options?: AbortOptions) => Promise<void>;
     /**
      * Invoked after an incoming connection is opened but before PeerIds are
      * exchanged, this lets the ConnectionManager check we have sufficient

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection-manager/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mBAAmB,CAAA;AACrD,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AACnF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD,MAAM,MAAM,iBAAiB,GAAG,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,SAAS,CAAA;AAEzE,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE,MAAM,CAAA;IACV,MAAM,EAAE,iBAAiB,CAAA;IACzB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,UAAU,EAAE,SAAS,EAAE,CAAA;CACxB;AAED,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;;OASG;IACH,cAAc,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,UAAU,EAAE,CAAA;IAEjD;;;;;;;;OAQG;IACH,iBAAiB,EAAE,MAAM,OAAO,CAAC,UAAU,EAAE,CAAC,CAAA;IAE9C;;;;;;;;OAQG;IACH,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;IAEvG;;OAEG;IACH,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAEjD;;;;;OAKG;IACH,wBAAwB,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAE3E;;OAEG;IACH,mBAAmB,EAAE,MAAM,IAAI,CAAA;IAE/B;;;;;;;;OAQG;IACH,YAAY,EAAE,MAAM,WAAW,EAAE,CAAA;CAClC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/connection-manager/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAA;AAClE,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AACnF,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,2BAA2B,CAAA;AACvD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAA;AACvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAA;AAExD,MAAM,WAAW,iBAAiB;IAChC;;;;;;;;;OASG;IACH,cAAc,EAAE,CAAC,MAAM,CAAC,EAAE,MAAM,KAAK,UAAU,EAAE,CAAA;IAEjD;;;;;;;;OAQG;IACH,iBAAiB,EAAE,MAAM,OAAO,CAAC,UAAU,EAAE,CAAC,CAAA;IAE9C;;;;;;;;OAQG;IACH,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,SAAS,EAAE,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;IAEvG;;OAEG;IACH,gBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,YAAY,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAEzE;;;;;OAKG;IACH,wBAAwB,EAAE,CAAC,MAAM,EAAE,mBAAmB,KAAK,OAAO,CAAC,OAAO,CAAC,CAAA;IAE3E;;OAEG;IACH,mBAAmB,EAAE,MAAM,IAAI,CAAA;IAE/B;;;;;;;;OAQG;IACH,YAAY,EAAE,MAAM,WAAW,EAAE,CAAA;CAClC"}

package/dist/src/index.d.ts

@@ -1,548 +1,2 @@
-/**
- * @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 { StreamHandler, StreamHandlerOptions } from './registrar/index.js';
-import type { AbortOptions } from '@libp2p/interface';
-import type { Connection, Stream } from '@libp2p/interface/connection';
-import type { ContentRouting } from '@libp2p/interface/content-routing';
-import type { EventEmitter } from '@libp2p/interface/events';
-import type { KeyChain } from '@libp2p/interface/keychain';
-import type { Metrics } from '@libp2p/interface/metrics';
-import type { PeerId } from '@libp2p/interface/peer-id';
-import type { PeerInfo } from '@libp2p/interface/peer-info';
-import type { PeerRouting } from '@libp2p/interface/peer-routing';
-import type { Address, Peer, PeerStore } from '@libp2p/interface/peer-store';
-import type { Startable } from '@libp2p/interface/startable';
-import type { Topology } from '@libp2p/interface/topology';
-import type { Listener } from '@libp2p/interface/transport';
-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;
-}
+export {};
 //# sourceMappingURL=index.d.ts.map

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

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

package/dist/src/index.js

@@ -1,17 +1,2 @@
-/**
- * @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) {
- *   // ...
- * }
- * ```
- */
 export {};
 //# sourceMappingURL=index.js.map

package/dist/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAA"}

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

@@ -16,6 +16,12 @@ export interface StreamHandlerOptions {
      * How many outgoing streams can be open for this protocol at the same time on each connection (default: 64)
      */
     maxOutboundStreams?: number;
+    /**
+     * If true, allow this protocol to run on limited connections (e.g.
+     * connections with data or duration limits such as circuit relay
+     * connections) (default: false)
+     */
+    runOnTransientConnection?: boolean;
 }
 export interface StreamHandlerRecord {
     handler: StreamHandler;

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

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/registrar/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAA;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AAE1D,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,UAAU,CAAA;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAAA;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAE1B;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,aAAa,CAAA;IACtB,OAAO,EAAE,oBAAoB,CAAA;CAC9B;AAED,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,YAAY,EAAE,MAAM,MAAM,EAAE,CAAA;IAE5B;;OAEG;IACH,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAEnG;;OAEG;IACH,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAE7C;;OAEG;IACH,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,mBAAmB,CAAA;IAErD;;;;;;;OAOG;IACH,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAEnE;;OAEG;IACH,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IAEhC;;;OAGG;IACH,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,QAAQ,EAAE,CAAA;CAChD"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/registrar/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,EAAE,MAAM,8BAA8B,CAAA;AACtE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,4BAA4B,CAAA;AAE1D,MAAM,WAAW,kBAAkB;IACjC,MAAM,EAAE,MAAM,CAAA;IACd,UAAU,EAAE,UAAU,CAAA;CACvB;AAED,MAAM,WAAW,aAAa;IAC5B,CAAC,IAAI,EAAE,kBAAkB,GAAG,IAAI,CAAA;CACjC;AAED,MAAM,WAAW,oBAAoB;IACnC;;OAEG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAE1B;;OAEG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAE3B;;;;OAIG;IACH,wBAAwB,CAAC,EAAE,OAAO,CAAA;CACnC;AAED,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,aAAa,CAAA;IACtB,OAAO,EAAE,oBAAoB,CAAA;CAC9B;AAED,MAAM,WAAW,SAAS;IACxB;;OAEG;IACH,YAAY,EAAE,MAAM,MAAM,EAAE,CAAA;IAE5B;;OAEG;IACH,MAAM,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,aAAa,EAAE,OAAO,CAAC,EAAE,oBAAoB,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAEnG;;OAEG;IACH,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAE7C;;OAEG;IACH,UAAU,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,mBAAmB,CAAA;IAErD;;;;;;;OAOG;IACH,QAAQ,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,QAAQ,KAAK,OAAO,CAAC,MAAM,CAAC,CAAA;IAEnE;;OAEG;IACH,UAAU,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,IAAI,CAAA;IAEhC;;;OAGG;IACH,aAAa,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,QAAQ,EAAE,CAAA;CAChD"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/interface-internal",
-  "version": "0.0.1-05abd49f",
+  "version": "0.0.1-1f7e18b0",
   "description": "Interfaces implemented by internal libp2p components",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/master/packages/interface-internal#readme",
@@ -60,10 +60,6 @@
       "types": "./dist/src/registrar/index.d.ts",
       "import": "./dist/src/registrar/index.js"
     },
-    "./transport": {
-      "types": "./dist/src/transport/index.d.ts",
-      "import": "./dist/src/transport/index.js"
-    },
     "./transport-manager": {
       "types": "./dist/src/transport-manager/index.d.ts",
       "import": "./dist/src/transport-manager/index.js"
@@ -82,15 +78,12 @@
     "build": "aegir build"
   },
   "dependencies": {
-    "@libp2p/interface": "0.0.1-05abd49f",
-    "@libp2p/peer-collections": "3.0.2-05abd49f",
+    "@libp2p/interface": "0.0.1-1f7e18b0",
+    "@libp2p/peer-collections": "3.0.2-1f7e18b0",
     "@multiformats/multiaddr": "^12.1.3",
     "uint8arraylist": "^2.4.3"
   },
   "devDependencies": {
-    "aegir": "^39.0.10"
-  },
-  "typedoc": {
-    "entryPoint": "./src/index.ts"
+    "aegir": "^40.0.1"
   }
 }

package/src/connection-manager/index.ts

@@ -1,18 +1,9 @@
-import type { AbortOptions } from '@libp2p/interface'
+import type { AbortOptions, PendingDial } from '@libp2p/interface'
 import type { Connection, MultiaddrConnection } from '@libp2p/interface/connection'
 import type { PeerId } from '@libp2p/interface/peer-id'
 import type { PeerMap } from '@libp2p/peer-collections'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-export type PendingDialStatus = 'queued' | 'active' | 'error' | 'success'
-
-export interface PendingDial {
-  id: string
-  status: PendingDialStatus
-  peerId?: PeerId
-  multiaddrs: Multiaddr[]
-}
-
 export interface ConnectionManager {
   /**
    * Return connections, optionally filtering by a PeerId
@@ -51,7 +42,7 @@ export interface ConnectionManager {
   /**
    * Close our connections to a peer
    */
-  closeConnections: (peer: PeerId) => Promise<void>
+  closeConnections: (peer: PeerId, options?: AbortOptions) => Promise<void>
 
   /**
    * Invoked after an incoming connection is opened but before PeerIds are

package/src/index.ts

@@ -1,598 +1 @@
-/**
- * @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 { StreamHandler, StreamHandlerOptions } from './registrar/index.js'
-import type { AbortOptions } from '@libp2p/interface'
-import type { Connection, Stream } from '@libp2p/interface/connection'
-import type { ContentRouting } from '@libp2p/interface/content-routing'
-import type { EventEmitter } from '@libp2p/interface/events'
-import type { KeyChain } from '@libp2p/interface/keychain'
-import type { Metrics } from '@libp2p/interface/metrics'
-import type { PeerId } from '@libp2p/interface/peer-id'
-import type { PeerInfo } from '@libp2p/interface/peer-info'
-import type { PeerRouting } from '@libp2p/interface/peer-routing'
-import type { Address, Peer, PeerStore } from '@libp2p/interface/peer-store'
-import type { Startable } from '@libp2p/interface/startable'
-import type { Topology } from '@libp2p/interface/topology'
-import type { Listener } from '@libp2p/interface/transport'
-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
-}
+export {}

package/src/registrar/index.ts

@@ -20,6 +20,13 @@ export interface StreamHandlerOptions {
    * How many outgoing streams can be open for this protocol at the same time on each connection (default: 64)
    */
   maxOutboundStreams?: number
+
+  /**
+   * If true, allow this protocol to run on limited connections (e.g.
+   * connections with data or duration limits such as circuit relay
+   * connections) (default: false)
+   */
+  runOnTransientConnection?: boolean
 }
 
 export interface StreamHandlerRecord {

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

@@ -1,18 +0,0 @@
-import type { Connection, MultiaddrConnection } from '@libp2p/interface/connection';
-import type { StreamMuxerFactory } from '@libp2p/interface/stream-muxer';
-export interface UpgraderOptions {
-    skipEncryption?: boolean;
-    skipProtection?: boolean;
-    muxerFactory?: StreamMuxerFactory;
-}
-export interface Upgrader {
-    /**
-     * Upgrades an outbound connection on `transport.dial`.
-     */
-    upgradeOutbound: (maConn: MultiaddrConnection, opts?: UpgraderOptions) => Promise<Connection>;
-    /**
-     * Upgrades an inbound connection on transport listener.
-     */
-    upgradeInbound: (maConn: MultiaddrConnection, opts?: UpgraderOptions) => Promise<Connection>;
-}
-//# sourceMappingURL=index.d.ts.map

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/upgrader/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA;AACnF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAA;AAExE,MAAM,WAAW,eAAe;IAC9B,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,YAAY,CAAC,EAAE,kBAAkB,CAAA;CAClC;AAED,MAAM,WAAW,QAAQ;IACvB;;OAEG;IACH,eAAe,EAAE,CAAC,MAAM,EAAE,mBAAmB,EAAE,IAAI,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;IAE7F;;OAEG;IACH,cAAc,EAAE,CAAC,MAAM,EAAE,mBAAmB,EAAE,IAAI,CAAC,EAAE,eAAe,KAAK,OAAO,CAAC,UAAU,CAAC,CAAA;CAC7F"}

package/dist/src/upgrader/index.js

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=index.js.map

package/dist/src/upgrader/index.js.map

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

package/src/upgrader/index.ts

@@ -1,20 +0,0 @@
-import type { Connection, MultiaddrConnection } from '@libp2p/interface/connection'
-import type { StreamMuxerFactory } from '@libp2p/interface/stream-muxer'
-
-export interface UpgraderOptions {
-  skipEncryption?: boolean
-  skipProtection?: boolean
-  muxerFactory?: StreamMuxerFactory
-}
-
-export interface Upgrader {
-  /**
-   * Upgrades an outbound connection on `transport.dial`.
-   */
-  upgradeOutbound: (maConn: MultiaddrConnection, opts?: UpgraderOptions) => Promise<Connection>
-
-  /**
-   * Upgrades an inbound connection on transport listener.
-   */
-  upgradeInbound: (maConn: MultiaddrConnection, opts?: UpgraderOptions) => Promise<Connection>
-}