libp2p 0.43.4 → 0.44.0-17eb162a

package/src/autonat/index.ts

@@ -1,6 +1,6 @@
 import type { AddressManager } from '@libp2p/interface-address-manager'
 import type { Connection } from '@libp2p/interface-connection'
-import type { ConnectionManager, Dialer } from '@libp2p/interface-connection-manager'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { PeerInfo } from '@libp2p/interface-peer-info'
 import type { PeerRouting } from '@libp2p/interface-peer-routing'
@@ -74,7 +74,6 @@ export interface DefaultAutonatComponents {
   registrar: Registrar
   addressManager: AddressManager
   transportManager: TransportManager
-  dialer: Dialer
   peerId: PeerId
   connectionManager: ConnectionManager
   peerRouting: PeerRouting
@@ -151,7 +150,7 @@ export class AutonatService implements Startable {
 
       await pipe(
         source,
-        lp.decode(),
+        (source) => lp.decode(source),
         async function * (stream) {
           const buf = await first(stream)
 
@@ -319,9 +318,7 @@ export class AutonatService implements Startable {
             lastMultiaddr = multiaddr
 
             try {
-              // use the dialer so we can dial a specific multiaddr instead of every known
-              // multiaddr for the peer
-              connection = await self.components.dialer.dial(multiaddr, {
+              connection = await self.components.connectionManager.openConnection(multiaddr, {
                 signal: controller.signal
               })
 
@@ -360,7 +357,7 @@ export class AutonatService implements Startable {
             }
           })
         },
-        lp.encode(),
+        (source) => lp.encode(source),
         // pipe to the stream, not the abortable source other wise we
         // can't tell the remote when a dial timed out..
         data.stream
@@ -449,9 +446,9 @@ export class AutonatService implements Startable {
 
           const buf = await pipe(
             [request],
-            lp.encode(),
+            (source) => lp.encode(source),
             source,
-            lp.decode(),
+            (source) => lp.decode(source),
             async (stream) => await first(stream)
           )
           if (buf == null) {

package/src/circuit-relay/server/advert-service.ts

@@ -7,7 +7,7 @@ import {
 } from '../constants.js'
 import type { Startable } from '@libp2p/interfaces/startable'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interfaces/events'
 import pRetry from 'p-retry'
 
 const log = logger('libp2p:circuit-relay:advert-service')
@@ -90,7 +90,7 @@ export class AdvertService extends EventEmitter<AdvertServiceEvents> implements
         const cid = await namespaceToCid(RELAY_RENDEZVOUS_NS)
         await this.contentRouting.provide(cid)
 
-        this.dispatchEvent(new CustomEvent('advert:success'))
+        this.safeDispatchEvent('advert:success', { detail: undefined })
       } catch (err: any) {
         this.safeDispatchEvent('advert:error', { detail: err })
 

package/src/circuit-relay/server/index.ts

@@ -24,7 +24,7 @@ import { ReservationVoucherRecord } from './reservation-voucher.js'
 import type { AddressManager } from '@libp2p/interface-address-manager'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { CircuitRelayService, RelayReservation } from '../index.js'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interfaces/events'
 import { setMaxListeners } from 'events'
 import type { PeerMap } from '@libp2p/peer-collections'
 
@@ -128,7 +128,7 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
     if (init.advertise != null && init.advertise !== false) {
       this.advertService = new AdvertService(components, init.advertise === true ? undefined : init.advertise)
       this.advertService.addEventListener('advert:success', () => {
-        this.dispatchEvent(new CustomEvent('relay:advert:success'))
+        this.safeDispatchEvent('relay:advert:success', {})
       })
       this.advertService.addEventListener('advert:error', (evt) => {
         this.safeDispatchEvent('relay:advert:error', { detail: evt.detail })
@@ -260,7 +260,11 @@ class CircuitRelayServer extends EventEmitter<RelayServerEvents> implements Star
       // result.expire is non-null if `ReservationStore.reserve` returns with status == OK
       if (result.expire != null) {
         const ttl = (result.expire * 1000) - Date.now()
-        await this.peerStore.tagPeer(connection.remotePeer, RELAY_SOURCE_TAG, { value: 1, ttl })
+        await this.peerStore.merge(connection.remotePeer, {
+          tags: {
+            [RELAY_SOURCE_TAG]: { value: 1, ttl }
+          }
+        })
       }
 
       hopstr.write({

package/src/circuit-relay/transport/discovery.ts

@@ -113,7 +113,9 @@ export class RelayDiscovery extends EventEmitter<RelayDiscoveryEvents> implement
 
           found++
           log('found relay peer %p in content routing', peerId)
-          await this.peerStore.addressBook.add(peerId, provider.multiaddrs)
+          await this.peerStore.merge(peerId, {
+            multiaddrs: provider.multiaddrs
+          })
 
           this.safeDispatchEvent('relay:discover', { detail: peerId })
         }

package/src/circuit-relay/transport/index.ts

@@ -23,6 +23,8 @@ import { CIRCUIT_PROTO_CODE, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../
 import { RelayStoreInit, ReservationStore } from './reservation-store.js'
 import { RelayDiscovery, RelayDiscoveryComponents } from './discovery.js'
 import { CodeError } from '@libp2p/interfaces/errors'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:circuit-relay:transport')
 
@@ -49,6 +51,7 @@ export interface CircuitRelayTransportComponents extends RelayDiscoveryComponent
   addressManager: AddressManager
   contentRouting: ContentRouting
   connectionGater: ConnectionGater
+  events: EventEmitter<Libp2pEvents>
 }
 
 interface ConnectOptions {
@@ -81,6 +84,7 @@ class CircuitRelayTransport implements Transport {
   private readonly upgrader: Upgrader
   private readonly addressManager: AddressManager
   private readonly connectionGater: ConnectionGater
+  private readonly events: EventEmitter<Libp2pEvents>
   private readonly reservationStore: ReservationStore
   private started: boolean
 
@@ -92,6 +96,7 @@ class CircuitRelayTransport implements Transport {
     this.upgrader = components.upgrader
     this.addressManager = components.addressManager
     this.connectionGater = components.connectionGater
+    this.events = components.events
 
     if (init.discoverRelays != null && init.discoverRelays > 0) {
       this.discovery = new RelayDiscovery(components)
@@ -178,7 +183,9 @@ class CircuitRelayTransport implements Transport {
     let relayConnection = relayConnections[0]
 
     if (relayConnection == null) {
-      await this.peerStore.addressBook.add(relayPeer, [relayAddr])
+      await this.peerStore.merge(relayPeer, {
+        multiaddrs: [relayAddr]
+      })
       relayConnection = await this.connectionManager.openConnection(relayPeer, options)
       disconnectOnFailure = true
     }
@@ -249,7 +256,8 @@ class CircuitRelayTransport implements Transport {
   createListener (options: CreateListenerOptions): Listener {
     return createListener({
       connectionManager: this.connectionManager,
-      relayStore: this.reservationStore
+      relayStore: this.reservationStore,
+      events: this.events
     })
   }
 

package/src/circuit-relay/transport/listener.ts

@@ -1,4 +1,4 @@
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interfaces/events'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { Listener, ListenerEvents } from '@libp2p/interface-transport'
 import type { Multiaddr } from '@multiformats/multiaddr'
@@ -7,24 +7,28 @@ import type { ReservationStore } from './reservation-store.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import { PeerMap } from '@libp2p/peer-collections'
 import { logger } from '@libp2p/logger'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:circuit-relay:transport:listener')
 
 export interface CircuitRelayTransportListenerComponents {
   connectionManager: ConnectionManager
   relayStore: ReservationStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> implements Listener {
   private readonly connectionManager: ConnectionManager
   private readonly relayStore: ReservationStore
   private readonly listeningAddrs: PeerMap<Multiaddr>
+  private readonly events: EventEmitter<Libp2pEvents>
 
   constructor (components: CircuitRelayTransportListenerComponents) {
     super()
 
     this.connectionManager = components.connectionManager
     this.relayStore = components.relayStore
+    this.events = components.events
     this.listeningAddrs = new PeerMap()
 
     // remove listening addrs when a relay is removed
@@ -33,7 +37,7 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
     })
 
     // remove listening addrs when a peer disconnects
-    this.connectionManager.addEventListener('peer:disconnect', (evt) => {
+    this.events.addEventListener('connection:close', (evt) => {
       this.#removeRelayPeer(evt.detail.remotePeer)
     })
   }
@@ -57,7 +61,7 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
     }
 
     this.listeningAddrs.set(relayConn.remotePeer, addr)
-    this.dispatchEvent(new CustomEvent('listening'))
+    this.safeDispatchEvent('listening', {})
   }
 
   /**
@@ -89,7 +93,7 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
 
     if (had) {
       // Announce listen addresses change
-      this.dispatchEvent(new CustomEvent('close'))
+      this.safeDispatchEvent('close', {})
     }
   }
 }

package/src/circuit-relay/transport/reservation-store.ts

@@ -10,10 +10,11 @@ import type { Reservation } from '../pb/index.js'
 import { HopMessage, Status } from '../pb/index.js'
 import { getExpirationMilliseconds } from '../utils.js'
 import type { TransportManager } from '@libp2p/interface-transport'
-import type { Startable } from '@libp2p/interfaces/dist/src/startable.js'
-import { CustomEvent, EventEmitter } from '@libp2p/interfaces/events'
+import type { Startable } from '@libp2p/interfaces/startable'
+import { EventEmitter } from '@libp2p/interfaces/events'
 import type { PeerStore } from '@libp2p/interface-peer-store'
 import { multiaddr } from '@multiformats/multiaddr'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 
 const log = logger('libp2p:circuit-relay:transport:reservation-store')
 
@@ -31,6 +32,7 @@ export interface RelayStoreComponents {
   connectionManager: ConnectionManager
   transportManager: TransportManager
   peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
 }
 
 export interface RelayStoreInit {
@@ -68,6 +70,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
   private readonly connectionManager: ConnectionManager
   private readonly transportManager: TransportManager
   private readonly peerStore: PeerStore
+  private readonly events: EventEmitter<Libp2pEvents>
   private readonly reserveQueue: PQueue
   private readonly reservations: PeerMap<RelayEntry>
   private readonly maxDiscoveredRelays: number
@@ -80,6 +83,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     this.connectionManager = components.connectionManager
     this.transportManager = components.transportManager
     this.peerStore = components.peerStore
+    this.events = components.events
     this.reservations = new PeerMap()
     this.maxDiscoveredRelays = init?.discoverRelays ?? 0
     this.started = false
@@ -92,7 +96,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     // When a peer disconnects, if we had a reservation on that peer
     // remove the reservation and multiaddr and maybe trigger search
     // for new relays
-    this.connectionManager.addEventListener('peer:disconnect', (evt) => {
+    this.events.addEventListener('connection:close', (evt) => {
       this.removeRelay(evt.detail.remotePeer)
     })
   }
@@ -184,9 +188,13 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
         })
 
         // ensure we don't close the connection to the relay
-        await this.peerStore.tagPeer(peerId, RELAY_TAG, {
-          value: 1,
-          ttl: expiration
+        await this.peerStore.merge(peerId, {
+          tags: {
+            [RELAY_TAG]: {
+              value: 1,
+              ttl: expiration
+            }
+          }
         })
 
         await this.transportManager.listen(
@@ -250,7 +258,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     this.safeDispatchEvent('relay:removed', { detail: peerId })
 
     if (this.reservations.size < this.maxDiscoveredRelays) {
-      this.dispatchEvent(new CustomEvent('relay:not-enough-relays'))
+      this.safeDispatchEvent('relay:not-enough-relays', {})
     }
   }
 }

package/src/circuit-relay/utils.ts

@@ -7,7 +7,7 @@ import { logger } from '@libp2p/logger'
 import type { Stream } from '@libp2p/interface-connection'
 import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT } from './constants.js'
 import { abortableSource } from 'abortable-iterator'
-import anySignal from 'any-signal'
+import { anySignal } from 'any-signal'
 
 const log = logger('libp2p:circuit-relay:utils')
 
@@ -69,6 +69,7 @@ const doRelay = (src: Stream, dst: Stream, abortSignal: AbortSignal, limit: Requ
         srcDstFinished = true
 
         if (dstSrcFinished) {
+          signal.clear()
           clearTimeout(timeout)
         }
       })
@@ -86,6 +87,7 @@ const doRelay = (src: Stream, dst: Stream, abortSignal: AbortSignal, limit: Requ
         dstSrcFinished = true
 
         if (srcDstFinished) {
+          signal.clear()
           clearTimeout(timeout)
         }
       })

package/src/components.ts

@@ -12,11 +12,14 @@ import type { TransportManager, Upgrader } from '@libp2p/interface-transport'
 import type { Datastore } from 'interface-datastore'
 import type { PubSub } from '@libp2p/interface-pubsub'
 import type { DualDHT } from '@libp2p/interface-dht'
-import type { ConnectionManager, Dialer } from '@libp2p/interface-connection-manager'
+import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
+import type { EventEmitter } from '@libp2p/interfaces/events'
 
 export interface Components {
   peerId: PeerId
+  events: EventEmitter<Libp2pEvents>
   addressManager: AddressManager
   peerStore: PeerStore
   upgrader: Upgrader
@@ -28,7 +31,6 @@ export interface Components {
   peerRouting: PeerRouting
   datastore: Datastore
   connectionProtector?: ConnectionProtector
-  dialer: Dialer
   metrics?: Metrics
   dht?: DualDHT
   pubsub?: PubSub
@@ -36,6 +38,7 @@ export interface Components {
 
 export interface ComponentsInit {
   peerId?: PeerId
+  events?: EventEmitter<Libp2pEvents>
   addressManager?: AddressManager
   peerStore?: PeerStore
   upgrader?: Upgrader
@@ -50,11 +53,11 @@ export interface ComponentsInit {
   connectionProtector?: ConnectionProtector
   dht?: DualDHT
   pubsub?: PubSub
-  dialer?: Dialer
 }
 
 export class DefaultComponents implements Components, Startable {
   private _peerId?: PeerId
+  private _events?: EventEmitter<Libp2pEvents>
   private _addressManager?: AddressManager
   private _peerStore?: PeerStore
   private _upgrader?: Upgrader
@@ -69,11 +72,11 @@ export class DefaultComponents implements Components, Startable {
   private _connectionProtector?: ConnectionProtector
   private _dht?: DualDHT
   private _pubsub?: PubSub
-  private _dialer?: Dialer
   private _started = false
 
   constructor (init: ComponentsInit = {}) {
     this._peerId = init.peerId
+    this._events = init.events
     this._addressManager = init.addressManager
     this._peerStore = init.peerStore
     this._upgrader = init.upgrader
@@ -88,7 +91,6 @@ export class DefaultComponents implements Components, Startable {
     this._connectionProtector = init.connectionProtector
     this._dht = init.dht
     this._pubsub = init.pubsub
-    this._dialer = init.dialer
   }
 
   isStarted (): boolean {
@@ -167,6 +169,18 @@ export class DefaultComponents implements Components, Startable {
     this._peerId = peerId
   }
 
+  get events (): EventEmitter<Libp2pEvents> {
+    if (this._events == null) {
+      throw new CodeError('events not set', 'ERR_SERVICE_MISSING')
+    }
+
+    return this._events
+  }
+
+  set events (events: EventEmitter<Libp2pEvents>) {
+    this._events = events
+  }
+
   get addressManager (): AddressManager {
     if (this._addressManager == null) {
       throw new CodeError('addressManager not set', 'ERR_SERVICE_MISSING')
@@ -295,18 +309,6 @@ export class DefaultComponents implements Components, Startable {
     this._connectionProtector = connectionProtector
   }
 
-  get dialer (): Dialer {
-    if (this._dialer == null) {
-      throw new CodeError('dialer not set', 'ERR_SERVICE_MISSING')
-    }
-
-    return this._dialer
-  }
-
-  set dialer (dialer: Dialer) {
-    this._dialer = dialer
-  }
-
   get metrics (): Metrics | undefined {
     return this._metrics
   }

package/src/config.ts

@@ -1,6 +1,5 @@
 import mergeOptions from 'merge-options'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
-import * as Constants from './constants.js'
 import { AGENT_VERSION } from './identify/consts.js'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { FaultTolerance } from '@libp2p/interface-transport'
@@ -19,19 +18,11 @@ const DefaultConfig: Partial<Libp2pInit> = {
     announceFilter: (multiaddrs: Multiaddr[]) => multiaddrs
   },
   connectionManager: {
-    maxConnections: 300,
-    minConnections: 50,
-    autoDialInterval: 10000,
-    maxParallelDials: Constants.MAX_PARALLEL_DIALS,
-    maxDialsPerPeer: Constants.MAX_PER_PEER_DIALS,
-    dialTimeout: Constants.DIAL_TIMEOUT,
-    inboundUpgradeTimeout: Constants.INBOUND_UPGRADE_TIMEOUT,
     resolvers: {
       dnsaddr: dnsaddrResolver
     },
     addressSorter: publicAddressesFirst
   },
-  connectionGater: {},
   transportManager: {
     faultTolerance: FaultTolerance.FATAL_ALL
   },

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

@@ -0,0 +1,183 @@
+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 PQueue from 'p-queue'
+import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_INTERVAL, AUTO_DIAL_PRIORITY, MIN_CONNECTIONS } from './constants.js'
+import type { Startable } from '@libp2p/interfaces/startable'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
+
+const log = logger('libp2p:connection-manager:auto-dial')
+
+interface AutoDialInit {
+  minConnections?: number
+  autoDialConcurrency?: number
+  autoDialPriority?: number
+  autoDialInterval?: number
+}
+
+interface AutoDialComponents {
+  connectionManager: ConnectionManager
+  peerStore: PeerStore
+  events: EventEmitter<Libp2pEvents>
+}
+
+const defaultOptions = {
+  minConnections: MIN_CONNECTIONS,
+  autoDialConcurrency: AUTO_DIAL_CONCURRENCY,
+  autoDialPriority: AUTO_DIAL_PRIORITY,
+  autoDialInterval: AUTO_DIAL_INTERVAL
+}
+
+export class AutoDial implements Startable {
+  private readonly connectionManager: ConnectionManager
+  private readonly peerStore: PeerStore
+  private readonly queue: PQueue
+  private readonly minConnections: number
+  private readonly autoDialPriority: number
+  private readonly autoDialIntervalMs: number
+  private autoDialInterval?: ReturnType<typeof setInterval>
+  private started: boolean
+
+  /**
+   * Proactively tries to connect to known peers stored in the PeerStore.
+   * It will keep the number of connections below the upper limit and sort
+   * the peers to connect based on whether we know their keys and protocols.
+   */
+  constructor (components: AutoDialComponents, init: AutoDialInit) {
+    this.connectionManager = components.connectionManager
+    this.peerStore = components.peerStore
+    this.minConnections = init.minConnections ?? defaultOptions.minConnections
+    this.autoDialPriority = init.autoDialPriority ?? defaultOptions.autoDialPriority
+    this.autoDialIntervalMs = init.autoDialInterval ?? defaultOptions.autoDialInterval
+    this.started = false
+    this.queue = new PQueue({
+      concurrency: init.autoDialConcurrency ?? defaultOptions.autoDialConcurrency
+    })
+    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 {
+    return this.started
+  }
+
+  start (): void {
+    this.autoDialInterval = setInterval(() => {
+      this.autoDial()
+        .catch(err => {
+          log.error('error while autodialing', err)
+        })
+    }, this.autoDialIntervalMs)
+    this.started = true
+  }
+
+  afterStart (): void {
+    this.autoDial()
+      .catch(err => {
+        log.error('error while autodialing', err)
+      })
+  }
+
+  stop (): void {
+    // clear the queue
+    this.queue.clear()
+    clearInterval(this.autoDialInterval)
+    this.started = false
+  }
+
+  async autoDial (): Promise<void> {
+    if (!this.started) {
+      return
+    }
+
+    const numConnections = this.connectionManager.getConnections().length
+
+    // Already has enough connections
+    if (numConnections >= this.minConnections) {
+      log('have enough connections %d/%d', numConnections, this.minConnections)
+      return
+    }
+
+    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
+    const peers = await this.peerStore.all()
+
+    // Remove some peers
+    const filteredPeers = peers.filter((peer) => {
+      // Remove peers without addresses
+      if (peer.addresses.length === 0) {
+        return false
+      }
+
+      return true
+    })
+
+    // 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 shuffledPeers) {
+      if (peerValues.has(peer.id)) {
+        continue
+      }
+
+      // sum all tag values
+      peerValues.set(peer.id, [...peer.tags.values()].reduce((acc, curr) => {
+        return acc + curr.value
+      }, 0))
+    }
+
+    // sort by value, highest to lowest
+    const sortedPeers = shuffledPeers.sort((a, b) => {
+      const peerAValue = peerValues.get(a.id) ?? 0
+      const peerBValue = peerValues.get(b.id) ?? 0
+
+      if (peerAValue > peerBValue) {
+        return -1
+      }
+
+      if (peerAValue < peerBValue) {
+        return 1
+      }
+
+      return 0
+    })
+
+    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
+
+        // Check to see if we still need to auto dial
+        if (numConnections >= this.minConnections) {
+          log('got enough connections now %d/%d', numConnections, this.minConnections)
+          this.queue.clear()
+          return
+        }
+
+        log('connecting to a peerStore stored peer %p', peer.id)
+        await this.connectionManager.openConnection(peer.id, {
+          // @ts-expect-error needs adding to the ConnectionManager interface
+          priority: this.autoDialPriority
+        })
+      }).catch(err => {
+        log.error('could not connect to peerStore stored peer', err)
+      })
+    }
+  }
+}