libp2p 0.44.0 → 0.45.0-08d4c261

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

@@ -1,9 +1,11 @@
 import { logger } from '@libp2p/logger'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import { PeerMap } from '@libp2p/peer-collections'
+import { PeerMap, PeerSet } from '@libp2p/peer-collections'
 import PQueue from 'p-queue'
 import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_INTERVAL, AUTO_DIAL_PRIORITY, MIN_CONNECTIONS } from './constants.js'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { EventEmitter } from '@libp2p/interfaces/events'
 import type { Startable } from '@libp2p/interfaces/startable'
 
 const log = logger('libp2p:connection-manager:auto-dial')
@@ -18,6 +20,7 @@ interface AutoDialInit {
 interface AutoDialComponents {
   connectionManager: ConnectionManager
   peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 const defaultOptions = {
@@ -55,6 +58,14 @@ export class AutoDial implements Startable {
     this.queue.addListener('error', (err) => {
       log.error('error during auto-dial', err)
     })
+
+    // check the min connection limit whenever a peer disconnects
+    components.events.addEventListener('connection:close', () => {
+      this.autoDial()
+        .catch(err => {
+          log.error(err)
+        })
+    })
   }
 
   isStarted (): boolean {
@@ -86,7 +97,18 @@ export class AutoDial implements Startable {
   }
 
   async autoDial (): Promise<void> {
-    const numConnections = this.connectionManager.getConnections().length
+    if (!this.started) {
+      return
+    }
+
+    const connections = this.connectionManager.getConnectionsMap()
+    const numConnections = connections.size
+    const dialQueue = new PeerSet(
+      // @ts-expect-error boolean filter removes falsy peer IDs
+      this.connectionManager.getDialQueue()
+        .map(queue => queue.peerId)
+        .filter(Boolean)
+    )
 
     // Already has enough connections
     if (numConnections >= this.minConnections) {
@@ -97,40 +119,47 @@ export class AutoDial implements Startable {
     log('not enough connections %d/%d - will dial peers to increase the number of connections', numConnections, this.minConnections)
 
     // Sort peers on whether we know protocols or public keys for them
-    let peers = await this.peerStore.all()
-
-    log('loaded %d peers from the peer store', peers.length)
+    const peers = await this.peerStore.all()
 
     // Remove some peers
-    peers = peers.filter((peer) => {
+    const filteredPeers = peers.filter((peer) => {
       // Remove peers without addresses
       if (peer.addresses.length === 0) {
         return false
       }
 
+      // remove peers we are already connected to
+      if (connections.has(peer.id)) {
+        return false
+      }
+
+      // remove peers we are already dialling
+      if (dialQueue.has(peer.id)) {
+        return false
+      }
+
       return true
     })
 
-    // shuffle the peers
-    peers = peers.sort(() => Math.random() > 0.5 ? 1 : -1)
+    // shuffle the peers - this is so peers with the same tag values will be
+    // dialled in a different order each time
+    const shuffledPeers = filteredPeers.sort(() => Math.random() > 0.5 ? 1 : -1)
 
     // Sort shuffled peers by tag value
     const peerValues = new PeerMap<number>()
-    for (const peer of peers) {
+    for (const peer of shuffledPeers) {
       if (peerValues.has(peer.id)) {
         continue
       }
 
-      const tags = await this.peerStore.getTags(peer.id)
-
       // sum all tag values
-      peerValues.set(peer.id, (tags ?? []).reduce((acc, curr) => {
+      peerValues.set(peer.id, [...peer.tags.values()].reduce((acc, curr) => {
         return acc + curr.value
       }, 0))
     }
 
     // sort by value, highest to lowest
-    const sortedPeers = peers.sort((a, b) => {
+    const sortedPeers = shuffledPeers.sort((a, b) => {
       const peerAValue = peerValues.get(a.id) ?? 0
       const peerBValue = peerValues.get(b.id) ?? 0
 
@@ -145,11 +174,11 @@ export class AutoDial implements Startable {
       return 0
     })
 
-    log('selected %d peers to dial', sortedPeers.length)
+    log('selected %d/%d peers to dial', sortedPeers.length, peers.length)
 
     for (const peer of sortedPeers) {
       this.queue.add(async () => {
-        const numConnections = this.connectionManager.getConnections().length
+        const numConnections = this.connectionManager.getConnectionsMap().size
 
         // Check to see if we still need to auto dial
         if (numConnections >= this.minConnections) {

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

@@ -1,10 +1,11 @@
 import { logger } from '@libp2p/logger'
+import { PeerMap } from '@libp2p/peer-collections'
+import { MAX_CONNECTIONS } from './constants.js'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 import type { PeerStore } from '@libp2p/interface-peer-store'
-import { PeerMap } from '@libp2p/peer-collections'
+import type { EventEmitter } from '@libp2p/interfaces/events'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import { MAX_CONNECTIONS } from './constants.js'
-import { CustomEvent } from '@libp2p/interfaces/events'
 
 const log = logger('libp2p:connection-manager:connection-pruner')
 
@@ -16,6 +17,7 @@ interface ConnectionPrunerInit {
 interface ConnectionPrunerComponents {
   connectionManager: ConnectionManager
   peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 const defaultOptions = {
@@ -31,12 +33,22 @@ export class ConnectionPruner {
   private readonly connectionManager: ConnectionManager
   private readonly peerStore: PeerStore
   private readonly allow: Multiaddr[]
+  private readonly events: EventEmitter<Libp2pEvents>
 
   constructor (components: ConnectionPrunerComponents, init: ConnectionPrunerInit = {}) {
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
     this.allow = init.allow ?? defaultOptions.allow
     this.connectionManager = components.connectionManager
     this.peerStore = components.peerStore
+    this.events = components.events
+
+    // check the max connection limit whenever a peer connects
+    components.events.addEventListener('connection:open', () => {
+      this.maybePruneConnections()
+        .catch(err => {
+          log.error(err)
+        })
+    })
   }
 
   /**
@@ -48,7 +60,7 @@ export class ConnectionPruner {
     const numConnections = connections.length
     const toPrune = Math.max(numConnections - this.maxConnections, 0)
 
-    log.trace('checking max connections limit %d/%d', numConnections, this.maxConnections)
+    log('checking max connections limit %d/%d', numConnections, this.maxConnections)
     if (numConnections <= this.maxConnections) {
       return
     }
@@ -64,12 +76,20 @@ export class ConnectionPruner {
         continue
       }
 
-      const tags = await this.peerStore.getTags(remotePeer)
+      peerValues.set(remotePeer, 0)
+
+      try {
+        const peer = await this.peerStore.get(remotePeer)
 
-      // sum all tag values
-      peerValues.set(remotePeer, tags.reduce((acc, curr) => {
-        return acc + curr.value
-      }, 0))
+        // sum all tag values
+        peerValues.set(remotePeer, [...peer.tags.values()].reduce((acc, curr) => {
+          return acc + curr.value
+        }, 0))
+      } catch (err: any) {
+        if (err.code !== 'ERR_NOT_FOUND') {
+          log.error('error loading peer tags', err)
+        }
+      }
     }
 
     // sort by value, lowest to highest
@@ -132,6 +152,6 @@ export class ConnectionPruner {
     )
 
     // despatch prune event
-    this.connectionManager.dispatchEvent(new CustomEvent('peer:prune', { detail: toClose.map(conn => conn.remotePeer) }))
+    this.events.safeDispatchEvent('connection:prune', { detail: toClose })
   }
 }

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

@@ -1,28 +1,29 @@
-import { logger } from '@libp2p/logger'
+import { setMaxListeners } from 'events'
 import { AbortError, CodeError } from '@libp2p/interfaces/errors'
-import { Multiaddr, Resolver, resolvers } from '@multiformats/multiaddr'
-import { TimeoutController } from 'timeout-abort-controller'
+import { logger } from '@libp2p/logger'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
+import { type Multiaddr, type Resolver, resolvers } from '@multiformats/multiaddr'
+import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
+import { type ClearableSignal, anySignal } from 'any-signal'
+import pDefer from 'p-defer'
+import PQueue from 'p-queue'
 import { codes } from '../errors.js'
+import { getPeerAddress } from '../get-peer.js'
 import {
   DIAL_TIMEOUT,
   MAX_PARALLEL_DIALS_PER_PEER,
   MAX_PARALLEL_DIALS,
   MAX_PEER_ADDRS_TO_DIAL
 } from './constants.js'
+import { combineSignals, resolveMultiaddrs } from './utils.js'
 import type { Connection } from '@libp2p/interface-connection'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import { getPeerAddress } from '../get-peer.js'
-import type { Address, AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { AddressSorter } from '@libp2p/interface-libp2p'
 import type { Metric, Metrics } from '@libp2p/interface-metrics'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { Address, PeerStore } from '@libp2p/interface-peer-store'
 import type { TransportManager } from '@libp2p/interface-transport'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import PQueue from 'p-queue'
-import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
-import { combineSignals, resolveMultiaddrs } from './utils.js'
-import pDefer from 'p-defer'
-import type { ClearableSignal } from 'any-signal'
+import type { AbortOptions } from '@libp2p/interfaces'
 
 const log = logger('libp2p:connection-manager:dial-queue')
 
@@ -100,6 +101,11 @@ export class DialQueue {
     this.transportManager = components.transportManager
     this.shutDownController = new AbortController()
 
+    try {
+      // This emitter gets listened to a lot
+      setMaxListeners?.(Infinity, this.shutDownController.signal)
+    } catch {}
+
     this.pendingDialCount = components.metrics?.registerMetric('libp2p_dialler_pending_dials')
     this.inProgressDialCount = components.metrics?.registerMetric('libp2p_dialler_in_progress_dials')
     this.pendingDials = []
@@ -175,7 +181,7 @@ export class DialQueue {
 
     // create abort conditions - need to do this before `calculateMultiaddrs` as we may be about to
     // resolve a dns addr which can time out
-    const { timeoutController, signal } = this.createDialAbortControllers(options.signal)
+    const signal = this.createDialAbortControllers(options.signal)
     let addrsToDial: Address[]
 
     try {
@@ -186,7 +192,6 @@ export class DialQueue {
       })
     } catch (err) {
       signal.clear()
-      timeoutController.clear()
       throw err
     }
 
@@ -209,8 +214,7 @@ export class DialQueue {
     if (existingDial != null) {
       log('joining existing dial target for %p', peerId)
       signal.clear()
-      timeoutController.clear()
-      return await existingDial.promise
+      return existingDial.promise
     }
 
     log('creating dial target for', addrsToDial.map(({ multiaddr }) => multiaddr.toString()))
@@ -232,13 +236,12 @@ export class DialQueue {
 
         // clean up abort signals/controllers
         signal.clear()
-        timeoutController.clear()
       })
       .catch(err => {
-        log.error('dial failed to %s', addrsToDial.map(({ multiaddr }) => multiaddr.toString()).join(', '), err)
+        log.error('dial failed to %s', pendingDial.multiaddrs.map(ma => ma.toString()).join(', '), err)
 
         // Error is a timeout
-        if (timeoutController.signal.aborted) {
+        if (signal.aborted) {
           const error = new CodeError(err.message, codes.ERR_TIMEOUT)
           throw error
         }
@@ -249,23 +252,27 @@ export class DialQueue {
     // let other dials join this one
     this.pendingDials.push(pendingDial)
 
-    return await pendingDial.promise
+    return pendingDial.promise
   }
 
-  private createDialAbortControllers (userSignal?: AbortSignal): { timeoutController: TimeoutController, signal: ClearableSignal } {
-    // ensure we throw if the dial takes longer than the dial timeout
-    const timeoutController = new TimeoutController(this.dialTimeout)
-
+  private createDialAbortControllers (userSignal?: AbortSignal): ClearableSignal {
     // let any signal abort the dial
-    const signal = combineSignals(
-      timeoutController.signal,
-      this.shutDownController.signal,
-      userSignal
+    const signal = anySignal(
+      [AbortSignal.timeout(this.dialTimeout),
+        this.shutDownController.signal,
+        userSignal
+      ]
     )
 
-    return { timeoutController, signal }
+    try {
+      // This emitter gets listened to a lot
+      setMaxListeners?.(Infinity, signal)
+    } catch {}
+
+    return signal
   }
 
+  // eslint-disable-next-line complexity
   private async calculateMultiaddrs (peerId?: PeerId, addrs: Address[] = [], options: DialOptions = {}): Promise<Address[]> {
     // if a peer id or multiaddr(s) with a peer id, make sure it isn't our peer id and that we are allowed to dial it
     if (peerId != null) {
@@ -280,8 +287,15 @@ export class DialQueue {
       // if just a peer id was passed, load available multiaddrs for this peer from the address book
       if (addrs.length === 0) {
         log('loading multiaddrs for %p', peerId)
-        addrs.push(...(await this.peerStore.addressBook.get(peerId)))
-        log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()))
+        try {
+          const peer = await this.peerStore.get(peerId)
+          addrs.push(...peer.addresses)
+          log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()))
+        } catch (err: any) {
+          if (err.code !== codes.ERR_NOT_FOUND) {
+            throw err
+          }
+        }
       }
     }
 
@@ -306,7 +320,7 @@ export class DialQueue {
     const filteredAddrs = resolvedAddresses.filter(addr => Boolean(this.transportManager.transportForMultiaddr(addr.multiaddr)))
 
     // deduplicate addresses
-    const dedupedAddrs: Map<string, Address> = new Map()
+    const dedupedAddrs = new Map<string, Address>()
 
     for (const addr of filteredAddrs) {
       const maStr = addr.multiaddr.toString()
@@ -371,7 +385,14 @@ export class DialQueue {
       gatedAdrs.push(addr)
     }
 
-    return gatedAdrs.sort(this.addressSorter)
+    const sortedGatedAddrs = gatedAdrs.sort(this.addressSorter)
+
+    // make sure we actually have some addresses to dial
+    if (sortedGatedAddrs.length === 0) {
+      throw new CodeError('The connection gater denied all addresses in the dial request', codes.ERR_NO_VALID_ADDRESSES)
+    }
+
+    return sortedGatedAddrs
   }
 
   private async performDial (pendingDial: PendingDial, options: DialOptions = {}): Promise<Connection> {
@@ -471,7 +492,7 @@ export class DialQueue {
           signal.clear()
         })
 
-        return await deferred.promise
+        return deferred.promise
       }))
 
       // dial succeeded or failed

package/src/connection-manager/index.ts

@@ -1,29 +1,28 @@
-import { logger } from '@libp2p/logger'
-import { CodeError } from '@libp2p/interfaces/errors'
-import type { AbortOptions } from '@libp2p/interfaces'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
-import type { Startable } from '@libp2p/interfaces/startable'
-import { codes } from '../errors.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import { setMaxListeners } from 'events'
-import type { Connection, MultiaddrConnection } from '@libp2p/interface-connection'
-import type { ConnectionManager, ConnectionManagerEvents } from '@libp2p/interface-connection-manager'
-import type { AddressSorter, PeerStore } from '@libp2p/interface-peer-store'
-import { Multiaddr, Resolver, multiaddr } from '@multiformats/multiaddr'
 import { KEEP_ALIVE } from '@libp2p/interface-peer-store/tags'
+import { CodeError } from '@libp2p/interfaces/errors'
+import { logger } from '@libp2p/logger'
+import { PeerMap } from '@libp2p/peer-collections'
+import { publicAddressesFirst } from '@libp2p/utils/address-sort'
+import { type Multiaddr, type Resolver, multiaddr } from '@multiformats/multiaddr'
+import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import { RateLimiterMemory } from 'rate-limiter-flexible'
-import type { Metrics } from '@libp2p/interface-metrics'
-import type { TransportManager, Upgrader } from '@libp2p/interface-transport'
+import { codes } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
 import { AutoDial } from './auto-dial.js'
-import { DialQueue } from './dial-queue.js'
 import { ConnectionPruner } from './connection-pruner.js'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import { PeerMap } from '@libp2p/peer-collections'
-import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_PRIORITY, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL, MIN_CONNECTIONS } from './constants.js'
-import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
-import type { PendingDial } from '../libp2p.js'
+import { DialQueue } from './dial-queue.js'
+import type { Connection, MultiaddrConnection } from '@libp2p/interface-connection'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
+import type { PendingDial, AddressSorter, Libp2pEvents } from '@libp2p/interface-libp2p'
+import type { Metrics } from '@libp2p/interface-metrics'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { TransportManager } from '@libp2p/interface-transport'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Startable } from '@libp2p/interfaces/startable'
 
 const log = logger('libp2p:connection-manager')
 
@@ -143,10 +142,10 @@ const defaultOptions = {
 export interface DefaultConnectionManagerComponents {
   peerId: PeerId
   metrics?: Metrics
-  upgrader: Upgrader
   peerStore: PeerStore
   transportManager: TransportManager
   connectionGater: ConnectionGater
+  events: EventEmitter<Libp2pEvents>
 }
 
 export interface OpenConnectionOptions extends AbortOptions {
@@ -156,7 +155,7 @@ export interface OpenConnectionOptions extends AbortOptions {
 /**
  * Responsible for managing known connections.
  */
-export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEvents> implements ConnectionManager, Startable {
+export class DefaultConnectionManager implements ConnectionManager, Startable {
   private started: boolean
   private readonly connections: PeerMap<Connection[]>
   private readonly allow: Multiaddr[]
@@ -172,10 +171,9 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
 
   private readonly peerStore: PeerStore
   private readonly metrics?: Metrics
+  private readonly events: EventEmitter<Libp2pEvents>
 
   constructor (components: DefaultConnectionManagerComponents, init: ConnectionManagerInit = {}) {
-    super()
-
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
     const minConnections = init.minConnections ?? defaultOptions.minConnections
 
@@ -189,17 +187,14 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     this.connections = new PeerMap()
 
     this.started = false
-
-    try {
-      // This emitter gets listened to a lot
-      setMaxListeners?.(Infinity, this)
-    } catch {}
-
     this.peerStore = components.peerStore
     this.metrics = components.metrics
+    this.events = components.events
 
     this.onConnect = this.onConnect.bind(this)
     this.onDisconnect = this.onDisconnect.bind(this)
+    this.events.addEventListener('connection:open', this.onConnect)
+    this.events.addEventListener('connection:close', this.onDisconnect)
 
     // allow/deny lists
     this.allow = (init.allow ?? []).map(ma => multiaddr(ma))
@@ -217,35 +212,23 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
     // controls what happens when we don't have enough connections
     this.autoDial = new AutoDial({
       connectionManager: this,
-      peerStore: components.peerStore
+      peerStore: components.peerStore,
+      events: components.events
     }, {
       minConnections,
       autoDialConcurrency: init.autoDialConcurrency ?? defaultOptions.autoDialConcurrency,
       autoDialPriority: init.autoDialPriority ?? defaultOptions.autoDialPriority
     })
-    // check the min connection limit whenever a peer disconnects
-    this.addEventListener('peer:disconnect', () => {
-      this.autoDial.autoDial()
-        .catch(err => {
-          log.error(err)
-        })
-    })
 
     // controls what happens when we have too many connections
     this.connectionPruner = new ConnectionPruner({
       connectionManager: this,
-      peerStore: components.peerStore
+      peerStore: components.peerStore,
+      events: components.events
     }, {
       maxConnections: this.maxConnections,
       allow: this.allow
     })
-    // check the max connection limit whenever a peer connects
-    this.addEventListener('peer:connect', () => {
-      this.connectionPruner.maybePruneConnections()
-        .catch(err => {
-          log.error(err)
-        })
-    })
 
     this.dialQueue = new DialQueue({
       peerId: components.peerId,
@@ -262,9 +245,6 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
         dnsaddr: dnsaddrResolver
       }
     })
-
-    components.upgrader.addEventListener('connection', this.onConnect)
-    components.upgrader.addEventListener('connectionEnd', this.onDisconnect)
   }
 
   isStarted (): boolean {
@@ -367,10 +347,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
         const keepAlivePeers: PeerId[] = []
 
         for (const peer of await this.peerStore.all()) {
-          const tags = await this.peerStore.getTags(peer.id)
-          const hasKeepAlive = tags.filter(tag => tag.name === KEEP_ALIVE).length > 0
-
-          if (hasKeepAlive) {
+          if (peer.tags.has(KEEP_ALIVE)) {
             keepAlivePeers.push(peer.id)
           }
         }
@@ -439,18 +416,25 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
 
     const peerId = connection.remotePeer
     const storedConns = this.connections.get(peerId)
+    let isNewPeer = false
 
     if (storedConns != null) {
       storedConns.push(connection)
     } else {
+      isNewPeer = true
       this.connections.set(peerId, [connection])
     }
 
-    if (peerId.publicKey != null) {
-      await this.peerStore.keyBook.set(peerId, peerId.publicKey)
+    // only need to store RSA public keys, all other types are embedded in the peer id
+    if (peerId.publicKey != null && peerId.type === 'RSA') {
+      await this.peerStore.patch(peerId, {
+        publicKey: peerId.publicKey
+      })
     }
 
-    this.dispatchEvent(new CustomEvent<Connection>('peer:connect', { detail: connection }))
+    if (isNewPeer) {
+      this.events.safeDispatchEvent('peer:connect', { detail: connection.remotePeer })
+    }
   }
 
   /**
@@ -472,7 +456,7 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
       this.connections.set(peerId, storedConn)
     } else if (storedConn != null) {
       this.connections.delete(peerId)
-      this.dispatchEvent(new CustomEvent<Connection>('peer:disconnect', { detail: connection }))
+      this.events.safeDispatchEvent('peer:disconnect', { detail: connection.remotePeer })
     }
   }
 
@@ -495,6 +479,10 @@ export class DefaultConnectionManager extends EventEmitter<ConnectionManagerEven
   }
 
   async openConnection (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], options: OpenConnectionOptions = {}): Promise<Connection> {
+    if (!this.isStarted()) {
+      throw new CodeError('Not started', codes.ERR_NODE_NOT_STARTED)
+    }
+
     const { peerId } = getPeerAddress(peerIdOrMultiaddr)
 
     if (peerId != null) {

package/src/connection-manager/utils.ts

@@ -1,8 +1,7 @@
-import { AbortOptions, multiaddr } from '@multiformats/multiaddr'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import { logger } from '@libp2p/logger'
-import { ClearableSignal, anySignal } from 'any-signal'
 import { setMaxListeners } from 'events'
+import { logger } from '@libp2p/logger'
+import { type AbortOptions, multiaddr, type Multiaddr } from '@multiformats/multiaddr'
+import { type ClearableSignal, anySignal } from 'any-signal'
 
 const log = logger('libp2p:connection-manager:utils')
 
@@ -21,7 +20,7 @@ export async function resolveMultiaddrs (ma: Multiaddr, options: AbortOptions):
 
   const resolvedMultiaddrs = await resolveRecord(ma, options)
   const recursiveMultiaddrs = await Promise.all(resolvedMultiaddrs.map(async (nm) => {
-    return await resolveMultiaddrs(nm, options)
+    return resolveMultiaddrs(nm, options)
   }))
 
   const addrs = recursiveMultiaddrs.flat()