libp2p 0.45.9 → 0.46.0

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

@@ -1,14 +1,14 @@
-import { CodeError } from '@libp2p/interfaces/errors'
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { CodeError } from '@libp2p/interface/errors'
+import { EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { PeerMap } from '@libp2p/peer-collections'
 import { peerIdFromString } from '@libp2p/peer-id'
 import { multiaddr } from '@multiformats/multiaddr'
 import type { ReservationStore } from './reservation-store.js'
-import type { Connection } from '@libp2p/interface-connection'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Listener, ListenerEvents } from '@libp2p/interface-transport'
+import type { Connection } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { Listener, ListenerEvents } from '@libp2p/interface/transport'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:circuit-relay:transport:listener')
@@ -37,7 +37,7 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
   }
 
   async listen (addr: Multiaddr): Promise<void> {
-    log('listen on %s', addr)
+    log('listen on %a', addr)
 
     const relayPeerStr = addr.getPeerId()
     let relayConn: Connection | undefined
@@ -95,6 +95,8 @@ class CircuitRelayTransportListener extends EventEmitter<ListenerEvents> impleme
   #removeRelayPeer (peerId: PeerId): void {
     const had = this.listeningAddrs.has(peerId)
 
+    log('relay peer removed %p - had reservation', peerId, had)
+
     this.listeningAddrs.delete(peerId)
 
     if (had) {

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

@@ -1,20 +1,20 @@
-import { EventEmitter } from '@libp2p/interfaces/events'
+import { EventEmitter } from '@libp2p/interface/events'
 import { logger } from '@libp2p/logger'
 import { PeerMap } from '@libp2p/peer-collections'
 import { multiaddr } from '@multiformats/multiaddr'
-import { pbStream } from 'it-pb-stream'
+import { pbStream } from 'it-protobuf-stream'
 import { PeerJobQueue } from '../../utils/peer-job-queue.js'
 import { DEFAULT_RESERVATION_CONCURRENCY, RELAY_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
 import { HopMessage, Status } from '../pb/index.js'
 import { getExpirationMilliseconds } from '../utils.js'
 import type { Reservation } from '../pb/index.js'
-import type { Connection } from '@libp2p/interface-connection'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-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 { Startable } from '@libp2p/interfaces/startable'
+import type { Libp2pEvents, AbortOptions } from '@libp2p/interface'
+import type { Connection } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Startable } from '@libp2p/interface/startable'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 
 const log = logger('libp2p:circuit-relay:transport:reservation-store')
 
@@ -55,6 +55,12 @@ export interface RelayStoreInit {
    * Limit the number of potential relays we will dial (default: 100)
    */
   maxReservationQueueLength?: number
+
+  /**
+   * When creating a reservation it must complete within this number of ms
+   * (default: 5000)
+   */
+  reservationCompletionTimeout?: number
 }
 
 export type RelayType = 'discovered' | 'configured'
@@ -80,6 +86,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
   private readonly reservations: PeerMap<RelayEntry>
   private readonly maxDiscoveredRelays: number
   private readonly maxReservationQueueLength: number
+  private readonly reservationCompletionTimeout: number
   private started: boolean
 
   constructor (components: RelayStoreComponents, init?: RelayStoreInit) {
@@ -93,6 +100,7 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     this.reservations = new PeerMap()
     this.maxDiscoveredRelays = init?.discoverRelays ?? 0
     this.maxReservationQueueLength = init?.maxReservationQueueLength ?? 100
+    this.reservationCompletionTimeout = init?.reservationCompletionTimeout ?? 10000
     this.started = false
 
     // ensure we don't listen on multiple relays simultaneously
@@ -117,12 +125,12 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
   }
 
   async stop (): Promise<void> {
+    this.reserveQueue.clear()
     this.reservations.forEach(({ timeout }) => {
       clearTimeout(timeout)
     })
     this.reservations.clear()
-
-    this.started = true
+    this.started = false
   }
 
   /**
@@ -175,14 +183,20 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
           return
         }
 
-        const connection = await this.connectionManager.openConnection(peerId)
+        const signal = AbortSignal.timeout(this.reservationCompletionTimeout)
+
+        const connection = await this.connectionManager.openConnection(peerId, {
+          signal
+        })
 
         if (connection.remoteAddr.protoNames().includes('p2p-circuit')) {
           log('not creating reservation over relayed connection')
           return
         }
 
-        const reservation = await this.#createReservation(connection)
+        const reservation = await this.#createReservation(connection, {
+          signal
+        })
 
         log('created reservation on relay peer %p', peerId)
 
@@ -220,6 +234,13 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
       } catch (err) {
         log.error('could not reserve slot on %p', peerId, err)
 
+        // cancel the renewal timeout if it's been set
+        const reservation = this.reservations.get(peerId)
+
+        if (reservation != null) {
+          clearTimeout(reservation.timeout)
+        }
+
         // if listening failed, remove the reservation
         this.reservations.delete(peerId)
       }
@@ -236,22 +257,24 @@ export class ReservationStore extends EventEmitter<ReservationStoreEvents> imple
     return this.reservations.get(peerId)?.reservation
   }
 
-  async #createReservation (connection: Connection): Promise<Reservation> {
-    log('requesting reservation from %s', connection.remotePeer)
+  async #createReservation (connection: Connection, options: AbortOptions): Promise<Reservation> {
+    options.signal?.throwIfAborted()
+
+    log('requesting reservation from %p', connection.remotePeer)
     const stream = await connection.newStream(RELAY_V2_HOP_CODEC)
     const pbstr = pbStream(stream)
     const hopstr = pbstr.pb(HopMessage)
-    hopstr.write({ type: HopMessage.Type.RESERVE })
+    await hopstr.write({ type: HopMessage.Type.RESERVE }, options)
 
     let response: HopMessage
 
     try {
-      response = await hopstr.read()
+      response = await hopstr.read(options)
     } catch (err: any) {
       log.error('error parsing reserve message response from %p because', connection.remotePeer, err)
       throw err
     } finally {
-      stream.close()
+      await stream.close()
     }
 
     if (response.status === Status.OK && (response.reservation != null)) {

package/src/circuit-relay/utils.ts

@@ -5,7 +5,7 @@ import { CID } from 'multiformats/cid'
 import { sha256 } from 'multiformats/hashes/sha2'
 import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT } from './constants.js'
 import type { Limit } from './pb/index.js'
-import type { Stream } from '@libp2p/interface-connection'
+import type { Stream } from '@libp2p/interface/connection'
 import type { Source } from 'it-stream-types'
 import type { Uint8ArrayList } from 'uint8arraylist'
 

package/src/components.ts

@@ -1,18 +1,19 @@
-import { CodeError } from '@libp2p/interfaces/errors'
-import { isStartable, type Startable } from '@libp2p/interfaces/startable'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import type { ConnectionProtector } from '@libp2p/interface-connection'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { ContentRouting } from '@libp2p/interface-content-routing'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import type { Metrics } from '@libp2p/interface-metrics'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerRouting } from '@libp2p/interface-peer-routing'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { Registrar } from '@libp2p/interface-registrar'
-import type { TransportManager, Upgrader } from '@libp2p/interface-transport'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+import { CodeError } from '@libp2p/interface/errors'
+import { isStartable, type Startable } from '@libp2p/interface/startable'
+import type { Libp2pEvents } from '@libp2p/interface'
+import type { ConnectionProtector } from '@libp2p/interface/connection'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+import type { ContentRouting } from '@libp2p/interface/content-routing'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { Metrics } from '@libp2p/interface/metrics'
+import type { PeerId } from '@libp2p/interface/peer-id'
+import type { PeerRouting } from '@libp2p/interface/peer-routing'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Upgrader } from '@libp2p/interface/transport'
+import type { AddressManager } from '@libp2p/interface-internal/address-manager'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
+import type { Registrar } from '@libp2p/interface-internal/registrar'
+import type { TransportManager } from '@libp2p/interface-internal/transport-manager'
 import type { Datastore } from 'interface-datastore'
 
 export interface Components extends Record<string, any>, Startable {

package/src/config/connection-gater.browser.ts

@@ -1,5 +1,5 @@
 import isPrivate from 'private-ip'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 /**

package/src/config/connection-gater.ts

@@ -1,4 +1,4 @@
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
 
 /**
  * Returns a default connection gater implementation that allows everything

package/src/config.ts

@@ -1,12 +1,11 @@
-import { FaultTolerance } from '@libp2p/interface-transport'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { CodeError } from '@libp2p/interface/errors'
+import { FaultTolerance } from '@libp2p/interface/transport'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
 import mergeOptions from 'merge-options'
 import { codes, messages } from './errors.js'
 import type { Libp2pInit } from './index.js'
-import type { ServiceMap } from '@libp2p/interface-libp2p'
-import type { RecursivePartial } from '@libp2p/interfaces'
+import type { ServiceMap, RecursivePartial } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const DefaultConfig: Partial<Libp2pInit> = {

package/src/connection/index.ts

@@ -1,21 +1,29 @@
-import { symbol } from '@libp2p/interface-connection'
-import { OPEN, CLOSING, CLOSED } from '@libp2p/interface-connection/status'
-import { CodeError } from '@libp2p/interfaces/errors'
+import { setMaxListeners } from 'events'
+import { symbol } from '@libp2p/interface/connection'
+import { CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
-import type { Connection, ConnectionStat, Stream } from '@libp2p/interface-connection'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { AbortOptions } from '@libp2p/interfaces'
+import type { AbortOptions } from '@libp2p/interface'
+import type { Direction, Connection, Stream, ConnectionTimeline, ConnectionStatus, NewStreamOptions } from '@libp2p/interface/connection'
+import type { PeerId } from '@libp2p/interface/peer-id'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:connection')
 
+const CLOSE_TIMEOUT = 500
+
 interface ConnectionInit {
   remoteAddr: Multiaddr
   remotePeer: PeerId
   newStream: (protocols: string[], options?: AbortOptions) => Promise<Stream>
-  close: () => Promise<void>
+  close: (options?: AbortOptions) => Promise<void>
+  abort: (err: Error) => void
   getStreams: () => Stream[]
-  stat: ConnectionStat
+  status: ConnectionStatus
+  direction: Direction
+  timeline: ConnectionTimeline
+  multiplexer?: string
+  encryption?: string
+  transient?: boolean
 }
 
 /**
@@ -38,10 +46,12 @@ export class ConnectionImpl implements Connection {
    */
   public readonly remotePeer: PeerId
 
-  /**
-   * Connection metadata
-   */
-  public readonly stat: ConnectionStat
+  public direction: Direction
+  public timeline: ConnectionTimeline
+  public multiplexer?: string
+  public encryption?: string
+  public status: ConnectionStatus
+  public transient: boolean
 
   /**
    * User provided tags
@@ -52,39 +62,42 @@ export class ConnectionImpl implements Connection {
   /**
    * Reference to the new stream function of the multiplexer
    */
-  private readonly _newStream: (protocols: string[], options?: AbortOptions) => Promise<Stream>
+  private readonly _newStream: (protocols: string[], options?: NewStreamOptions) => Promise<Stream>
 
   /**
    * Reference to the close function of the raw connection
    */
-  private readonly _close: () => Promise<void>
+  private readonly _close: (options?: AbortOptions) => Promise<void>
+
+  private readonly _abort: (err: Error) => void
 
   /**
    * Reference to the getStreams function of the muxer
    */
   private readonly _getStreams: () => Stream[]
 
-  private _closing: boolean
-
   /**
    * An implementation of the js-libp2p connection.
    * Any libp2p transport should use an upgrader to return this connection.
    */
   constructor (init: ConnectionInit) {
-    const { remoteAddr, remotePeer, newStream, close, getStreams, stat } = init
+    const { remoteAddr, remotePeer, newStream, close, abort, getStreams } = init
 
     this.id = `${(parseInt(String(Math.random() * 1e9))).toString(36)}${Date.now()}`
     this.remoteAddr = remoteAddr
     this.remotePeer = remotePeer
-    this.stat = {
-      ...stat,
-      status: OPEN
-    }
+    this.direction = init.direction
+    this.status = 'open'
+    this.timeline = init.timeline
+    this.multiplexer = init.multiplexer
+    this.encryption = init.encryption
+    this.transient = init.transient ?? false
+
     this._newStream = newStream
     this._close = close
+    this._abort = abort
     this._getStreams = getStreams
     this.tags = []
-    this._closing = false
   }
 
   readonly [Symbol.toStringTag] = 'Connection'
@@ -101,12 +114,12 @@ export class ConnectionImpl implements Connection {
   /**
    * Create a new stream from this connection
    */
-  async newStream (protocols: string | string[], options?: AbortOptions): Promise<Stream> {
-    if (this.stat.status === CLOSING) {
+  async newStream (protocols: string | string[], options?: NewStreamOptions): Promise<Stream> {
+    if (this.status === 'closing') {
       throw new CodeError('the connection is being closed', 'ERR_CONNECTION_BEING_CLOSED')
     }
 
-    if (this.stat.status === CLOSED) {
+    if (this.status === 'closed') {
       throw new CodeError('the connection is closed', 'ERR_CONNECTION_CLOSED')
     }
 
@@ -114,9 +127,13 @@ export class ConnectionImpl implements Connection {
       protocols = [protocols]
     }
 
+    if (this.transient && options?.runOnTransientConnection !== true) {
+      throw new CodeError('Cannot open protocol stream on transient connection', 'ERR_TRANSIENT_CONNECTION')
+    }
+
     const stream = await this._newStream(protocols, options)
 
-    stream.stat.direction = 'outbound'
+    stream.direction = 'outbound'
 
     return stream
   }
@@ -125,7 +142,7 @@ export class ConnectionImpl implements Connection {
    * Add a stream when it is opened to the registry
    */
   addStream (stream: Stream): void {
-    stream.stat.direction = 'inbound'
+    stream.direction = 'inbound'
   }
 
   /**
@@ -138,27 +155,52 @@ export class ConnectionImpl implements Connection {
   /**
    * Close the connection
    */
-  async close (): Promise<void> {
-    if (this.stat.status === CLOSED || this._closing) {
+  async close (options: AbortOptions = {}): Promise<void> {
+    if (this.status === 'closed' || this.status === 'closing') {
       return
     }
 
-    this.stat.status = CLOSING
+    log('closing connection to %a', this.remoteAddr)
+
+    this.status = 'closing'
+
+    options.signal = options?.signal ?? AbortSignal.timeout(CLOSE_TIMEOUT)
+
+    try {
+      // fails on node < 15.4
+      setMaxListeners?.(Infinity, options.signal)
+    } catch { }
 
-    // close all streams - this can throw if we're not multiplexed
     try {
-      this.streams.forEach(s => { s.close() })
-    } catch (err) {
-      log.error(err)
+      // close all streams gracefully - this can throw if we're not multiplexed
+      await Promise.all(
+        this.streams.map(async s => s.close(options))
+      )
+
+      // Close raw connection
+      await this._close(options)
+
+      this.timeline.close = Date.now()
+      this.status = 'closed'
+    } catch (err: any) {
+      log.error('error encountered during graceful close of connection to %a', this.remoteAddr, err)
+      this.abort(err)
     }
+  }
+
+  abort (err: Error): void {
+    log.error('aborting connection to %a due to error', this.remoteAddr, err)
+
+    this.status = 'closing'
+    this.streams.forEach(s => { s.abort(err) })
+
+    log.error('all streams aborted', this.streams.length)
 
-    // Close raw connection
-    this._closing = true
-    await this._close()
-    this._closing = false
+    // Abort raw connection
+    this._abort(err)
 
-    this.stat.timeline.close = Date.now()
-    this.stat.status = CLOSED
+    this.timeline.close = Date.now()
+    this.status = 'closed'
   }
 }
 

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

@@ -2,11 +2,11 @@ import { logger } from '@libp2p/logger'
 import { PeerMap, PeerSet } from '@libp2p/peer-collections'
 import { PeerJobQueue } from '../utils/peer-job-queue.js'
 import { AUTO_DIAL_CONCURRENCY, AUTO_DIAL_INTERVAL, AUTO_DIAL_MAX_QUEUE_LENGTH, 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'
+import type { Libp2pEvents } from '@libp2p/interface'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { Startable } from '@libp2p/interface/startable'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 
 const log = logger('libp2p:connection-manager:auto-dial')
 
@@ -113,7 +113,9 @@ export class AutoDial implements Startable {
 
     // Already has enough connections
     if (numConnections >= this.minConnections) {
-      log.trace('have enough connections %d/%d', numConnections, this.minConnections)
+      if (this.minConnections > 0) {
+        log.trace('have enough connections %d/%d', numConnections, this.minConnections)
+      }
       return
     }
 

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

@@ -1,10 +1,10 @@
 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 type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Libp2pEvents } from '@libp2p/interface'
+import type { EventEmitter } from '@libp2p/interface/events'
+import type { PeerStore } from '@libp2p/interface/peer-store'
+import type { ConnectionManager } from '@libp2p/interface-internal/connection-manager'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:connection-manager:connection-pruner')
@@ -106,8 +106,8 @@ export class ConnectionPruner {
       }
 
       // if the peers have an equal tag value then we want to close short-lived connections first
-      const connectionALifespan = a.stat.timeline.open
-      const connectionBLifespan = b.stat.timeline.open
+      const connectionALifespan = a.timeline.open
+      const connectionBLifespan = b.timeline.open
 
       if (connectionALifespan < connectionBLifespan) {
         return 1

package/src/connection-manager/constants.ts

@@ -1,4 +1,3 @@
-
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#dialTimeout
  */

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

@@ -1,5 +1,5 @@
 import { setMaxListeners } from 'events'
-import { AbortError, CodeError } from '@libp2p/interfaces/errors'
+import { AbortError, CodeError } from '@libp2p/interface/errors'
 import { logger } from '@libp2p/logger'
 import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { type Multiaddr, type Resolver, resolvers } from '@multiformats/multiaddr'
@@ -16,27 +16,16 @@ import {
   MAX_PEER_ADDRS_TO_DIAL
 } from './constants.js'
 import { combineSignals, resolveMultiaddrs } from './utils.js'
-import type { Connection } from '@libp2p/interface-connection'
-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 { AbortOptions } from '@libp2p/interfaces'
+import type { AddressSorter, AbortOptions, PendingDial } from '@libp2p/interface'
+import type { Connection } from '@libp2p/interface/connection'
+import type { ConnectionGater } from '@libp2p/interface/connection-gater'
+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-internal/transport-manager'
 
 const log = logger('libp2p:connection-manager:dial-queue')
 
-export type PendingDialStatus = 'queued' | 'active' | 'error' | 'success'
-
-export interface PendingDial {
-  id: string
-  status: PendingDialStatus
-  peerId?: PeerId
-  multiaddrs: Multiaddr[]
-  promise: Promise<Connection>
-}
-
 export interface PendingDialTarget {
   resolve: (value: any) => void
   reject: (err: Error) => void
@@ -46,6 +35,10 @@ export interface DialOptions extends AbortOptions {
   priority?: number
 }
 
+interface PendingDialInternal extends PendingDial {
+  promise: Promise<Connection>
+}
+
 interface DialerInit {
   addressSorter?: AddressSorter
   maxParallelDials?: number
@@ -75,7 +68,7 @@ interface DialQueueComponents {
 }
 
 export class DialQueue {
-  public pendingDials: PendingDial[]
+  public pendingDials: PendingDialInternal[]
   public queue: PQueue
   private readonly peerId: PeerId
   private readonly peerStore: PeerStore
@@ -219,7 +212,7 @@ export class DialQueue {
 
     log('creating dial target for', addrsToDial.map(({ multiaddr }) => multiaddr.toString()))
     // @ts-expect-error .promise property is set below
-    const pendingDial: PendingDial = {
+    const pendingDial: PendingDialInternal = {
       id: randomId(),
       status: 'queued',
       peerId,
@@ -395,7 +388,7 @@ export class DialQueue {
     return sortedGatedAddrs
   }
 
-  private async performDial (pendingDial: PendingDial, options: DialOptions = {}): Promise<Connection> {
+  private async performDial (pendingDial: PendingDialInternal, options: DialOptions = {}): Promise<Connection> {
     const dialAbortControllers: Array<(AbortController | undefined)> = pendingDial.multiaddrs.map(() => new AbortController())
 
     try {
@@ -419,13 +412,13 @@ export class DialQueue {
         // let any signal abort the dial
         const signal = combineSignals(controller.signal, options.signal)
         signal.addEventListener('abort', () => {
-          log('dial to %s aborted', addr)
+          log('dial to %a aborted', addr)
         })
         const deferred = pDefer<Connection>()
 
         await peerDialQueue.add(async () => {
           if (signal.aborted) {
-            log('dial to %s was aborted before reaching the head of the peer dial queue', addr)
+            log('dial to %a was aborted before reaching the head of the peer dial queue', addr)
             deferred.reject(new AbortError())
             return
           }
@@ -434,7 +427,7 @@ export class DialQueue {
           await this.queue.add(async () => {
             try {
               if (signal.aborted) {
-                log('dial to %s was aborted before reaching the head of the dial queue', addr)
+                log('dial to %a was aborted before reaching the head of the dial queue', addr)
                 deferred.reject(new AbortError())
                 return
               }
@@ -469,13 +462,13 @@ export class DialQueue {
                 }
               })
 
-              log('dial to %s succeeded', addr)
+              log('dial to %a succeeded', addr)
 
               // resolve the connection promise
               deferred.resolve(conn)
             } catch (err: any) {
               // something only went wrong if our signal was not aborted
-              log.error('error during dial of %s', addr, err)
+              log.error('error during dial of %a', addr, err)
               deferred.reject(err)
             }
           }, {