libp2p 2.1.1-c258b35af → 2.1.1

package/src/connection-manager/index.ts

@@ -57,34 +57,17 @@ export interface ConnectionManagerInit {
   /**
    * How long a dial attempt is allowed to take, including DNS resolution
    * of the multiaddr, opening a socket and upgrading it to a Connection.
-   *
-   * @default 5000
    */
   dialTimeout?: number
 
   /**
-   * When a new incoming connection is opened, the upgrade process (e.g.
-   * protect, encrypt, multiplex etc) must complete within this number of ms.
+   * When a new inbound connection is opened, the upgrade process (e.g. protect,
+   * encrypt, multiplex etc) must complete within this number of ms.
    *
-   * @default 3000
+   * @default 30000
    */
   inboundUpgradeTimeout?: number
 
-  /**
-   * When a new outbound connection is opened, the upgrade process (e.g.
-   * protect, encrypt, multiplex etc) must complete within this number of ms.
-   *
-   * @default 3000
-   */
-  outboundUpgradeTimeout?: number
-
-  /**
-   * Protocol negotiation must complete within this number of ms
-   *
-   * @default 2000
-   */
-  protocolNegotiationTimeout?: number
-
   /**
    * Multiaddr resolvers to use when dialling
    */
@@ -181,6 +164,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
   private readonly deny: Multiaddr[]
   private readonly maxIncomingPendingConnections: number
   private incomingPendingConnections: number
+  private outboundPendingConnections: number
   private readonly maxConnections: number
 
   public readonly dialQueue: DialQueue
@@ -219,6 +203,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.allow = (init.allow ?? []).map(ma => multiaddr(ma))
     this.deny = (init.deny ?? []).map(ma => multiaddr(ma))
 
+    this.outboundPendingConnections = 0
     this.incomingPendingConnections = 0
     this.maxIncomingPendingConnections = init.maxIncomingPendingConnections ?? defaultOptions.maxIncomingPendingConnections
 
@@ -281,7 +266,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
         const metric = {
           inbound: 0,
           'inbound pending': this.incomingPendingConnections,
-          outbound: 0
+          outbound: 0,
+          'outbound pending': this.outboundPendingConnections
         }
 
         for (const conns of this.connections.values()) {
@@ -482,48 +468,54 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     options.signal?.throwIfAborted()
 
-    const { peerId } = getPeerAddress(peerIdOrMultiaddr)
+    try {
+      this.outboundPendingConnections++
 
-    if (peerId != null && options.force !== true) {
-      this.log('dial %p', peerId)
-      const existingConnection = this.getConnections(peerId)
-        .find(conn => conn.limits == null)
+      const { peerId } = getPeerAddress(peerIdOrMultiaddr)
 
-      if (existingConnection != null) {
-        this.log('had an existing non-limited connection to %p', peerId)
+      if (peerId != null && options.force !== true) {
+        this.log('dial %p', peerId)
+        const existingConnection = this.getConnections(peerId)
+          .find(conn => conn.limits == null)
 
-        options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
-        return existingConnection
+        if (existingConnection != null) {
+          this.log('had an existing non-limited connection to %p', peerId)
+
+          options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
+          return existingConnection
+        }
       }
-    }
 
-    const connection = await this.dialQueue.dial(peerIdOrMultiaddr, {
-      ...options,
-      priority: options.priority ?? DEFAULT_DIAL_PRIORITY
-    })
-    let peerConnections = this.connections.get(connection.remotePeer)
+      const connection = await this.dialQueue.dial(peerIdOrMultiaddr, {
+        ...options,
+        priority: options.priority ?? DEFAULT_DIAL_PRIORITY
+      })
+      let peerConnections = this.connections.get(connection.remotePeer)
 
-    if (peerConnections == null) {
-      peerConnections = []
-      this.connections.set(connection.remotePeer, peerConnections)
-    }
+      if (peerConnections == null) {
+        peerConnections = []
+        this.connections.set(connection.remotePeer, peerConnections)
+      }
 
-    // we get notified of connections via the Upgrader emitting "connection"
-    // events, double check we aren't already tracking this connection before
-    // storing it
-    let trackedConnection = false
+      // we get notified of connections via the Upgrader emitting "connection"
+      // events, double check we aren't already tracking this connection before
+      // storing it
+      let trackedConnection = false
 
-    for (const conn of peerConnections) {
-      if (conn.id === connection.id) {
-        trackedConnection = true
+      for (const conn of peerConnections) {
+        if (conn.id === connection.id) {
+          trackedConnection = true
+        }
       }
-    }
 
-    if (!trackedConnection) {
-      peerConnections.push(connection)
-    }
+      if (!trackedConnection) {
+        peerConnections.push(connection)
+      }
 
-    return connection
+      return connection
+    } finally {
+      this.outboundPendingConnections--
+    }
   }
 
   async closeConnections (peerId: PeerId, options: AbortOptions = {}): Promise<void> {

package/src/libp2p.ts

@@ -110,8 +110,7 @@ export class Libp2p<T extends ServiceMap = ServiceMap> extends TypedEventEmitter
     this.components.upgrader = new DefaultUpgrader(this.components, {
       connectionEncrypters: (init.connectionEncrypters ?? []).map((fn, index) => this.configureComponent(`connection-encryption-${index}`, fn(this.components))),
       streamMuxers: (init.streamMuxers ?? []).map((fn, index) => this.configureComponent(`stream-muxers-${index}`, fn(this.components))),
-      inboundUpgradeTimeout: init.connectionManager?.inboundUpgradeTimeout,
-      outboundUpgradeTimeout: init.connectionManager?.outboundUpgradeTimeout
+      inboundUpgradeTimeout: init.connectionManager?.inboundUpgradeTimeout
     })
 
     // Setup the transport manager

package/src/upgrader.ts

@@ -1,15 +1,16 @@
-import { InvalidMultiaddrError, TooManyInboundProtocolStreamsError, TooManyOutboundProtocolStreamsError, LimitedConnectionError, setMaxListeners } from '@libp2p/interface'
+import { InvalidMultiaddrError, InvalidPeerIdError, TooManyInboundProtocolStreamsError, TooManyOutboundProtocolStreamsError, LimitedConnectionError, TimeoutError, setMaxListeners } from '@libp2p/interface'
 import * as mss from '@libp2p/multistream-select'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { anySignal } from 'any-signal'
 import { CustomProgressEvent } from 'progress-events'
 import { createConnection } from './connection/index.js'
-import { PROTOCOL_NEGOTIATION_TIMEOUT, UPGRADE_TIMEOUT } from './connection-manager/constants.js'
+import { INBOUND_UPGRADE_TIMEOUT } from './connection-manager/constants.js'
 import { ConnectionDeniedError, ConnectionInterceptedError, EncryptionFailedError, MuxerUnavailableError } from './errors.js'
 import { DEFAULT_MAX_INBOUND_STREAMS, DEFAULT_MAX_OUTBOUND_STREAMS } from './registrar.js'
 import type { Libp2pEvents, AbortOptions, ComponentLogger, MultiaddrConnection, Connection, Stream, ConnectionProtector, NewStreamOptions, ConnectionEncrypter, SecuredConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, PeerStore, StreamMuxer, StreamMuxerFactory, Upgrader, UpgraderOptions, ConnectionLimits, SecureConnectionOptions } from '@libp2p/interface'
 import type { ConnectionManager, Registrar } from '@libp2p/interface-internal'
 
+const DEFAULT_PROTOCOL_SELECT_TIMEOUT = 30000
+
 interface CreateConnectionOptions {
   cryptoProtocol: string
   direction: 'inbound' | 'outbound'
@@ -35,34 +36,10 @@ export interface UpgraderInit {
   streamMuxers: StreamMuxerFactory[]
 
   /**
-   * An amount of ms by which an inbound connection upgrade must complete
-   *
-   * @default 3000
+   * An amount of ms by which an inbound connection upgrade
+   * must complete
    */
   inboundUpgradeTimeout?: number
-
-  /**
-   * An amount of ms by which an outbound connection upgrade must complete
-   *
-   * @default 3000
-   */
-  outboundUpgradeTimeout?: number
-
-  /**
-   * When a new incoming stream is opened on a multiplexed connection, protocol
-   * negotiation on that stream must complete within this many ms
-   *
-   * @default 2000
-   */
-  inboundStreamProtocolNegotiationTimeout?: number
-
-  /**
-   * When a new incoming stream is opened on a multiplexed connection, protocol
-   * negotiation on that stream must complete within this many ms
-   *
-   * @default 2000
-   */
-  outboundStreamProtocolNegotiationTimeout?: number
 }
 
 function findIncomingStreamLimit (protocol: string, registrar: Registrar): number | undefined {
@@ -126,9 +103,6 @@ export class DefaultUpgrader implements Upgrader {
   private readonly connectionEncrypters: Map<string, ConnectionEncrypter>
   private readonly streamMuxers: Map<string, StreamMuxerFactory>
   private readonly inboundUpgradeTimeout: number
-  private readonly outboundUpgradeTimeout: number
-  private readonly inboundStreamProtocolNegotiationTimeout: number
-  private readonly outboundStreamProtocolNegotiationTimeout: number
   private readonly events: TypedEventTarget<Libp2pEvents>
 
   constructor (components: DefaultUpgraderComponents, init: UpgraderInit) {
@@ -145,46 +119,135 @@ export class DefaultUpgrader implements Upgrader {
       this.streamMuxers.set(muxer.protocol, muxer)
     })
 
-    this.inboundUpgradeTimeout = init.inboundUpgradeTimeout ?? UPGRADE_TIMEOUT
-    this.outboundUpgradeTimeout = init.outboundUpgradeTimeout ?? UPGRADE_TIMEOUT
-    this.inboundStreamProtocolNegotiationTimeout = init.inboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
-    this.outboundStreamProtocolNegotiationTimeout = init.outboundStreamProtocolNegotiationTimeout ?? PROTOCOL_NEGOTIATION_TIMEOUT
+    this.inboundUpgradeTimeout = init.inboundUpgradeTimeout ?? INBOUND_UPGRADE_TIMEOUT
     this.events = components.events
   }
 
   readonly [Symbol.toStringTag] = '@libp2p/upgrader'
 
-  async shouldBlockConnection (connectionType: 'denyInboundConnection', maConn: MultiaddrConnection): Promise<void>
-  async shouldBlockConnection (connectionType: ConnectionDeniedType, remotePeer: PeerId, maConn: MultiaddrConnection): Promise<void>
-  async shouldBlockConnection (method: ConnectionDeniedType | 'denyInboundConnection', ...args: any[]): Promise<void> {
-    const denyOperation: any = this.components.connectionGater[method]
+  async shouldBlockConnection (remotePeer: PeerId, maConn: MultiaddrConnection, connectionType: ConnectionDeniedType): Promise<void> {
+    const connectionGater = this.components.connectionGater[connectionType]
 
-    if (denyOperation == null) {
-      return
-    }
-
-    const result = await denyOperation.apply(this.components.connectionGater, args)
-
-    if (result === true) {
-      throw new ConnectionInterceptedError(`The multiaddr connection is blocked by gater.${method}`)
+    if (connectionGater !== undefined) {
+      if (await connectionGater(remotePeer, maConn)) {
+        throw new ConnectionInterceptedError(`The multiaddr connection is blocked by gater.${connectionType}`)
+      }
     }
   }
 
   /**
    * Upgrades an inbound connection
    */
-  async upgradeInbound (maConn: MultiaddrConnection, opts: UpgraderOptions = {}): Promise<Connection> {
+  async upgradeInbound (maConn: MultiaddrConnection, opts?: UpgraderOptions): Promise<Connection> {
+    const accept = await this.components.connectionManager.acceptIncomingConnection(maConn)
+
+    if (!accept) {
+      throw new ConnectionDeniedError('connection denied')
+    }
+
+    let encryptedConn: MultiaddrConnection
+    let remotePeer
+    let upgradedConn: MultiaddrConnection
+    let muxerFactory: StreamMuxerFactory | undefined
+    let cryptoProtocol
+
+    const signal = AbortSignal.timeout(this.inboundUpgradeTimeout)
+
+    const onAbort = (): void => {
+      maConn.abort(new TimeoutError('inbound upgrade timeout'))
+    }
+
+    signal.addEventListener('abort', onAbort, { once: true })
+
+    setMaxListeners(Infinity, signal)
+
     try {
-      const accept = await this.components.connectionManager.acceptIncomingConnection(maConn)
+      if ((await this.components.connectionGater.denyInboundConnection?.(maConn)) === true) {
+        throw new ConnectionInterceptedError('The multiaddr connection is blocked by gater.acceptConnection')
+      }
+
+      this.components.metrics?.trackMultiaddrConnection(maConn)
 
-      if (!accept) {
-        throw new ConnectionDeniedError('connection denied')
+      maConn.log('starting the inbound connection upgrade')
+
+      // Protect
+      let protectedConn = maConn
+
+      if (opts?.skipProtection !== true) {
+        const protector = this.components.connectionProtector
+
+        if (protector != null) {
+          maConn.log('protecting the inbound connection')
+          protectedConn = await protector.protect(maConn)
+        }
       }
 
-      await this.shouldBlockConnection('denyInboundConnection', maConn)
+      try {
+        // Encrypt the connection
+        encryptedConn = protectedConn
+        if (opts?.skipEncryption !== true) {
+          opts?.onProgress?.(new CustomProgressEvent('upgrader:encrypt-inbound-connection'));
+
+          ({
+            conn: encryptedConn,
+            remotePeer,
+            protocol: cryptoProtocol
+          } = await this._encryptInbound(protectedConn))
+
+          const maConn: MultiaddrConnection = {
+            ...protectedConn,
+            ...encryptedConn
+          }
 
-      return await this._performUpgrade(maConn, 'inbound', opts)
+          await this.shouldBlockConnection(remotePeer, maConn, 'denyInboundEncryptedConnection')
+        } else {
+          const idStr = maConn.remoteAddr.getPeerId()
+
+          if (idStr == null) {
+            throw new InvalidMultiaddrError('inbound connection that skipped encryption must have a peer id')
+          }
+
+          const remotePeerId = peerIdFromString(idStr)
+
+          cryptoProtocol = 'native'
+          remotePeer = remotePeerId
+        }
+
+        upgradedConn = encryptedConn
+        if (opts?.muxerFactory != null) {
+          muxerFactory = opts.muxerFactory
+        } else if (this.streamMuxers.size > 0) {
+          opts?.onProgress?.(new CustomProgressEvent('upgrader:multiplex-inbound-connection'))
+
+          // Multiplex the connection
+          const multiplexed = await this._multiplexInbound({
+            ...protectedConn,
+            ...encryptedConn
+          }, this.streamMuxers)
+          muxerFactory = multiplexed.muxerFactory
+          upgradedConn = multiplexed.stream
+        }
+      } catch (err: any) {
+        maConn.log.error('failed to upgrade inbound connection', err)
+        throw err
+      }
+
+      await this.shouldBlockConnection(remotePeer, maConn, 'denyInboundUpgradedConnection')
+
+      maConn.log('successfully upgraded inbound connection')
+
+      return this._createConnection({
+        cryptoProtocol,
+        direction: 'inbound',
+        maConn,
+        upgradedConn,
+        muxerFactory,
+        remotePeer,
+        limits: opts?.limits
+      })
     } finally {
+      signal.removeEventListener('abort', onAbort)
+
       this.components.connectionManager.afterUpgradeInbound()
     }
   }
@@ -192,43 +255,36 @@ export class DefaultUpgrader implements Upgrader {
   /**
    * Upgrades an outbound connection
    */
-  async upgradeOutbound (maConn: MultiaddrConnection, opts: UpgraderOptions = {}): Promise<Connection> {
+  async upgradeOutbound (maConn: MultiaddrConnection, opts?: UpgraderOptions): Promise<Connection> {
     const idStr = maConn.remoteAddr.getPeerId()
     let remotePeerId: PeerId | undefined
 
     if (idStr != null) {
       remotePeerId = peerIdFromString(idStr)
-      await this.shouldBlockConnection('denyOutboundConnection', remotePeerId, maConn)
-    }
 
-    return this._performUpgrade(maConn, 'outbound', opts)
-  }
+      await this.shouldBlockConnection(remotePeerId, maConn, 'denyOutboundConnection')
+    }
 
-  private async _performUpgrade (maConn: MultiaddrConnection, direction: 'inbound' | 'outbound', opts: UpgraderOptions): Promise<Connection> {
     let encryptedConn: MultiaddrConnection
     let remotePeer: PeerId
     let upgradedConn: MultiaddrConnection
-    let muxerFactory: StreamMuxerFactory | undefined
     let cryptoProtocol
-
-    const upgradeTimeoutSignal = AbortSignal.timeout(direction === 'inbound' ? this.inboundUpgradeTimeout : this.outboundUpgradeTimeout)
-    const signal = anySignal([upgradeTimeoutSignal, opts.signal])
-    setMaxListeners(Infinity, upgradeTimeoutSignal, signal)
-    opts.signal = signal
+    let muxerFactory
 
     this.components.metrics?.trackMultiaddrConnection(maConn)
 
-    maConn.log('starting the %s connection upgrade', direction)
+    maConn.log('starting the outbound connection upgrade')
+
+    // If the transport natively supports encryption, skip connection
+    // protector and encryption
 
     // Protect
     let protectedConn = maConn
-
     if (opts?.skipProtection !== true) {
       const protector = this.components.connectionProtector
 
       if (protector != null) {
-        maConn.log('protecting the %s connection', direction)
-        protectedConn = await protector.protect(maConn, opts)
+        protectedConn = await protector.protect(maConn)
       }
     }
 
@@ -236,38 +292,26 @@ export class DefaultUpgrader implements Upgrader {
       // Encrypt the connection
       encryptedConn = protectedConn
       if (opts?.skipEncryption !== true) {
-        opts?.onProgress?.(new CustomProgressEvent(`upgrader:encrypt-${direction}-connection`));
-
         ({
           conn: encryptedConn,
           remotePeer,
           protocol: cryptoProtocol
-        } = await (direction === 'inbound'
-          ? this._encryptInbound(protectedConn, {
-            ...opts,
-            signal
-          })
-          : this._encryptOutbound(protectedConn, {
-            ...opts,
-            signal
-          })
-        ))
+        } = await this._encryptOutbound(protectedConn, {
+          ...opts,
+          remotePeer: remotePeerId
+        }))
 
         const maConn: MultiaddrConnection = {
           ...protectedConn,
           ...encryptedConn
         }
 
-        await this.shouldBlockConnection(direction === 'inbound' ? 'denyInboundEncryptedConnection' : 'denyOutboundEncryptedConnection', remotePeer, maConn)
+        await this.shouldBlockConnection(remotePeer, maConn, 'denyOutboundEncryptedConnection')
       } else {
-        const idStr = maConn.remoteAddr.getPeerId()
-
-        if (idStr == null) {
-          throw new InvalidMultiaddrError(`${direction} connection that skipped encryption must have a peer id`)
+        if (remotePeerId == null) {
+          throw new InvalidPeerIdError('Encryption was skipped but no peer id was passed')
         }
 
-        const remotePeerId = peerIdFromString(idStr)
-
         cryptoProtocol = 'native'
         remotePeer = remotePeerId
       }
@@ -276,33 +320,27 @@ export class DefaultUpgrader implements Upgrader {
       if (opts?.muxerFactory != null) {
         muxerFactory = opts.muxerFactory
       } else if (this.streamMuxers.size > 0) {
-        opts?.onProgress?.(new CustomProgressEvent(`upgrader:multiplex-${direction}-connection`))
-
         // Multiplex the connection
-        const multiplexed = await (direction === 'inbound'
-          ? this._multiplexInbound({
-            ...protectedConn,
-            ...encryptedConn
-          }, this.streamMuxers, opts)
-          : this._multiplexOutbound({
-            ...protectedConn,
-            ...encryptedConn
-          }, this.streamMuxers, opts))
+        const multiplexed = await this._multiplexOutbound({
+          ...protectedConn,
+          ...encryptedConn
+        }, this.streamMuxers)
         muxerFactory = multiplexed.muxerFactory
         upgradedConn = multiplexed.stream
       }
     } catch (err: any) {
-      maConn.log.error('failed to upgrade inbound connection', err)
+      maConn.log.error('failed to upgrade outbound connection', err)
+      await maConn.close(err)
       throw err
     }
 
-    await this.shouldBlockConnection(direction === 'inbound' ? 'denyInboundUpgradedConnection' : 'denyOutboundUpgradedConnection', remotePeer, maConn)
+    await this.shouldBlockConnection(remotePeer, maConn, 'denyOutboundUpgradedConnection')
 
-    maConn.log('successfully %s inbound connection', direction)
+    maConn.log('successfully upgraded outbound connection')
 
     return this._createConnection({
       cryptoProtocol,
-      direction,
+      direction: 'outbound',
       maConn,
       upgradedConn,
       muxerFactory,
@@ -342,11 +380,7 @@ export class DefaultUpgrader implements Upgrader {
           void Promise.resolve()
             .then(async () => {
               const protocols = this.components.registrar.getProtocols()
-              const signal = AbortSignal.timeout(this.inboundStreamProtocolNegotiationTimeout)
-              setMaxListeners(Infinity, signal)
-
               const { stream, protocol } = await mss.handle(muxedStream, protocols, {
-                signal,
                 log: muxedStream.log,
                 yieldBytes: false
               })
@@ -421,7 +455,7 @@ export class DefaultUpgrader implements Upgrader {
           if (options.signal == null) {
             muxedStream.log('no abort signal was passed while trying to negotiate protocols %s falling back to default timeout', protocols)
 
-            const signal = AbortSignal.timeout(this.outboundStreamProtocolNegotiationTimeout)
+            const signal = AbortSignal.timeout(DEFAULT_PROTOCOL_SELECT_TIMEOUT)
             setMaxListeners(Infinity, signal)
 
             options = {
@@ -598,7 +632,6 @@ export class DefaultUpgrader implements Upgrader {
 
     try {
       const { stream, protocol } = await mss.handle(connection, protocols, {
-        ...options,
         log: connection.log
       })
       const encrypter = this.connectionEncrypters.get(protocol)
@@ -623,7 +656,7 @@ export class DefaultUpgrader implements Upgrader {
    * Attempts to encrypt the given `connection` with the provided connection encrypters.
    * The first `ConnectionEncrypter` module to succeed will be used
    */
-  async _encryptOutbound (connection: MultiaddrConnection, options: SecureConnectionOptions): Promise<CryptoResult> {
+  async _encryptOutbound (connection: MultiaddrConnection, options?: SecureConnectionOptions): Promise<CryptoResult> {
     const protocols = Array.from(this.connectionEncrypters.keys())
     connection.log('selecting outbound crypto protocol', protocols)
 
@@ -634,7 +667,6 @@ export class DefaultUpgrader implements Upgrader {
         stream,
         protocol
       } = await mss.select(connection, protocols, {
-        ...options,
         log: connection.log,
         yieldBytes: true
       })
@@ -661,7 +693,7 @@ export class DefaultUpgrader implements Upgrader {
    * Selects one of the given muxers via multistream-select. That
    * muxer will be used for all future streams on the connection.
    */
-  async _multiplexOutbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>, options: AbortOptions): Promise<{ stream: MultiaddrConnection, muxerFactory?: StreamMuxerFactory }> {
+  async _multiplexOutbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: MultiaddrConnection, muxerFactory?: StreamMuxerFactory }> {
     const protocols = Array.from(muxers.keys())
     connection.log('outbound selecting muxer %s', protocols)
     try {
@@ -671,7 +703,6 @@ export class DefaultUpgrader implements Upgrader {
         stream,
         protocol
       } = await mss.select(connection, protocols, {
-        ...options,
         log: connection.log,
         yieldBytes: true
       })
@@ -690,12 +721,11 @@ export class DefaultUpgrader implements Upgrader {
    * Registers support for one of the given muxers via multistream-select. The
    * selected muxer will be used for all future streams on the connection.
    */
-  async _multiplexInbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>, options: AbortOptions): Promise<{ stream: MultiaddrConnection, muxerFactory?: StreamMuxerFactory }> {
+  async _multiplexInbound (connection: MultiaddrConnection, muxers: Map<string, StreamMuxerFactory>): Promise<{ stream: MultiaddrConnection, muxerFactory?: StreamMuxerFactory }> {
     const protocols = Array.from(muxers.keys())
     connection.log('inbound handling muxers %s', protocols)
     try {
       const { stream, protocol } = await mss.handle(connection, protocols, {
-        ...options,
         log: connection.log
       })
       const muxerFactory = muxers.get(protocol)

package/src/version.ts

@@ -1,2 +1,2 @@
-export const version = '2.1.1-c258b35af'
+export const version = '2.1.1'
 export const name = 'libp2p'