libp2p 0.45.0-752db6d6 → 0.45.0-e93d258d

package/src/address-manager/index.ts

@@ -1,13 +1,13 @@
-import type { Multiaddr } from '@multiformats/multiaddr'
-import { multiaddr } from '@multiformats/multiaddr'
+import { logger } from '@libp2p/logger'
 import { peerIdFromString } from '@libp2p/peer-id'
+import { multiaddr } from '@multiformats/multiaddr'
+import { debounce } from './utils.js'
+import type { Libp2pEvents } from '@libp2p/interface-libp2p'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import type { TransportManager } from '@libp2p/interface-transport'
 import type { PeerStore } from '@libp2p/interface-peer-store'
-import { logger } from '@libp2p/logger'
+import type { TransportManager } from '@libp2p/interface-transport'
 import type { EventEmitter } from '@libp2p/interfaces/dist/src/events'
-import type { Libp2pEvents } from '@libp2p/interface-libp2p'
-import { debounce } from './utils.js'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:address-manager')
 

package/src/autonat/index.ts

@@ -1,18 +1,10 @@
-import type { AddressManager } from '@libp2p/interface-address-manager'
-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 { PeerInfo } from '@libp2p/interface-peer-info'
-import type { PeerRouting } from '@libp2p/interface-peer-routing'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { TransportManager } from '@libp2p/interface-transport'
-import type { Startable } from '@libp2p/interfaces/startable'
+import { setMaxListeners } from 'events'
 import { logger } from '@libp2p/logger'
 import { peerIdFromBytes } from '@libp2p/peer-id'
 import { createEd25519PeerId } from '@libp2p/peer-id-factory'
 import { multiaddr, protocols } from '@multiformats/multiaddr'
 import { abortableDuplex } from 'abortable-iterator'
-import { setMaxListeners } from 'events'
+import { anySignal } from 'any-signal'
 import first from 'it-first'
 import * as lp from 'it-length-prefixed'
 import map from 'it-map'
@@ -25,7 +17,15 @@ import {
   PROTOCOL_NAME, PROTOCOL_PREFIX, PROTOCOL_VERSION, REFRESH_INTERVAL, STARTUP_DELAY, TIMEOUT
 } from './constants.js'
 import { Message } from './pb/index.js'
-import { anySignal } from 'any-signal'
+import type { AddressManager } from '@libp2p/interface-address-manager'
+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 { PeerInfo } from '@libp2p/interface-peer-info'
+import type { PeerRouting } from '@libp2p/interface-peer-routing'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import type { TransportManager } from '@libp2p/interface-transport'
+import type { Startable } from '@libp2p/interfaces/startable'
 
 const log = logger('libp2p:autonat')
 
@@ -452,7 +452,7 @@ class DefaultAutoNATService implements Startable {
             (source) => lp.encode(source),
             source,
             (source) => lp.decode(source),
-            async (stream) => await first(stream)
+            async (stream) => first(stream)
           )
           if (buf == null) {
             log('No response received from %s', connection.remotePeer)
@@ -497,7 +497,7 @@ class DefaultAutoNATService implements Startable {
 
       for await (const dialResponse of parallel(map(this.components.peerRouting.getClosestPeers(randomCid, {
         signal
-      }), (peer) => async () => await verifyAddress(peer)), {
+      }), (peer) => async () => verifyAddress(peer)), {
         concurrency: REQUIRED_SUCCESSFUL_DIALS
       })) {
         try {
@@ -565,7 +565,7 @@ class DefaultAutoNATService implements Startable {
   }
 }
 
-export function autoNATService (init: AutoNATServiceInit = {}): (components: AutoNATComponents) => {} {
+export function autoNATService (init: AutoNATServiceInit = {}): (components: AutoNATComponents) => unknown {
   return (components) => {
     return new DefaultAutoNATService(components, init)
   }

package/src/circuit-relay/index.ts

@@ -1,6 +1,6 @@
+import type { Limit } from './pb/index.js'
 import type { EventEmitter } from '@libp2p/interfaces/events'
 import type { PeerMap } from '@libp2p/peer-collections'
-import type { Limit } from './pb/index.js'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
 export interface RelayReservation {

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

@@ -1,14 +1,14 @@
+import { EventEmitter } from '@libp2p/interfaces/events'
 import { logger } from '@libp2p/logger'
+import pRetry from 'p-retry'
 import { codes } from '../../errors.js'
-import { namespaceToCid } from '../utils.js'
 import {
   DEFAULT_ADVERT_BOOT_DELAY,
   RELAY_RENDEZVOUS_NS
 } from '../constants.js'
-import type { Startable } from '@libp2p/interfaces/startable'
+import { namespaceToCid } from '../utils.js'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
-import { EventEmitter } from '@libp2p/interfaces/events'
-import pRetry from 'p-retry'
+import type { Startable } from '@libp2p/interfaces/startable'
 
 const log = logger('libp2p:circuit-relay:advert-service')
 

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

@@ -1,31 +1,31 @@
+import { setMaxListeners } from 'events'
+import { EventEmitter } from '@libp2p/interfaces/events'
 import { logger } from '@libp2p/logger'
-import { createLimitedRelay } from '../utils.js'
+import { peerIdFromBytes } from '@libp2p/peer-id'
+import { RecordEnvelope } from '@libp2p/peer-record'
+import { type Multiaddr, multiaddr } from '@multiformats/multiaddr'
+import { pbStream, type ProtobufStream } from 'it-pb-stream'
+import pDefer from 'p-defer'
 import {
   CIRCUIT_PROTO_CODE,
   DEFAULT_HOP_TIMEOUT,
   RELAY_SOURCE_TAG
   , RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC
 } from '../constants.js'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { Startable } from '@libp2p/interfaces/startable'
-import { ReservationStore, ReservationStoreInit } from './reservation-store.js'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import { AdvertService, AdvertServiceComponents, AdvertServiceInit } from './advert-service.js'
-import pDefer from 'p-defer'
-import { pbStream, ProtobufStream } from 'it-pb-stream'
-import { HopMessage, Reservation, Status, StopMessage } from '../pb/index.js'
-import { Multiaddr, multiaddr } from '@multiformats/multiaddr'
-import type { Connection, Stream } from '@libp2p/interface-connection'
-import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import { peerIdFromBytes } from '@libp2p/peer-id'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import { RecordEnvelope } from '@libp2p/peer-record'
+import { HopMessage, type Reservation, Status, StopMessage } from '../pb/index.js'
+import { createLimitedRelay } from '../utils.js'
+import { AdvertService, type AdvertServiceComponents, type AdvertServiceInit } from './advert-service.js'
+import { ReservationStore, type ReservationStoreInit } from './reservation-store.js'
 import { ReservationVoucherRecord } from './reservation-voucher.js'
+import type { CircuitRelayService, RelayReservation } from '../index.js'
 import type { AddressManager } from '@libp2p/interface-address-manager'
+import type { Connection, Stream } from '@libp2p/interface-connection'
+import type { ConnectionGater } from '@libp2p/interface-connection-gater'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { CircuitRelayService, RelayReservation } from '../index.js'
-import { EventEmitter } from '@libp2p/interfaces/events'
-import { setMaxListeners } from 'events'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import type { Startable } from '@libp2p/interfaces/startable'
 import type { PeerMap } from '@libp2p/peer-collections'
 
 const log = logger('libp2p:circuit-relay:server')

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

@@ -1,11 +1,11 @@
-import { Limit, Status } from '../pb/index.js'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Startable } from '@libp2p/interfaces/startable'
 import { PeerMap } from '@libp2p/peer-collections'
-import type { RecursivePartial } from '@libp2p/interfaces'
 import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT, DEFAULT_MAX_RESERVATION_CLEAR_INTERVAL, DEFAULT_MAX_RESERVATION_STORE_SIZE, DEFAULT_MAX_RESERVATION_TTL } from '../constants.js'
+import { type Limit, Status } from '../pb/index.js'
 import type { RelayReservation } from '../index.js'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { RecursivePartial } from '@libp2p/interfaces'
+import type { Startable } from '@libp2p/interfaces/startable'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 export type ReservationStatus = Status.OK | Status.PERMISSION_DENIED | Status.RESERVATION_REFUSED
 

package/src/circuit-relay/server/reservation-voucher.ts

@@ -1,6 +1,6 @@
+import { ReservationVoucher } from '../pb/index.js'
 import type { PeerId } from '@libp2p/interface-peer-id'
 import type { Record } from '@libp2p/interface-record'
-import { ReservationVoucher } from '../pb/index.js'
 
 export interface ReservationVoucherOptions {
   relay: PeerId

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

@@ -1,18 +1,18 @@
+import { EventEmitter } from '@libp2p/interfaces/events'
 import { logger } from '@libp2p/logger'
-import { namespaceToCid } from '../utils.js'
+import { createTopology } from '@libp2p/topology'
 import {
   RELAY_RENDEZVOUS_NS,
   RELAY_V2_HOP_CODEC
 } from '../constants.js'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import { EventEmitter } from '@libp2p/interfaces/events'
-import type { Startable } from '@libp2p/interfaces/startable'
+import { namespaceToCid } from '../utils.js'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { TransportManager } from '@libp2p/interface-transport'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { Registrar } from '@libp2p/interface-registrar'
-import { createTopology } from '@libp2p/topology'
+import type { TransportManager } from '@libp2p/interface-transport'
+import type { Startable } from '@libp2p/interfaces/startable'
 
 const log = logger('libp2p:circuit-relay:discover-relays')
 

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

@@ -1,30 +1,29 @@
-import { StopMessage, HopMessage, Status } from '../pb/index.js'
+import { symbol, type Upgrader, type Listener, type Transport, type CreateListenerOptions } from '@libp2p/interface-transport'
+import { CodeError } from '@libp2p/interfaces/errors'
 import { logger } from '@libp2p/logger'
+import { peerIdFromBytes, peerIdFromString } from '@libp2p/peer-id'
+import { streamToMaConnection } from '@libp2p/utils/stream-to-ma-conn'
 import * as mafmt from '@multiformats/mafmt'
 import { multiaddr } from '@multiformats/multiaddr'
+import { pbStream } from 'it-pb-stream'
 import { codes } from '../../errors.js'
-import { streamToMaConnection } from '@libp2p/utils/stream-to-ma-conn'
+import { CIRCUIT_PROTO_CODE, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../constants.js'
+import { StopMessage, HopMessage, Status } from '../pb/index.js'
+import { RelayDiscovery, type RelayDiscoveryComponents } from './discovery.js'
 import { createListener } from './listener.js'
-import { symbol, Upgrader } from '@libp2p/interface-transport'
-import { peerIdFromBytes, peerIdFromString } from '@libp2p/peer-id'
-import type { AbortOptions } from '@libp2p/interfaces'
-import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
-import type { Listener, Transport, CreateListenerOptions } from '@libp2p/interface-transport'
+import { type RelayStoreInit, ReservationStore } from './reservation-store.js'
+import type { AddressManager } from '@libp2p/interface-address-manager'
 import type { Connection, Stream } from '@libp2p/interface-connection'
 import type { ConnectionGater } from '@libp2p/interface-connection-gater'
-import type { PeerId } from '@libp2p/interface-peer-id'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { PeerStore } from '@libp2p/interface-peer-store'
 import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { AddressManager } from '@libp2p/interface-address-manager'
-import { pbStream } from 'it-pb-stream'
 import type { ContentRouting } from '@libp2p/interface-content-routing'
-import { CIRCUIT_PROTO_CODE, RELAY_V2_HOP_CODEC, RELAY_V2_STOP_CODEC } from '../constants.js'
-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'
+import type { PeerId } from '@libp2p/interface-peer-id'
+import type { PeerStore } from '@libp2p/interface-peer-store'
+import type { IncomingStreamData, Registrar } from '@libp2p/interface-registrar'
+import type { AbortOptions } from '@libp2p/interfaces'
+import type { EventEmitter } from '@libp2p/interfaces/events'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:circuit-relay:transport')
 
@@ -142,13 +141,9 @@ class CircuitRelayTransport implements Transport {
     this.started = false
   }
 
-  get [symbol] (): true {
-    return true
-  }
+  readonly [symbol] = true
 
-  get [Symbol.toStringTag] (): 'libp2p/circuit-relay-v2' {
-    return 'libp2p/circuit-relay-v2'
-  }
+  readonly [Symbol.toStringTag] = 'libp2p/circuit-relay-v2'
 
   /**
    * Dial a peer over a relay

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

@@ -1,15 +1,15 @@
+import { CodeError } from '@libp2p/interfaces/errors'
 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'
-import { multiaddr } from '@multiformats/multiaddr'
-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 { 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 { CodeError } from '@libp2p/interfaces/errors'
+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 { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:circuit-relay:transport:listener')
 

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

@@ -1,20 +1,20 @@
-import type { PeerId } from '@libp2p/interface-peer-id'
+import { EventEmitter } from '@libp2p/interfaces/events'
+import { logger } from '@libp2p/logger'
 import { PeerMap } from '@libp2p/peer-collections'
+import { multiaddr } from '@multiformats/multiaddr'
+import { pbStream } from 'it-pb-stream'
 import PQueue from 'p-queue'
 import { DEFAULT_RESERVATION_CONCURRENCY, RELAY_TAG, RELAY_V2_HOP_CODEC } from '../constants.js'
-import { logger } from '@libp2p/logger'
-import { pbStream } from 'it-pb-stream'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { Connection } from '@libp2p/interface-connection'
-import type { Reservation } from '../pb/index.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 { 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')
 

package/src/circuit-relay/utils.ts

@@ -1,13 +1,13 @@
+import { logger } from '@libp2p/logger'
+import { abortableSource } from 'abortable-iterator'
+import { anySignal } from 'any-signal'
 import { CID } from 'multiformats/cid'
 import { sha256 } from 'multiformats/hashes/sha2'
-import type { Source } from 'it-stream-types'
-import type { Uint8ArrayList } from 'uint8arraylist'
+import { DEFAULT_DATA_LIMIT, DEFAULT_DURATION_LIMIT } from './constants.js'
 import type { Limit } from './pb/index.js'
-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 type { Source } from 'it-stream-types'
+import type { Uint8ArrayList } from 'uint8arraylist'
 
 const log = logger('libp2p:circuit-relay:utils')
 

package/src/components.ts

@@ -1,19 +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 { AddressManager } from '@libp2p/interface-address-manager'
-import { isStartable, Startable } from '@libp2p/interfaces/startable'
+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 { Datastore } from 'interface-datastore'
-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'
+import type { Datastore } from 'interface-datastore'
 
 export interface Components extends Record<string, any>, Startable {
   peerId: PeerId

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

@@ -1,6 +1,6 @@
+import isPrivate from 'private-ip'
 import type { ConnectionGater } from '@libp2p/interface-connection-gater'
 import type { Multiaddr } from '@multiformats/multiaddr'
-import isPrivate from 'private-ip'
 
 /**
  * Returns a connection gater that disallows dialling private addresses by

package/src/config.ts

@@ -1,13 +1,13 @@
-import mergeOptions from 'merge-options'
-import { dnsaddrResolver } from '@multiformats/multiaddr/resolvers'
-import { publicAddressesFirst } from '@libp2p/utils/address-sort'
 import { FaultTolerance } from '@libp2p/interface-transport'
-import type { Multiaddr } from '@multiformats/multiaddr'
-import type { Libp2pInit } from './index.js'
-import { codes, messages } from './errors.js'
 import { CodeError } from '@libp2p/interfaces/errors'
-import type { RecursivePartial } from '@libp2p/interfaces'
+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 { Multiaddr } from '@multiformats/multiaddr'
 
 const DefaultConfig: Partial<Libp2pInit> = {
   addresses: {
@@ -27,17 +27,13 @@ const DefaultConfig: Partial<Libp2pInit> = {
   }
 }
 
-export function validateConfig <T extends ServiceMap = {}> (opts: RecursivePartial<Libp2pInit<T>>): Libp2pInit<T> {
+export function validateConfig <T extends ServiceMap = Record<string, unknown>> (opts: RecursivePartial<Libp2pInit<T>>): Libp2pInit<T> {
   const resultingOptions: Libp2pInit<T> = mergeOptions(DefaultConfig, opts)
 
   if (resultingOptions.transports == null || resultingOptions.transports.length < 1) {
     throw new CodeError(messages.ERR_TRANSPORTS_REQUIRED, codes.ERR_TRANSPORTS_REQUIRED)
   }
 
-  if (resultingOptions.connectionEncryption == null || resultingOptions.connectionEncryption.length === 0) {
-    throw new CodeError(messages.CONN_ENCRYPTION_REQUIRED, codes.CONN_ENCRYPTION_REQUIRED)
-  }
-
   if (resultingOptions.connectionProtector === null && globalThis.process?.env?.LIBP2P_FORCE_PNET != null) { // eslint-disable-line no-undef
     throw new CodeError(messages.ERR_PROTECTOR_REQUIRED, codes.ERR_PROTECTOR_REQUIRED)
   }

package/src/connection/index.ts

@@ -1,11 +1,11 @@
-import type { Multiaddr } from '@multiformats/multiaddr'
-import { CodeError } from '@libp2p/interfaces/errors'
-import { OPEN, CLOSING, CLOSED } from '@libp2p/interface-connection/status'
 import { symbol } from '@libp2p/interface-connection'
+import { OPEN, CLOSING, CLOSED } from '@libp2p/interface-connection/status'
+import { CodeError } from '@libp2p/interfaces/errors'
+import { logger } from '@libp2p/logger'
 import type { Connection, ConnectionStat, Stream } from '@libp2p/interface-connection'
 import type { PeerId } from '@libp2p/interface-peer-id'
-import { logger } from '@libp2p/logger'
 import type { AbortOptions } from '@libp2p/interfaces'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:connection')
 
@@ -87,13 +87,9 @@ export class ConnectionImpl implements Connection {
     this._closing = false
   }
 
-  get [Symbol.toStringTag] (): 'Connection' {
-    return 'Connection'
-  }
+  readonly [Symbol.toStringTag] = 'Connection'
 
-  get [symbol] (): true {
-    return true
-  }
+  readonly [symbol] = true
 
   /**
    * Get all the streams of the muxer

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

@@ -1,12 +1,12 @@
 import { logger } from '@libp2p/logger'
-import type { PeerStore } from '@libp2p/interface-peer-store'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
 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 { Startable } from '@libp2p/interfaces/startable'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+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')
 
@@ -112,7 +112,7 @@ export class AutoDial implements Startable {
 
     // Already has enough connections
     if (numConnections >= this.minConnections) {
-      log('have enough connections %d/%d', numConnections, this.minConnections)
+      log.trace('have enough connections %d/%d', numConnections, this.minConnections)
       return
     }
 

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

@@ -1,11 +1,11 @@
 import { logger } from '@libp2p/logger'
-import type { ConnectionManager } from '@libp2p/interface-connection-manager'
-import type { PeerStore } from '@libp2p/interface-peer-store'
 import { PeerMap } from '@libp2p/peer-collections'
-import type { Multiaddr } from '@multiformats/multiaddr'
 import { MAX_CONNECTIONS } from './constants.js'
-import type { EventEmitter } from '@libp2p/interfaces/events'
+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 { Multiaddr } from '@multiformats/multiaddr'
 
 const log = logger('libp2p:connection-manager:connection-pruner')
 

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

@@ -1,29 +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 { 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 { 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 { getPeerAddress } from '../get-peer.js'
 import type { Address, PeerStore } from '@libp2p/interface-peer-store'
-import type { Metric, Metrics } from '@libp2p/interface-metrics'
 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 { ClearableSignal, anySignal } from 'any-signal'
-import type { AddressSorter } from '@libp2p/interface-libp2p'
-import { setMaxListeners } from 'events'
+import type { AbortOptions } from '@libp2p/interfaces'
 
 const log = logger('libp2p:connection-manager:dial-queue')
 
@@ -214,7 +214,7 @@ export class DialQueue {
     if (existingDial != null) {
       log('joining existing dial target for %p', peerId)
       signal.clear()
-      return await existingDial.promise
+      return existingDial.promise
     }
 
     log('creating dial target for', addrsToDial.map(({ multiaddr }) => multiaddr.toString()))
@@ -252,7 +252,7 @@ export class DialQueue {
     // let other dials join this one
     this.pendingDials.push(pendingDial)
 
-    return await pendingDial.promise
+    return pendingDial.promise
   }
 
   private createDialAbortControllers (userSignal?: AbortSignal): ClearableSignal {
@@ -272,6 +272,7 @@ export class DialQueue {
     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) {
@@ -319,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()
@@ -491,7 +492,7 @@ export class DialQueue {
           signal.clear()
         })
 
-        return await deferred.promise
+        return deferred.promise
       }))
 
       // dial succeeded or failed