@libp2p/interface 2.11.0 → 3.0.0-049bfa0fa

package/dist/src/stream-muxer.d.ts

@@ -1,59 +1,142 @@
-import type { Direction, Stream } from './connection.js';
-import type { AbortOptions, Logger } from './index.js';
-import type { Duplex } from 'it-stream-types';
-import type { Uint8ArrayList } from 'uint8arraylist';
-export interface StreamMuxerFactory {
+import type { Stream, TypedEventTarget, MessageStream, AbortOptions } from './index.js';
+/**
+ * User-facing message stream muxer options
+ */
+export interface StreamMuxerOptions<MuxedStreamOptions extends StreamOptions = StreamOptions> {
     /**
-     * The protocol used to select this muxer during connection opening
+     * Configuration options for each outgoing/incoming stream
      */
-    protocol: string;
+    streamOptions?: MuxedStreamOptions;
     /**
-     * Creates a new stream muxer to be used with a new connection
+     * libp2p is notified of incoming streams via the muxer's 'stream' event.
+     *
+     * During connection establishment there may be a small window where a muxer
+     * starts to process incoming stream data before a listener has been added for
+     * the 'stream' event.
+     *
+     * If no handler is registered for this event incoming streams can be missed
+     * so when this is the case muxers queue streams internally as "early
+     * streams", and will defer emitting the 'stream' event until after a listener
+     * has been registered.
+     *
+     * Allowing an unlimited amount of early streams can cause excessive memory
+     * consumption so this setting controls how many early streams to store when
+     * no 'stream' listener has been registered.
+     *
+     * If more streams than this are opened before a listener is added the muxed
+     * connection will be reset.
+     *
+     * @default 10
+     */
+    maxEarlyStreams?: number;
+    /**
+     * Maximum size of a message in bytes that we'll send on a stream - this
+     * ensures that a single stream doesn't hog a connection
+     *
+     * @default 65_536
+     */
+    maxMessageSize?: number;
+    /**
+     * Maximum number of concurrent inbound streams that we accept - if the peer
+     * tries to open more streams, those will be reset immediately
+     *
+     * @default 1_000
      */
-    createStreamMuxer(init?: StreamMuxerInit): StreamMuxer;
+    maxInboundStreams?: number;
+    /**
+     * Maximum number of concurrent outbound streams that we accept - if the
+     * application tries to open more streams, the call to `newStream` will throw
+     *
+     * @default 1_000
+     */
+    maxOutboundStreams?: number;
 }
 /**
- * A libp2p stream muxer
+ * User-facing message stream options
  */
-export interface StreamMuxer extends Duplex<AsyncGenerator<Uint8Array | Uint8ArrayList>> {
+export interface StreamOptions {
+    /**
+     * If no data is sent or received in this number of ms the stream will be
+     * reset and an 'error' event emitted.
+     *
+     * @default 120_000
+     */
+    inactivityTimeout?: number;
+    /**
+     * The maximum number of bytes to store when paused or before a 'message'
+     * event handler is added.
+     *
+     * If the internal buffer overflows this value the stream will be reset.
+     *
+     * @default 4_194_304
+     */
+    maxReadBufferLength?: number;
+    /**
+     * The maximum number of bytes to store when the remote end of the stream is
+     * applying backpressure, or when it is slow to accept new bytes.
+     *
+     * If the internal buffer overflows this value the stream will be reset.
+     *
+     * @default Infinity
+     */
+    maxWriteBufferLength?: number;
+}
+export interface StreamMuxerFactory<Muxer extends StreamMuxer = StreamMuxer> {
     /**
      * The protocol used to select this muxer during connection opening
      */
     protocol: string;
     /**
-     * A list of streams that are currently open. Closed streams will not be returned.
+     * Creates a new stream muxer to be used with a new connection
      */
-    readonly streams: Stream[];
+    createStreamMuxer(maConn: MessageStream): Muxer;
+}
+export interface StreamMuxerEvents<MuxedStream extends Stream = Stream> {
     /**
-     * Initiate a new stream with the given name. If no name is
-     * provided, the id of the stream will be used.
+     * An incoming stream was created
      */
-    newStream(name?: string): Stream | Promise<Stream>;
+    stream: CustomEvent<MuxedStream>;
+}
+export interface CreateStreamOptions extends AbortOptions, StreamOptions {
     /**
-     * Close or abort all tracked streams and stop the muxer
+     * If a single protocol was requested and the muxer has support for this,
+     * pre-negotiate the protocol using this value, otherwise multistream-select
+     * will be run over the stream after opening.
      */
-    close(options?: AbortOptions): Promise<void>;
+    protocol?: string;
+}
+export type StreamMuxerStatus = 'open' | 'closing' | 'closed';
+/**
+ * A libp2p stream muxer
+ */
+export interface StreamMuxer<MuxedStream extends Stream = Stream> extends TypedEventTarget<StreamMuxerEvents<MuxedStream>> {
     /**
-     * Close or abort all tracked streams and stop the muxer
+     * The protocol used to select this muxer during connection opening
      */
-    abort(err: Error): void;
-}
-export interface StreamMuxerInit {
+    protocol: string;
     /**
-     * A callback function invoked every time an incoming stream is opened
+     * A list of streams that are currently open
      */
-    onIncomingStream?(stream: Stream): void;
+    streams: MuxedStream[];
     /**
-     * A callback function invoke every time a stream ends
+     * The status of the muxer
      */
-    onStreamEnd?(stream: Stream): void;
+    status: StreamMuxerStatus;
     /**
-     * Outbound stream muxers are opened by the local node, inbound stream muxers are opened by the remote
+     * Create a new stream
      */
-    direction?: Direction;
+    createStream(options?: CreateStreamOptions): Promise<MuxedStream>;
     /**
-     * The logger used by the connection
+     * Immediately close the muxer, abort every open stream and discard any
+     * unsent/unread data.
      */
-    log?: Logger;
+    abort(err: Error): void;
+    /**
+     * Gracefully close the muxer. All open streams will be gracefully closed, and
+     * the returned promise will either resolve when any/all unsent data has been
+     * sent, or it will reject if the passed abort signal fires before this
+     * happens.
+     */
+    close(options?: AbortOptions): Promise<void>;
 }
 //# sourceMappingURL=stream-muxer.d.ts.map

package/dist/src/stream-muxer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stream-muxer.d.ts","sourceRoot":"","sources":["../../src/stream-muxer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AACxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACtD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,iBAAiB,CAAA;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAA;AAEpD,MAAM,WAAW,kBAAkB;IACjC;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,iBAAiB,CAAC,IAAI,CAAC,EAAE,eAAe,GAAG,WAAW,CAAA;CACvD;AAED;;GAEG;AACH,MAAM,WAAW,WAAY,SAAQ,MAAM,CAAC,cAAc,CAAC,UAAU,GAAG,cAAc,CAAC,CAAC;IACtF;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,CAAA;IAC1B;;;OAGG;IACH,SAAS,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC,MAAM,CAAC,CAAA;IAElD;;OAEG;IACH,KAAK,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE5C;;OAEG;IACH,KAAK,CAAC,GAAG,EAAE,KAAK,GAAG,IAAI,CAAA;CACxB;AAED,MAAM,WAAW,eAAe;IAC9B;;OAEG;IACH,gBAAgB,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IAEvC;;OAEG;IACH,WAAW,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IAElC;;OAEG;IACH,SAAS,CAAC,EAAE,SAAS,CAAA;IAErB;;OAEG;IACH,GAAG,CAAC,EAAE,MAAM,CAAA;CACb"}
+{"version":3,"file":"stream-muxer.d.ts","sourceRoot":"","sources":["../../src/stream-muxer.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,gBAAgB,EAAE,aAAa,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAEvF;;GAEG;AACH,MAAM,WAAW,kBAAkB,CAAC,kBAAkB,SAAS,aAAa,GAAG,aAAa;IAC1F;;OAEG;IACH,aAAa,CAAC,EAAE,kBAAkB,CAAA;IAElC;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,eAAe,CAAC,EAAE,MAAM,CAAA;IAExB;;;;;OAKG;IACH,cAAc,CAAC,EAAE,MAAM,CAAA;IAEvB;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAE1B;;;;;OAKG;IACH,kBAAkB,CAAC,EAAE,MAAM,CAAA;CAC5B;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAE1B;;;;;;;OAOG;IACH,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAE5B;;;;;;;OAOG;IACH,oBAAoB,CAAC,EAAE,MAAM,CAAA;CAC9B;AAED,MAAM,WAAW,kBAAkB,CAAC,KAAK,SAAS,WAAW,GAAG,WAAW;IACzE;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,iBAAiB,CAAC,MAAM,EAAE,aAAa,GAAG,KAAK,CAAA;CAChD;AAED,MAAM,WAAW,iBAAiB,CAAC,WAAW,SAAS,MAAM,GAAG,MAAM;IACpE;;OAEG;IACH,MAAM,EAAE,WAAW,CAAC,WAAW,CAAC,CAAA;CACjC;AAED,MAAM,WAAW,mBAAoB,SAAQ,YAAY,EAAE,aAAa;IACtE;;;;OAIG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAA;CAClB;AAED,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,SAAS,GAAG,QAAQ,CAAA;AAE7D;;GAEG;AACH,MAAM,WAAW,WAAW,CAAC,WAAW,SAAS,MAAM,GAAG,MAAM,CAAE,SAAQ,gBAAgB,CAAC,iBAAiB,CAAC,WAAW,CAAC,CAAC;IACxH;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,OAAO,EAAE,WAAW,EAAE,CAAA;IAEtB;;OAEG;IACH,MAAM,EAAE,iBAAiB,CAAA;IAEzB;;OAEG;IACH,YAAY,CAAC,OAAO,CAAC,EAAE,mBAAmB,GAAG,OAAO,CAAC,WAAW,CAAC,CAAA;IAEjE;;;OAGG;IACH,KAAK,CAAE,GAAG,EAAE,KAAK,GAAG,IAAI,CAAA;IAExB;;;;;OAKG;IACH,KAAK,CAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CAC9C"}

package/dist/src/stream.d.ts

@@ -0,0 +1,63 @@
+import type { AbortOptions } from './index.ts';
+import type { MessageStream, MessageStreamReadStatus, MessageStreamWriteStatus } from './message-stream.js';
+/**
+ * A Stream is a lightweight data channel between two peers that can be written
+ * to and read from at both ends.
+ *
+ * It is half-closable - that is in order for it to be closed fully and any
+ * associated memory reclaimed, both ends must close their writeable end of the
+ * stream.
+ *
+ * It's also possible to close the readable end of the stream, but this depends
+ * on the underlying stream muxer supporting this operation which not all do.
+ */
+export interface Stream extends MessageStream {
+    /**
+     * Unique identifier for a stream. Identifiers are not unique across muxers.
+     */
+    id: string;
+    /**
+     * The protocol negotiated for this stream
+     */
+    protocol: string;
+    /**
+     * The status of the readable end of the stream
+     */
+    readStatus: MessageStreamReadStatus;
+    /**
+     * The status of the writable end of the stream
+     */
+    writeStatus: MessageStreamWriteStatus;
+    /**
+     * The status of the readable end of the remote end of the stream - n.b. this
+     * requires the underlying stream transport to support sending STOP_SENDING
+     * messages or similar.
+     */
+    remoteReadStatus: MessageStreamReadStatus;
+    /**
+     * The status of the writable end of the remote end of the stream
+     */
+    remoteWriteStatus: MessageStreamWriteStatus;
+    /**
+     * Close stream for writing and return a promise that resolves once any
+     * pending data has been passed to the underlying transport.
+     *
+     * Note that the stream itself will remain readable until the remote end also
+     * closes it's writable end.
+     *
+     * To close without waiting for the remote, call `.abort` instead. If you want
+     * to wait for data to be sent first, ensure if the `.writableStatus` property
+     * is not 'paused', if it is, wait for a `drain` event before aborting.
+     */
+    close(options?: AbortOptions): Promise<void>;
+    /**
+     * Send a message to the remote end of the stream informing them that any
+     * incoming data will be discarded so they should stop sending.
+     *
+     * This requires the underlying resource to support this operation - for
+     * example the QUIC, WebTransport, WebRTC transports do but anything
+     * multiplexed using Yamux or Mplex do not.
+     */
+    closeRead(options?: AbortOptions): Promise<void>;
+}
+//# sourceMappingURL=stream.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stream.d.ts","sourceRoot":"","sources":["../../src/stream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAA;AAC9C,OAAO,KAAK,EAAE,aAAa,EAAE,uBAAuB,EAAE,wBAAwB,EAAE,MAAM,qBAAqB,CAAA;AAE3G;;;;;;;;;;GAUG;AACH,MAAM,WAAW,MAAO,SAAQ,aAAa;IAC3C;;OAEG;IACH,EAAE,EAAE,MAAM,CAAA;IAEV;;OAEG;IACH,QAAQ,EAAE,MAAM,CAAA;IAEhB;;OAEG;IACH,UAAU,EAAE,uBAAuB,CAAA;IAEnC;;OAEG;IACH,WAAW,EAAE,wBAAwB,CAAA;IAErC;;;;OAIG;IACH,gBAAgB,EAAE,uBAAuB,CAAA;IAEzC;;OAEG;IACH,iBAAiB,EAAE,wBAAwB,CAAA;IAE3C;;;;;;;;;;OAUG;IACH,KAAK,CAAE,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAE7C;;;;;;;OAOG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACjD"}

package/dist/src/stream.js

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

package/dist/src/stream.js.map

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

package/dist/src/topology.d.ts

@@ -4,7 +4,7 @@ import type { PeerId } from './peer-id.js';
  * A topology filter - this can be used by topologies to ensure they do not
  * receive duplicate notifications of individual peers
  *
- * @see https://libp2p.github.io/js-libp2p/functions/_libp2p_peer_collections.peerFilter-1.html
+ * @see https://libp2p.github.io/js-libp2p/classes/_libp2p_peer-collections.PeerFilter.html
  */
 export interface TopologyFilter {
     has(peerId: PeerId): boolean;
@@ -36,11 +36,11 @@ export interface Topology {
      * Invoked when a new connection is opened to a peer that supports the
      * registered protocol
      */
-    onConnect?(peerId: PeerId, conn: Connection): void;
+    onConnect?(peerId: PeerId, conn: Connection): void | Promise<void>;
     /**
      * Invoked when the last connection to a peer that supports the registered
      * protocol closes
      */
-    onDisconnect?(peerId: PeerId): void;
+    onDisconnect?(peerId: PeerId): void | Promise<void>;
 }
 //# sourceMappingURL=topology.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"topology.d.ts","sourceRoot":"","sources":["../../src/topology.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAA;IAC7B,GAAG,CAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,MAAM,CAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB;;;OAGG;IACH,MAAM,CAAC,EAAE,cAAc,CAAA;IAEvB;;;;;;OAMG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAA;IAEnC;;;OAGG;IACH,SAAS,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,CAAA;IAElD;;;OAGG;IACH,YAAY,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CACpC"}
+{"version":3,"file":"topology.d.ts","sourceRoot":"","sources":["../../src/topology.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,iBAAiB,CAAA;AACjD,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,cAAc,CAAA;AAE1C;;;;;GAKG;AACH,MAAM,WAAW,cAAc;IAC7B,GAAG,CAAE,MAAM,EAAE,MAAM,GAAG,OAAO,CAAA;IAC7B,GAAG,CAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;IAC1B,MAAM,CAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAA;CAC9B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,QAAQ;IACvB;;;OAGG;IACH,MAAM,CAAC,EAAE,cAAc,CAAA;IAEvB;;;;;;OAMG;IACH,yBAAyB,CAAC,EAAE,OAAO,CAAA;IAEnC;;;OAGG;IACH,SAAS,CAAC,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAElE;;;OAGG;IACH,YAAY,CAAC,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACpD"}

package/dist/src/transport.d.ts

@@ -1,6 +1,4 @@
-import type { Connection, ConnectionLimits, MultiaddrConnection } from './connection.js';
-import type { AbortOptions, ClearableSignal, ConnectionEncrypter } from './index.js';
-import type { StreamMuxerFactory } from './stream-muxer.js';
+import type { AbortOptions, ClearableSignal, ConnectionEncrypter, MultiaddrConnection, Connection, ConnectionLimits, StreamMuxerFactory, PeerId } from './index.js';
 import type { Multiaddr } from '@multiformats/multiaddr';
 import type { TypedEventTarget } from 'main-event';
 import type { ProgressOptions, ProgressEvent } from 'progress-events';
@@ -114,14 +112,6 @@ export declare enum FaultTolerance {
  * Options accepted by the upgrader during connection establishment
  */
 export interface UpgraderOptions<ConnectionUpgradeEvents extends ProgressEvent = ProgressEvent> extends ProgressOptions<ConnectionUpgradeEvents>, Required<AbortOptions> {
-    /**
-     * If true the invoking transport is expected to implement it's own encryption
-     * and an encryption protocol will not attempted to be negotiated via
-     * multi-stream select
-     *
-     * @default false
-     */
-    skipEncryption?: boolean;
     /**
      * If true no connection protection will be performed on the connection.
      */
@@ -147,18 +137,35 @@ export interface UpgraderOptions<ConnectionUpgradeEvents extends ProgressEvent =
      */
     initiator?: boolean;
 }
+/**
+ * Options accepted by the upgrader during connection establishment
+ */
+export interface UpgraderWithoutEncryptionOptions extends UpgraderOptions {
+    /**
+     * If true the invoking transport is expected to implement it's own encryption
+     * and an encryption protocol will not attempted to be negotiated via
+     * multi-stream select
+     */
+    skipEncryption: true;
+    /**
+     * If `skipEncryption` is true, a remote PeerId must be supplied
+     */
+    remotePeer: PeerId;
+}
 export type InboundConnectionUpgradeEvents = ProgressEvent<'upgrader:encrypt-inbound-connection'> | ProgressEvent<'upgrader:multiplex-inbound-connection'>;
 export type OutboundConnectionUpgradeEvents = ProgressEvent<'upgrader:encrypt-outbound-connection'> | ProgressEvent<'upgrader:multiplex-outbound-connection'>;
 export interface Upgrader {
     /**
      * Upgrades an outbound connection created by the `dial` method of a transport
      */
-    upgradeOutbound(maConn: MultiaddrConnection, opts?: UpgraderOptions<OutboundConnectionUpgradeEvents>): Promise<Connection>;
+    upgradeOutbound(maConn: MultiaddrConnection, opts: UpgraderOptions<OutboundConnectionUpgradeEvents>): Promise<Connection>;
+    upgradeOutbound(maConn: MultiaddrConnection, opts: UpgraderWithoutEncryptionOptions): Promise<Connection>;
     /**
      * Upgrades an inbound connection received by a transport listener and
      * notifies other libp2p components about the new connection
      */
-    upgradeInbound(maConn: MultiaddrConnection, opts?: UpgraderOptions<InboundConnectionUpgradeEvents>): Promise<void>;
+    upgradeInbound(maConn: MultiaddrConnection, opts: UpgraderOptions<InboundConnectionUpgradeEvents>): Promise<void>;
+    upgradeInbound(maConn: MultiaddrConnection, opts: UpgraderWithoutEncryptionOptions): Promise<void>;
     /**
      * Used by transports that perform part of the upgrade process themselves and
      * do some async work. This allows configuring inbound upgrade timeouts from a

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

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

package/dist/src/transport.js.map

@@ -1 +1 @@
-{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"AAgDA,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAA;AA8D9D;;GAEG;AACH,MAAM,UAAU,WAAW,CAAE,KAAW;IACtC,OAAO,KAAK,IAAI,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,CAAA;AACzD,CAAC;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,cAUX;AAVD,WAAY,cAAc;IACxB;;OAEG;IACH,6DAAa,CAAA;IAEb;;OAEG;IACH,2DAAQ,CAAA;AACV,CAAC,EAVW,cAAc,KAAd,cAAc,QAUzB"}
+{"version":3,"file":"transport.js","sourceRoot":"","sources":["../../src/transport.ts"],"names":[],"mappings":"AAiDA,MAAM,CAAC,MAAM,eAAe,GAAG,MAAM,CAAC,GAAG,CAAC,mBAAmB,CAAC,CAAA;AA8D9D;;GAEG;AACH,MAAM,UAAU,WAAW,CAAE,KAAW;IACtC,OAAO,KAAK,IAAI,IAAI,IAAI,OAAO,CAAC,KAAK,CAAC,eAAe,CAAC,CAAC,CAAA;AACzD,CAAC;AAED;;GAEG;AACH,MAAM,CAAN,IAAY,cAUX;AAVD,WAAY,cAAc;IACxB;;OAEG;IACH,6DAAa,CAAA;IAEb;;OAEG;IACH,2DAAQ,CAAA;AACV,CAAC,EAVW,cAAc,KAAd,cAAc,QAUzB"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@libp2p/interface",
-  "version": "2.11.0",
+  "version": "3.0.0-049bfa0fa",
   "description": "The interface implemented by a libp2p node",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/interface#readme",
@@ -42,16 +42,14 @@
   },
   "dependencies": {
     "@multiformats/dns": "^1.0.6",
-    "@multiformats/multiaddr": "^12.4.4",
-    "it-pushable": "^3.2.3",
-    "it-stream-types": "^2.0.2",
+    "@multiformats/multiaddr": "^13.0.1",
     "main-event": "^1.0.1",
-    "multiformats": "^13.3.6",
+    "multiformats": "^13.4.0",
     "progress-events": "^1.0.1",
     "uint8arraylist": "^2.4.8"
   },
   "devDependencies": {
-    "aegir": "^47.0.14"
+    "aegir": "^47.0.22"
   },
   "sideEffects": false
 }

package/src/connection-encrypter.ts

@@ -1,8 +1,4 @@
-import type { MultiaddrConnection } from './connection.js'
-import type { AbortOptions, Logger, StreamMuxerFactory } from './index.js'
-import type { PeerId } from './peer-id.js'
-import type { Duplex } from 'it-stream-types'
-import type { Uint8ArrayList } from 'uint8arraylist'
+import type { AbortOptions, StreamMuxerFactory, PeerId, MessageStream } from './index.js'
 
 /**
  * If the remote PeerId is known and passed as an option, the securing operation
@@ -10,6 +6,9 @@ import type { Uint8ArrayList } from 'uint8arraylist'
  * corresponds to the public key the remote PeerId is derived from.
  */
 export interface SecureConnectionOptions extends AbortOptions {
+  /**
+   * This will be set if the remote peer is known in advance
+   */
   remotePeer?: PeerId
 
   /**
@@ -21,13 +20,6 @@ export interface SecureConnectionOptions extends AbortOptions {
   skipStreamMuxerNegotiation?: boolean
 }
 
-/**
- * A stream with an optional logger
- */
-export interface SecurableStream extends Duplex<AsyncGenerator<Uint8Array | Uint8ArrayList>> {
-  log?: Logger
-}
-
 /**
  * A libp2p connection encrypter module must be compliant to this interface
  * to ensure all exchanged data between two peers is encrypted.
@@ -40,19 +32,30 @@ export interface ConnectionEncrypter<Extension = unknown> {
    * pass it for extra verification, otherwise it will be determined during
    * the handshake.
    */
-  secureOutbound <Stream extends SecurableStream = MultiaddrConnection> (connection: Stream, options?: SecureConnectionOptions): Promise<SecuredConnection<Stream, Extension>>
+  secureOutbound (connection: MessageStream, options?: SecureConnectionOptions): Promise<SecuredConnection<Extension>>
 
   /**
    * Decrypt incoming data. If the remote PeerId is known,
    * pass it for extra verification, otherwise it will be determined during
    * the handshake
    */
-  secureInbound <Stream extends SecurableStream = MultiaddrConnection> (connection: Stream, options?: SecureConnectionOptions): Promise<SecuredConnection<Stream, Extension>>
+  secureInbound (connection: MessageStream, options?: SecureConnectionOptions): Promise<SecuredConnection<Extension>>
 }
 
-export interface SecuredConnection<Stream = any, Extension = unknown> {
-  conn: Stream
+export interface SecuredConnection<Extension = unknown> {
+  /**
+   * The decrypted data stream
+   */
+  connection: MessageStream
+
+  /**
+   * Any extension data transferred as part of the encryption handshake
+   */
   remoteExtensions?: Extension
+
+  /**
+   * The identifier of the remote peer
+   */
   remotePeer: PeerId
 
   /**

package/src/connection-gater.ts

@@ -1,5 +1,4 @@
-import type { MultiaddrConnection } from './connection.js'
-import type { PeerId } from './peer-id.js'
+import type { MultiaddrConnection, PeerId } from './index.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export interface ConnectionGater {

package/src/connection-protector.ts

@@ -0,0 +1,9 @@
+import type { AbortOptions, MessageStream } from './index.ts'
+
+export interface ConnectionProtector {
+  /**
+   * Takes a MessageStream and creates a private encryption stream between
+   * the two peers from the shared key the Protector instance was created with.
+   */
+  protect (connection: MessageStream, options?: AbortOptions): Promise<MessageStream>
+}