libp2p 1.9.4 → 2.0.0-7cd984569

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

@@ -1,10 +1,5 @@
 export * from './constants.defaults.js'
 
-/**
- * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#minConnections
- */
-export const MIN_CONNECTIONS = 5
-
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#maxConnections
  */
@@ -14,8 +9,3 @@ export const MAX_CONNECTIONS = 100
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#maxParallelDials
  */
 export const MAX_PARALLEL_DIALS = 50
-
-/**
- * @see https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.unknown.ConnectionManagerInit.html#autoDialPeerRetryThreshold
- */
-export const AUTO_DIAL_PEER_RETRY_THRESHOLD = 1000 * 60 * 7

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

@@ -13,31 +13,6 @@ export const INBOUND_UPGRADE_TIMEOUT = 2e3
  */
 export const MAX_PEER_ADDRS_TO_DIAL = 25
 
-/**
- * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#autoDialInterval
- */
-export const AUTO_DIAL_INTERVAL = 5000
-
-/**
- * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#autoDialConcurrency
- */
-export const AUTO_DIAL_CONCURRENCY = 25
-
-/**
- * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#autoDialPriority
- */
-export const AUTO_DIAL_PRIORITY = 0
-
-/**
- * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#autoDialMaxQueueLength
- */
-export const AUTO_DIAL_MAX_QUEUE_LENGTH = 100
-
-/**
- * @see https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.unknown.ConnectionManagerInit.html#autoDialDiscoveredPeersDebounce
- */
-export const AUTO_DIAL_DISCOVERED_PEERS_DEBOUNCE = 10
-
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#inboundConnectionThreshold
  */
@@ -48,16 +23,28 @@ export const INBOUND_CONNECTION_THRESHOLD = 5
  */
 export const MAX_INCOMING_PENDING_CONNECTIONS = 10
 
+/**
+ * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#maxParallelReconnects
+ */
+export const MAX_PARALLEL_RECONNECTS = 5
+
 /**
  * Store as part of the peer store metadata for a given peer, the value for this
- * key is a timestamp of the last time a dial attempted failed with the relevant
- * peer stored as a string.
+ * key is a timestamp of the last time a dial attempt failed with the timestamp
+ * stored as a string.
  *
  * Used to insure we do not endlessly try to auto dial peers we have recently
  * failed to dial.
  */
 export const LAST_DIAL_FAILURE_KEY = 'last-dial-failure'
 
+/**
+ * Store as part of the peer store metadata for a given peer, the value for this
+ * key is a timestamp of the last time a dial attempt succeeded with the
+ * timestamp stored as a string.
+ */
+export const LAST_DIAL_SUCCESS_KEY = 'last-dial-success'
+
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#maxDialQueueLength
  */

package/src/connection-manager/constants.ts

@@ -1,10 +1,5 @@
 export * from './constants.defaults.js'
 
-/**
- * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#minConnections
- */
-export const MIN_CONNECTIONS = 50
-
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#maxConnections
  */
@@ -14,8 +9,3 @@ export const MAX_CONNECTIONS = 300
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#maxParallelDials
  */
 export const MAX_PARALLEL_DIALS = 100
-
-/**
- * @see https://libp2p.github.io/js-libp2p/interfaces/libp2p.index.unknown.ConnectionManagerInit.html#autoDialPeerRetryThreshold
- */
-export const AUTO_DIAL_PEER_RETRY_THRESHOLD = 1000 * 60

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

@@ -1,5 +1,5 @@
 /* eslint-disable max-depth */
-import { CodeError, AggregateCodeError, ERR_TIMEOUT, setMaxListeners } from '@libp2p/interface'
+import { TimeoutError, DialError, setMaxListeners } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { PriorityQueue, type PriorityQueueJobOptions } from '@libp2p/utils/priority-queue'
@@ -9,14 +9,15 @@ import { Circuit } from '@multiformats/multiaddr-matcher'
 import { type ClearableSignal, anySignal } from 'any-signal'
 import { CustomProgressEvent } from 'progress-events'
 import { fromString as uint8ArrayFromString } from 'uint8arrays/from-string'
-import { codes } from '../errors.js'
+import { DialDeniedError, NoValidAddressesError } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
 import {
   DIAL_TIMEOUT,
   MAX_PARALLEL_DIALS,
   MAX_PEER_ADDRS_TO_DIAL,
   LAST_DIAL_FAILURE_KEY,
-  MAX_DIAL_QUEUE_LENGTH
+  MAX_DIAL_QUEUE_LENGTH,
+  LAST_DIAL_SUCCESS_KEY
 } from './constants.js'
 import { resolveMultiaddrs } from './utils.js'
 import { DEFAULT_DIAL_PRIORITY } from './index.js'
@@ -192,7 +193,7 @@ export class DialQueue {
     }
 
     if (this.queue.size >= this.maxDialQueueLength) {
-      throw new CodeError('Dial queue is full', 'ERR_DIAL_QUEUE_FULL')
+      throw new DialError('Dial queue is full')
     }
 
     this.log('creating dial target for %p', peerId, multiaddrs.map(ma => ma.toString()))
@@ -231,7 +232,7 @@ export class DialQueue {
           if (dialed === this.maxPeerAddrsToDial) {
             this.log('dialed maxPeerAddrsToDial (%d) addresses for %p, not trying any others', dialed, peerId)
 
-            throw new CodeError('Peer had more than maxPeerAddrsToDial', codes.ERR_TOO_MANY_ADDRESSES)
+            throw new DialError('Peer had more than maxPeerAddrsToDial')
           }
 
           dialed++
@@ -244,6 +245,20 @@ export class DialQueue {
 
             this.log('dial to %a succeeded', address.multiaddr)
 
+            // record the successful dial and the address
+            try {
+              await this.components.peerStore.merge(conn.remotePeer, {
+                multiaddrs: [
+                  conn.remoteAddr
+                ],
+                metadata: {
+                  [LAST_DIAL_SUCCESS_KEY]: uint8ArrayFromString(Date.now().toString())
+                }
+              })
+            } catch (err: any) {
+              this.log.error('could not update last dial failure key for %p', peerId, err)
+            }
+
             return conn
           } catch (err: any) {
             this.log.error('dial failed to %a', address.multiaddr, err)
@@ -251,7 +266,7 @@ export class DialQueue {
             if (peerId != null) {
               // record the failed dial
               try {
-                await this.components.peerStore.patch(peerId, {
+                await this.components.peerStore.merge(peerId, {
                   metadata: {
                     [LAST_DIAL_FAILURE_KEY]: uint8ArrayFromString(Date.now().toString())
                   }
@@ -263,7 +278,7 @@ export class DialQueue {
 
             // the user/dial timeout/shutdown controller signal aborted
             if (signal.aborted) {
-              throw new CodeError(err.message, ERR_TIMEOUT)
+              throw new TimeoutError(err.message)
             }
 
             errors.push(err)
@@ -274,7 +289,7 @@ export class DialQueue {
           throw errors[0]
         }
 
-        throw new AggregateCodeError(errors, 'All multiaddr dials failed', codes.ERR_TRANSPORT_DIAL_FAILED)
+        throw new AggregateError(errors, 'All multiaddr dials failed')
       } finally {
         // clean up abort signals/controllers
         signal.clear()
@@ -312,11 +327,11 @@ export class DialQueue {
     // 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) {
       if (this.components.peerId.equals(peerId)) {
-        throw new CodeError('Tried to dial self', codes.ERR_DIALED_SELF)
+        throw new DialError('Tried to dial self')
       }
 
       if ((await this.components.connectionGater.denyDialPeer?.(peerId)) === true) {
-        throw new CodeError('The dial request is blocked by gater.allowDialPeer', codes.ERR_PEER_DIAL_INTERCEPTED)
+        throw new DialDeniedError('The dial request is blocked by gater.allowDialPeer')
       }
 
       // if just a peer id was passed, load available multiaddrs for this peer
@@ -328,7 +343,7 @@ export class DialQueue {
           addrs.push(...peer.addresses)
           this.log('loaded multiaddrs for %p', peerId, addrs.map(({ multiaddr }) => multiaddr.toString()))
         } catch (err: any) {
-          if (err.code !== codes.ERR_NOT_FOUND) {
+          if (err.name !== 'NotFoundError') {
             throw err
           }
         }
@@ -349,7 +364,7 @@ export class DialQueue {
             isCertified: false
           })))
         } catch (err: any) {
-          if (err.code !== codes.ERR_NO_ROUTERS_AVAILABLE) {
+          if (err.name !== 'NoPeerRoutersError') {
             this.log.error('looking up multiaddrs for %p in the peer routing failed', peerId, err)
           }
         }
@@ -437,7 +452,7 @@ export class DialQueue {
 
     // make sure we actually have some addresses to dial
     if (dedupedMultiaddrs.length === 0) {
-      throw new CodeError('The dial request has no valid addresses', codes.ERR_NO_VALID_ADDRESSES)
+      throw new NoValidAddressesError('The dial request has no valid addresses')
     }
 
     const gatedAdrs: Address[] = []
@@ -454,7 +469,7 @@ export class DialQueue {
 
     // 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)
+      throw new DialDeniedError('The connection gater denied all addresses in the dial request')
     }
 
     this.log.trace('addresses for %p before filtering', peerId ?? 'unknown peer', resolvedAddresses.map(({ multiaddr }) => multiaddr.toString()))
@@ -471,7 +486,7 @@ export class DialQueue {
     try {
       const addresses = await this.calculateMultiaddrs(undefined, new Set(multiaddr.map(ma => ma.toString())), options)
 
-      if (options.runOnTransientConnection === false) {
+      if (options.runOnLimitedConnection === false) {
         // return true if any resolved multiaddrs are not relay addresses
         return addresses.find(addr => {
           return !Circuit.matches(addr.multiaddr)

package/src/connection-manager/index.ts

@@ -1,17 +1,16 @@
-import { CodeError, KEEP_ALIVE } from '@libp2p/interface'
+import { InvalidParametersError, NotStartedError, start, stop } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
 import { defaultAddressSort } from '@libp2p/utils/address-sort'
 import { RateLimiter } from '@libp2p/utils/rate-limiter'
 import { type Multiaddr, type Resolver, multiaddr } from '@multiformats/multiaddr'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import { CustomProgressEvent } from 'progress-events'
-import { codes } from '../errors.js'
 import { getPeerAddress } from '../get-peer.js'
-import { AutoDial } from './auto-dial.js'
 import { ConnectionPruner } from './connection-pruner.js'
-import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_DISCOVERED_PEERS_DEBOUNCE, AUTO_DIAL_MAX_QUEUE_LENGTH, AUTO_DIAL_PEER_RETRY_THRESHOLD, AUTO_DIAL_PRIORITY, DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_DIAL_QUEUE_LENGTH, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL, MIN_CONNECTIONS } from './constants.js'
+import { DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_DIAL_QUEUE_LENGTH, MAX_INCOMING_PENDING_CONNECTIONS, MAX_PARALLEL_DIALS, MAX_PEER_ADDRS_TO_DIAL } from './constants.js'
 import { DialQueue } from './dial-queue.js'
-import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, Peer, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions } from '@libp2p/interface'
+import { ReconnectQueue } from './reconnect-queue.js'
+import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, TypedEventTarget, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions } from '@libp2p/interface'
 import type { ConnectionManager, OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
 import type { JobStatus } from '@libp2p/utils/queue'
 
@@ -19,57 +18,13 @@ export const DEFAULT_DIAL_PRIORITY = 50
 
 export interface ConnectionManagerInit {
   /**
-   * The maximum number of connections libp2p is willing to have before it starts
-   * pruning connections to reduce resource usage. (default: 300, 100 in browsers)
+   * The maximum number of connections libp2p is willing to have before it
+   * starts pruning connections to reduce resource usage.
+   *
+   * @default 300/100
    */
   maxConnections?: number
 
-  /**
-   * The minimum number of connections below which libp2p will start to dial peers
-   * from the peer book. Setting this to 0 effectively disables this behaviour.
-   * (default: 50, 5 in browsers)
-   */
-  minConnections?: number
-
-  /**
-   * How long to wait between attempting to keep our number of concurrent connections
-   * above minConnections (default: 5000)
-   */
-  autoDialInterval?: number
-
-  /**
-   * When dialling peers from the peer book to keep the number of open connections
-   * above `minConnections`, add dials for this many peers to the dial queue
-   * at once. (default: 25)
-   */
-  autoDialConcurrency?: number
-
-  /**
-   * To allow user dials to take priority over auto dials, use this value as the
-   * dial priority. (default: 0)
-   */
-  autoDialPriority?: number
-
-  /**
-   * Limit the maximum number of peers to dial when trying to keep the number of
-   * open connections above `minConnections`. (default: 100)
-   */
-  autoDialMaxQueueLength?: number
-
-  /**
-   * When we've failed to dial a peer, do not autodial them again within this
-   * number of ms. (default: 1 minute, 7 minutes in browsers)
-   */
-  autoDialPeerRetryThreshold?: number
-
-  /**
-   * Newly discovered peers may be auto-dialed to increase the number of open
-   * connections, but they can be discovered in quick succession so add a small
-   * delay before attempting to dial them in case more peers have been
-   * discovered. (default: 10ms)
-   */
-  autoDialDiscoveredPeersDebounce?: number
-
   /**
    * Sort the known addresses of a peer before trying to dial, By default public
    * addresses will be dialled before private (e.g. loopback or LAN) addresses.
@@ -78,7 +33,8 @@ export interface ConnectionManagerInit {
 
   /**
    * The maximum number of dials across all peers to execute in parallel.
-   * (default: 100, 50 in browsers)
+   *
+   * @default 100/50
    */
   maxParallelDials?: number
 
@@ -106,7 +62,9 @@ export interface ConnectionManagerInit {
 
   /**
    * When a new inbound connection is opened, the upgrade process (e.g. protect,
-   * encrypt, multiplex etc) must complete within this number of ms. (default: 30s)
+   * encrypt, multiplex etc) must complete within this number of ms.
+   *
+   * @default 30000
    */
   inboundUpgradeTimeout?: number
 
@@ -117,7 +75,8 @@ export interface ConnectionManagerInit {
 
   /**
    * A list of multiaddrs that will always be allowed (except if they are in the
-   * deny list) to open connections to this node even if we've reached maxConnections
+   * deny list) to open connections to this node even if we've reached
+   * maxConnections
    */
   allow?: string[]
 
@@ -134,23 +93,52 @@ export interface ConnectionManagerInit {
   inboundConnectionThreshold?: number
 
   /**
-   * The maximum number of parallel incoming connections allowed that have yet to
-   * complete the connection upgrade - e.g. choosing connection encryption, muxer, etc.
-   * (default: 10)
+   * The maximum number of parallel incoming connections allowed that have yet
+   * to complete the connection upgrade - e.g. choosing connection encryption,
+   * muxer, etc.
+   *
+   * @default 10
    */
   maxIncomingPendingConnections?: number
+
+  /**
+   * When a peer tagged with `KEEP_ALIVE` disconnects, attempt to redial them
+   * this many times.
+   *
+   * @default 5
+   */
+  reconnectRetries?: number
+
+  /**
+   * When a peer tagged with `KEEP_ALIVE` disconnects, wait this long between
+   * each retry. Note this will be multiplied by `reconnectFactor` to create an
+   * increasing retry backoff.
+   *
+   * @default 1000
+   */
+  reconnectRetryInterval?: number
+
+  /**
+   * When a peer tagged with `KEEP_ALIVE` disconnects, apply this multiplication
+   * factor to the time interval between each retry.
+   *
+   * @default 2
+   */
+  reconnectBackoffFactor?: number
+
+  /**
+   * When a peers tagged with `KEEP_ALIVE` disconnect, reconnect to this many at
+   * once.
+   *
+   * @default 5
+   */
+  maxParallelReconnects?: number
 }
 
 const defaultOptions = {
-  minConnections: MIN_CONNECTIONS,
   maxConnections: MAX_CONNECTIONS,
   inboundConnectionThreshold: INBOUND_CONNECTION_THRESHOLD,
-  maxIncomingPendingConnections: MAX_INCOMING_PENDING_CONNECTIONS,
-  autoDialConcurrency: AUTO_DIAL_CONCURRENCY,
-  autoDialPriority: AUTO_DIAL_PRIORITY,
-  autoDialMaxQueueLength: AUTO_DIAL_MAX_QUEUE_LENGTH,
-  autoDialPeerRetryThreshold: AUTO_DIAL_PEER_RETRY_THRESHOLD,
-  autoDialDiscoveredPeersDebounce: AUTO_DIAL_DISCOVERED_PEERS_DEBOUNCE
+  maxIncomingPendingConnections: MAX_INCOMING_PENDING_CONNECTIONS
 }
 
 export interface DefaultConnectionManagerComponents {
@@ -177,7 +165,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
   private readonly maxConnections: number
 
   public readonly dialQueue: DialQueue
-  public readonly autoDial: AutoDial
+  public readonly reconnectQueue: ReconnectQueue
   public readonly connectionPruner: ConnectionPruner
   private readonly inboundConnectionRateLimiter: RateLimiter
   private readonly peerStore: PeerStore
@@ -187,10 +175,9 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
   constructor (components: DefaultConnectionManagerComponents, init: ConnectionManagerInit = {}) {
     this.maxConnections = init.maxConnections ?? defaultOptions.maxConnections
-    const minConnections = init.minConnections ?? defaultOptions.minConnections
 
-    if (this.maxConnections < minConnections) {
-      throw new CodeError('Connection Manager maxConnections must be greater than minConnections', codes.ERR_INVALID_PARAMETERS)
+    if (this.maxConnections < 1) {
+      throw new InvalidParametersError('Connection Manager maxConnections must be greater than 0')
     }
 
     /**
@@ -222,21 +209,6 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       duration: 1
     })
 
-    // controls what happens when we don't have enough connections
-    this.autoDial = new AutoDial({
-      connectionManager: this,
-      peerStore: components.peerStore,
-      events: components.events,
-      logger: components.logger
-    }, {
-      minConnections,
-      autoDialConcurrency: init.autoDialConcurrency ?? defaultOptions.autoDialConcurrency,
-      autoDialPriority: init.autoDialPriority ?? defaultOptions.autoDialPriority,
-      autoDialPeerRetryThreshold: init.autoDialPeerRetryThreshold ?? defaultOptions.autoDialPeerRetryThreshold,
-      autoDialDiscoveredPeersDebounce: init.autoDialDiscoveredPeersDebounce ?? defaultOptions.autoDialDiscoveredPeersDebounce,
-      maxQueueLength: init.autoDialMaxQueueLength ?? defaultOptions.autoDialMaxQueueLength
-    })
-
     // controls what happens when we have too many connections
     this.connectionPruner = new ConnectionPruner({
       connectionManager: this,
@@ -259,6 +231,18 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       },
       connections: this.connections
     })
+
+    this.reconnectQueue = new ReconnectQueue({
+      events: components.events,
+      peerStore: components.peerStore,
+      logger: components.logger,
+      connectionManager: this
+    }, {
+      retries: init.reconnectRetries,
+      retryInterval: init.reconnectRetryInterval,
+      backoffFactor: init.reconnectBackoffFactor,
+      maxParallelReconnects: init.maxParallelReconnects
+    })
   }
 
   readonly [Symbol.toStringTag] = '@libp2p/connection-manager'
@@ -350,45 +334,23 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       }
     })
 
-    this.dialQueue.start()
-    this.autoDial.start()
+    await start(
+      this.dialQueue,
+      this.reconnectQueue
+    )
 
     this.started = true
     this.log('started')
   }
 
-  async afterStart (): Promise<void> {
-    // re-connect to any peers with the KEEP_ALIVE tag
-    void Promise.resolve()
-      .then(async () => {
-        const keepAlivePeers: Peer[] = await this.peerStore.all({
-          filters: [(peer) => {
-            return peer.tags.has(KEEP_ALIVE)
-          }]
-        })
-
-        await Promise.all(
-          keepAlivePeers.map(async peer => {
-            await this.openConnection(peer.id)
-              .catch(err => {
-                this.log.error(err)
-              })
-          })
-        )
-      })
-      .catch(err => {
-        this.log.error(err)
-      })
-
-    this.autoDial.afterStart()
-  }
-
   /**
    * Stops the Connection Manager
    */
   async stop (): Promise<void> {
-    this.dialQueue.stop()
-    this.autoDial.stop()
+    await stop(
+      this.reconnectQueue,
+      this.dialQueue
+    )
 
     // Close all connections we're tracking
     const tasks: Array<Promise<void>> = []
@@ -495,7 +457,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
   async openConnection (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], options: OpenConnectionOptions = {}): Promise<Connection> {
     if (!this.isStarted()) {
-      throw new CodeError('Not started', codes.ERR_NODE_NOT_STARTED)
+      throw new NotStartedError('Not started')
     }
 
     options.signal?.throwIfAborted()
@@ -505,10 +467,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.transient)
+        .find(conn => conn.limits == null)
 
       if (existingConnection != null) {
-        this.log('had an existing non-transient connection to %p', peerId)
+        this.log('had an existing non-limited connection to %p', peerId)
 
         options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
         return existingConnection