libp2p 2.10.0 → 3.0.0-049bfa0fa

package/src/config/connection-gater.ts

@@ -4,16 +4,5 @@ import type { ConnectionGater } from '@libp2p/interface'
  * Returns a default connection gater implementation that allows everything
  */
 export function connectionGater (gater: ConnectionGater = {}): ConnectionGater {
-  return {
-    denyDialPeer: async () => false,
-    denyDialMultiaddr: async () => false,
-    denyInboundConnection: async () => false,
-    denyOutboundConnection: async () => false,
-    denyInboundEncryptedConnection: async () => false,
-    denyOutboundEncryptedConnection: async () => false,
-    denyInboundUpgradedConnection: async () => false,
-    denyOutboundUpgradedConnection: async () => false,
-    filterMultiaddrForPeer: async () => true,
-    ...gater
-  }
+  return gater
 }

package/src/config.ts

@@ -1,33 +1,11 @@
-import { FaultTolerance, InvalidParametersError } from '@libp2p/interface'
-import { mergeOptions } from '@libp2p/utils/merge-options'
-import { dnsaddrResolver } from './connection-manager/resolvers/dnsaddr.ts'
+import { InvalidParametersError } from '@libp2p/interface'
 import type { Libp2pInit } from './index.js'
 import type { ServiceMap } from '@libp2p/interface'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-const DefaultConfig: Libp2pInit = {
-  addresses: {
-    listen: [],
-    announce: [],
-    noAnnounce: [],
-    announceFilter: (multiaddrs: Multiaddr[]) => multiaddrs
-  },
-  connectionManager: {
-    resolvers: {
-      dnsaddr: dnsaddrResolver
-    }
-  },
-  transportManager: {
-    faultTolerance: FaultTolerance.FATAL_ALL
-  }
-}
 
 export async function validateConfig <T extends ServiceMap = Record<string, unknown>> (opts: Libp2pInit<T>): Promise<Libp2pInit<T>> {
-  const resultingOptions: Libp2pInit<T> = mergeOptions(DefaultConfig, opts)
-
-  if (resultingOptions.connectionProtector === null && globalThis.process?.env?.LIBP2P_FORCE_PNET != null) {
+  if (opts.connectionProtector === null && globalThis.process?.env?.LIBP2P_FORCE_PNET != null) {
     throw new InvalidParametersError('Private network is enforced, but no protector was provided')
   }
 
-  return resultingOptions
+  return opts
 }

package/src/connection-manager/address-sorter.ts

@@ -1,5 +1,4 @@
-import { isLoopback } from '@libp2p/utils/multiaddr/is-loopback'
-import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
+import { isLoopback, isPrivate } from '@libp2p/utils'
 import { Circuit, WebSockets, WebSocketsSecure, WebRTC, WebRTCDirect, WebTransport, TCP } from '@multiformats/multiaddr-matcher'
 import type { Address } from '@libp2p/interface'
 

package/src/connection-manager/connection-pruner.ts

@@ -1,6 +1,6 @@
 import { PeerMap } from '@libp2p/peer-collections'
-import { safelyCloseConnectionIfUnused } from '@libp2p/utils/close'
-import { multiaddrToIpNet } from './utils.js'
+import { getNetConfig, isNetworkAddress } from '@libp2p/utils'
+import { multiaddrToIpNet, safelyCloseConnectionIfUnused } from './utils.js'
 import type { IpNet } from '@chainsafe/netmask'
 import type { Libp2pEvents, Logger, ComponentLogger, PeerStore, Connection } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
@@ -103,7 +103,12 @@ export class ConnectionPruner {
       this.log('too many connections open - closing a connection to %p', connection.remotePeer)
       // check allow list
       const connectionInAllowList = this.allow.some((ipNet) => {
-        return ipNet.contains(connection.remoteAddr.nodeAddress().address)
+        if (isNetworkAddress(connection.remoteAddr)) {
+          const config = getNetConfig(connection.remoteAddr)
+          return ipNet.contains(config.host)
+        }
+
+        return true
       })
 
       // Connections in the allow list should be excluded from pruning

package/src/connection-manager/constants.defaults.ts

@@ -3,6 +3,11 @@
  */
 export const DIAL_TIMEOUT = 10_000
 
+/**
+ * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#connectionCloseTimeout
+ */
+export const CONNECTION_CLOSE_TIMEOUT = 1_000
+
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#inboundUpgradeTimeout
  */

package/src/connection-manager/dial-queue.ts

@@ -1,8 +1,8 @@
 /* eslint-disable max-depth */
 import { TimeoutError, DialError, AbortError } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
-import { PriorityQueue } from '@libp2p/utils/priority-queue'
-import { multiaddr } from '@multiformats/multiaddr'
+import { PriorityQueue } from '@libp2p/utils'
+import { CODE_P2P, multiaddr } from '@multiformats/multiaddr'
 import { Circuit } from '@multiformats/multiaddr-matcher'
 import { anySignal } from 'any-signal'
 import { setMaxListeners } from 'main-event'
@@ -20,10 +20,11 @@ import {
   LAST_DIAL_SUCCESS_KEY
 } from './constants.js'
 import { resolveMultiaddr, dnsaddrResolver } from './resolvers/index.js'
+import { findExistingConnection } from './utils.ts'
 import { DEFAULT_DIAL_PRIORITY } from './index.js'
 import type { AddressSorter, ComponentLogger, Logger, Connection, ConnectionGater, Metrics, PeerId, Address, PeerStore, PeerRouting, IsDialableOptions, OpenConnectionProgressEvents, MultiaddrResolver } from '@libp2p/interface'
 import type { OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
-import type { PriorityQueueJobOptions } from '@libp2p/utils/priority-queue'
+import type { PriorityQueueJobOptions } from '@libp2p/utils'
 import type { DNS } from '@multiformats/dns'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { ProgressOptions } from 'progress-events'
@@ -103,7 +104,7 @@ export class DialQueue {
     // a started job errored
     this.queue.addEventListener('failure', (event) => {
       if (event.detail?.error.name !== AbortError.name) {
-        this.log.error('error in dial queue - %e', event.detail)
+        this.log.error('error in dial queue - %e', event.detail.error)
       }
     })
   }
@@ -136,30 +137,14 @@ export class DialQueue {
   async dial (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], options: OpenConnectionOptions = {}): Promise<Connection> {
     const { peerId, multiaddrs } = getPeerAddress(peerIdOrMultiaddr)
 
-    // make sure we don't have an existing non-limited connection to any of the
-    // addresses we are about to dial
-    const existingConnection = Array.from(this.connections.values()).flat().find(conn => {
-      if (options.force === true) {
-        return false
-      }
-
-      if (conn.limits != null) {
-        return false
-      }
+    if (peerId != null && options.force !== true) {
+      const existingConnection = findExistingConnection(peerId, this.connections.get(peerId), multiaddrs)
 
-      if (conn.remotePeer.equals(peerId)) {
-        return true
+      if (existingConnection != null) {
+        this.log('already connected to %a', existingConnection.remoteAddr)
+        options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
+        return existingConnection
       }
-
-      return multiaddrs.find(addr => {
-        return addr.equals(conn.remoteAddr)
-      })
-    })
-
-    if (existingConnection?.status === 'open') {
-      this.log('already connected to %a', existingConnection.remoteAddr)
-      options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
-      return existingConnection
     }
 
     // ready to dial, all async work finished - make sure we don't have any
@@ -461,7 +446,7 @@ export class DialQueue {
       // if the resolved multiaddr has a PeerID but it's the wrong one, ignore it
       // - this can happen with addresses like bootstrap.libp2p.io that resolve
       // to multiple different peers
-      const addrPeerId = addr.multiaddr.getPeerId()
+      const addrPeerId = addr.multiaddr.getComponents().findLast(c => c.code === CODE_P2P)?.value
       if (peerId != null && addrPeerId != null) {
         return peerId.equals(addrPeerId)
       }

package/src/connection-manager/index.ts

@@ -1,7 +1,8 @@
 import { ConnectionClosedError, InvalidMultiaddrError, InvalidParametersError, InvalidPeerIdError, NotStartedError, start, stop } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
-import { RateLimiter } from '@libp2p/utils/rate-limiter'
+import { getNetConfig, isNetworkAddress, RateLimiter } from '@libp2p/utils'
 import { multiaddr } from '@multiformats/multiaddr'
+import { pEvent } from 'p-event'
 import { CustomProgressEvent } from 'progress-events'
 import { getPeerAddress } from '../get-peer.js'
 import { ConnectionPruner } from './connection-pruner.js'
@@ -9,11 +10,11 @@ import { DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_DIAL_Q
 import { DialQueue } from './dial-queue.js'
 import { ReconnectQueue } from './reconnect-queue.js'
 import { dnsaddrResolver } from './resolvers/index.ts'
-import { multiaddrToIpNet } from './utils.js'
+import { findExistingConnection, multiaddrToIpNet } from './utils.js'
 import type { IpNet } from '@chainsafe/netmask'
-import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions, MultiaddrResolver } from '@libp2p/interface'
+import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions, MultiaddrResolver, Stream, NewStreamOptions } from '@libp2p/interface'
 import type { ConnectionManager, OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
-import type { JobStatus } from '@libp2p/utils/queue'
+import type { JobStatus } from '@libp2p/utils'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
 
@@ -66,30 +67,20 @@ export interface ConnectionManagerInit {
   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.
+   * How many ms to wait when closing a connection if an abort signal is not
+   * passed
    *
-   * @default 10_000
+   * @default 1_000
    */
-  inboundUpgradeTimeout?: number
+  connectionCloseTimeout?: number
 
   /**
-   * When a new outbound connection is opened, the upgrade process (e.g.
+   * When a new incoming connection is opened, the upgrade process (e.g.
    * protect, encrypt, multiplex etc) must complete within this number of ms.
    *
-   * Does not apply if an abort signal is passed to the `.dial` method.
-   *
-   * @deprecated This is handled by `dialTimeout`
-   */
-  outboundUpgradeTimeout?: number
-
-  /**
-   * Protocol negotiation must complete within this number of ms
-   *
-   * @default 2000
-   * @deprecated use outboundStreamProtocolNegotiationTimeout or inboundStreamProtocolNegotiationTimeout instead
+   * @default 10_000
    */
-  protocolNegotiationTimeout?: number
+  inboundUpgradeTimeout?: number
 
   /**
    * Outbound protocol negotiation must complete within this number of ms.
@@ -241,8 +232,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.onDisconnect = this.onDisconnect.bind(this)
 
     // allow/deny lists
-    this.allow = (init.allow ?? []).map(str => multiaddrToIpNet(str))
-    this.deny = (init.deny ?? []).map(str => multiaddrToIpNet(str))
+    this.allow = (init.allow ?? []).map(str => multiaddrToIpNet(multiaddr(str)))
+    this.deny = (init.deny ?? []).map(str => multiaddrToIpNet(multiaddr(str)))
 
     this.incomingPendingConnections = 0
     this.maxIncomingPendingConnections = init.maxIncomingPendingConnections ?? defaultOptions.maxIncomingPendingConnections
@@ -399,16 +390,22 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     )
 
     // Close all connections we're tracking
-    const tasks: Array<Promise<void>> = []
+    const tasks: Array<Promise<any>> = []
     for (const connectionList of this.connections.values()) {
       for (const connection of connectionList) {
-        tasks.push((async () => {
-          try {
-            await connection.close()
-          } catch (err) {
-            this.log.error(err)
-          }
-        })())
+        tasks.push(
+          Promise.all([
+            pEvent(connection, 'close', {
+              signal: AbortSignal.timeout(500)
+            }),
+            connection.close({
+              signal: AbortSignal.timeout(500)
+            })
+          ])
+            .catch(err => {
+              connection.abort(err)
+            })
+        )
       }
     }
 
@@ -504,7 +501,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       this.connections.delete(peerId)
 
       // broadcast disconnect event
-      this.events.safeDispatchEvent('peer:disconnect', { detail: connection.remotePeer })
+      this.events.safeDispatchEvent('peer:disconnect', { detail: peerId })
     }
   }
 
@@ -536,7 +533,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     try {
       options.signal?.throwIfAborted()
 
-      const { peerId } = getPeerAddress(peerIdOrMultiaddr)
+      const { peerId, multiaddrs } = getPeerAddress(peerIdOrMultiaddr)
 
       if (this.peerId.equals(peerId)) {
         throw new InvalidPeerIdError('Can not dial self')
@@ -544,11 +541,10 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
       if (peerId != null && options.force !== true) {
         this.log('dial %p', peerId)
-        const existingConnection = this.getConnections(peerId)
-          .find(conn => conn.limits == null)
+        const existingConnection = findExistingConnection(peerId, this.getConnections(peerId), multiaddrs)
 
         if (existingConnection != null) {
-          this.log('had an existing non-limited connection to %p as %a', peerId, existingConnection.remoteAddr)
+          this.log('had an existing connection to %p as %a', peerId, existingConnection.remoteAddr)
 
           options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
           return existingConnection
@@ -600,13 +596,22 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     }
   }
 
+  async openStream (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], protocol: string | string[], options: OpenConnectionOptions & NewStreamOptions = {}): Promise<Stream> {
+    const connection = await this.openConnection(peerIdOrMultiaddr, options)
+
+    return connection.newStream(protocol, options)
+  }
+
   async closeConnections (peerId: PeerId, options: AbortOptions = {}): Promise<void> {
     const connections = this.connections.get(peerId) ?? []
 
     await Promise.all(
       connections.map(async connection => {
         try {
-          await connection.close(options)
+          await Promise.all([
+            pEvent(connection, 'close', options),
+            connection.close(options)
+          ])
         } catch (err: any) {
           connection.abort(err)
         }
@@ -614,10 +619,15 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     )
   }
 
-  async acceptIncomingConnection (maConn: MultiaddrConnection): Promise<boolean> {
+  acceptIncomingConnection (maConn: MultiaddrConnection): boolean {
     // check deny list
-    const denyConnection = this.deny.some(ma => {
-      return ma.contains(maConn.remoteAddr.nodeAddress().address)
+    const denyConnection = this.deny.some(ipNet => {
+      if (isNetworkAddress(maConn.remoteAddr)) {
+        const config = getNetConfig(maConn.remoteAddr)
+        return ipNet.contains(config.host)
+      }
+
+      return false
     })
 
     if (denyConnection) {
@@ -627,7 +637,12 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     // check allow list
     const allowConnection = this.allow.some(ipNet => {
-      return ipNet.contains(maConn.remoteAddr.nodeAddress().address)
+      if (isNetworkAddress(maConn.remoteAddr)) {
+        const config = getNetConfig(maConn.remoteAddr)
+        return ipNet.contains(config.host)
+      }
+
+      return true
     })
 
     if (allowConnection) {
@@ -642,13 +657,13 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       return false
     }
 
-    if (maConn.remoteAddr.isThinWaistAddress()) {
-      const host = maConn.remoteAddr.nodeAddress().address
+    if (isNetworkAddress(maConn.remoteAddr)) {
+      const config = getNetConfig(maConn.remoteAddr)
 
       try {
-        await this.inboundConnectionRateLimiter.consume(host, 1)
+        this.inboundConnectionRateLimiter.consume(config.host, 1)
       } catch {
-        this.log('connection from %a refused - inboundConnectionThreshold exceeded by host %s', maConn.remoteAddr, host)
+        this.log('connection from %a refused - inboundConnectionThreshold exceeded by host %s', maConn.remoteAddr, config.host)
         return false
       }
     }

package/src/connection-manager/reconnect-queue.ts

@@ -1,5 +1,5 @@
 import { KEEP_ALIVE } from '@libp2p/interface'
-import { PeerQueue } from '@libp2p/utils/peer-queue'
+import { PeerQueue } from '@libp2p/utils'
 import pRetry from 'p-retry'
 import { MAX_PARALLEL_RECONNECTS } from './constants.js'
 import type { ComponentLogger, Libp2pEvents, Logger, Metrics, Peer, PeerId, PeerStore, Startable } from '@libp2p/interface'

package/src/connection-manager/utils.ts

@@ -1,38 +1,146 @@
-import { multiaddr } from '@multiformats/multiaddr'
-import { convertToIpNet } from '@multiformats/multiaddr/convert'
-import type { IpNet } from '@chainsafe/netmask'
+import { IpNet } from '@chainsafe/netmask'
+import { InvalidParametersError } from '@libp2p/interface'
+import { getNetConfig } from '@libp2p/utils'
+import { Circuit } from '@multiformats/multiaddr-matcher'
+import type { Connection, AbortOptions, PeerId } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
+/**
+ * These are speculative protocols that are run automatically on connection open
+ * so are usually not the reason the connection was opened.
+ *
+ * Consequently when requested it should be safe to close connections that only
+ * have these protocol streams open.
+ */
+const DEFAULT_CLOSABLE_PROTOCOLS = [
+  // identify
+  '/ipfs/id/1.0.0',
+
+  // identify-push
+  '/ipfs/id/push/1.0.0',
+
+  // autonat
+  '/libp2p/autonat/1.0.0',
+
+  // dcutr
+  '/libp2p/dcutr'
+]
+
+export interface SafelyCloseConnectionOptions extends AbortOptions {
+  /**
+   * Only close the stream if it either has no protocol streams open or only
+   * ones in this list.
+   *
+   * @default ['/ipfs/id/1.0.0']
+   */
+  closableProtocols?: string[]
+}
+
+/**
+ * Close the passed connection if it has no streams, or only closable protocol
+ * streams, falling back to aborting the connection if closing it cleanly fails.
+ */
+export async function safelyCloseConnectionIfUnused (connection?: Connection, options?: SafelyCloseConnectionOptions): Promise<void> {
+  const streamProtocols = connection?.streams?.map(stream => stream.protocol) ?? []
+  const closableProtocols = options?.closableProtocols ?? DEFAULT_CLOSABLE_PROTOCOLS
+
+  // if the connection has protocols not in the closable protocols list, do not
+  // close the connection
+  if (streamProtocols.filter(proto => proto != null && !closableProtocols.includes(proto)).length > 0) {
+    return
+  }
+
+  try {
+    await connection?.close(options)
+  } catch (err: any) {
+    connection?.abort(err)
+  }
+}
+
 /**
  * Converts a multiaddr string or object to an IpNet object.
  * If the multiaddr doesn't include /ipcidr, it will encapsulate with the appropriate CIDR:
  * - /ipcidr/32 for IPv4
  * - /ipcidr/128 for IPv6
  *
- * @param {string | Multiaddr} ma - The multiaddr string or object to convert.
+ * @param {string | Multiaddr} ma - The multiaddr object to convert.
  * @returns {IpNet} The converted IpNet object.
  * @throws {Error} Throws an error if the multiaddr is not valid.
  */
-export function multiaddrToIpNet (ma: string | Multiaddr): IpNet {
-  try {
-    let parsedMa: Multiaddr
-    if (typeof ma === 'string') {
-      parsedMa = multiaddr(ma)
-    } else {
-      parsedMa = ma
-    }
+export function multiaddrToIpNet (ma: Multiaddr): IpNet {
+  const config = getNetConfig(ma)
+  let mask = config.cidr
 
-    const protoNames = new Set([...parsedMa.getComponents().map(component => component.name)])
+  if (config.type !== 'ip4' && config.type !== 'ip6') {
+    throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
+  }
 
-    // Check if /ipcidr is already present
-    if (!protoNames.has('ipcidr')) {
-      const isIPv6 = protoNames.has('ip6')
-      const cidr = isIPv6 ? '/ipcidr/128' : '/ipcidr/32'
-      parsedMa = parsedMa.encapsulate(cidr)
+  // Check if /ipcidr is already present
+  if (mask == null) {
+    switch (config.type) {
+      case 'ip4': {
+        mask = 32
+        break
+      }
+      case 'ip6': {
+        mask = 128
+        break
+      }
+      default: {
+        throw new InvalidParametersError(`Multiaddr ${ma} was not an IPv4 or IPv6 address`)
+      }
     }
+  }
+
+  return new IpNet(config.host, mask)
+}
+
+/**
+ * Returns true if the passed multiaddr would result in a direct connection to
+ * the peer.
+ *
+ * Currently only circuit relay addresses are supported as indirect connections.
+ */
+export function isDirect (ma: Multiaddr): boolean {
+  return !Circuit.exactMatch(ma)
+}
+
+/**
+ * If there is an existing non-limited connection to the remote peer return it,
+ * unless it is indirect and at least one of the passed dial addresses would
+ * result in a direct connection
+ */
+export function findExistingConnection (peerId?: PeerId, connections?: Connection[], dialAddresses?: Multiaddr[]): Connection | undefined {
+  if (peerId == null || connections == null) {
+    return
+  }
+
+  const existingConnection = connections
+    .sort((a, b) => {
+      if (a.direct) {
+        return -1
+      }
+
+      if (b.direct) {
+        return 1
+      }
 
-    return convertToIpNet(parsedMa)
-  } catch (error) {
-    throw new Error(`Can't convert to IpNet, Invalid multiaddr format: ${ma}`)
+      return 0
+    })
+    .find(con => con.limits == null)
+
+  if (existingConnection == null || existingConnection.direct || dialAddresses == null) {
+    return existingConnection
   }
+
+  // we have an indirect, but unlimited connection - test the dial addresses to
+  // see if any of them would result in a direct connection, in which case allow
+  // the attempt to upgrade to a direct connection
+  const wouldUpgradeToDirect = dialAddresses.some(ma => isDirect(ma))
+
+  if (wouldUpgradeToDirect) {
+    return
+  }
+
+  return existingConnection
 }

package/src/connection-monitor.ts

@@ -1,11 +1,10 @@
 import { randomBytes } from '@libp2p/crypto'
 import { serviceCapabilities } from '@libp2p/interface'
-import { AdaptiveTimeout } from '@libp2p/utils/adaptive-timeout'
-import { byteStream } from 'it-byte-stream'
+import { AdaptiveTimeout, byteStream } from '@libp2p/utils'
 import { setMaxListeners } from 'main-event'
 import type { ComponentLogger, Logger, Metrics, Startable } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
-import type { AdaptiveTimeoutInit } from '@libp2p/utils/adaptive-timeout'
+import type { AdaptiveTimeoutInit } from '@libp2p/utils'
 
 const DEFAULT_PING_INTERVAL_MS = 10000
 const PROTOCOL_VERSION = '1.0.0'
@@ -120,7 +119,7 @@ export class ConnectionMonitor implements Startable {
 
             conn.rtt = Date.now() - start
 
-            await bs.unwrap().close({
+            await stream.close({
               signal
             })
           } catch (err: any) {