libp2p 0.45.0 → 0.45.1-3c925ffa

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')
 
@@ -110,7 +110,7 @@ class DefaultAutoNATService implements Startable {
     await this.components.registrar.handle(this.protocol, (data) => {
       void this.handleIncomingAutonatStream(data)
         .catch(err => {
-          log.error(err)
+          log.error('error handling incoming autonat stream', err)
         })
     }, {
       maxInboundStreams: this.maxInboundStreams,
@@ -156,7 +156,7 @@ class DefaultAutoNATService implements Startable {
           const buf = await first(stream)
 
           if (buf == null) {
-            log('No message received')
+            log('no message received')
             yield Message.encode({
               type: Message.MessageType.DIAL_RESPONSE,
               dialResponse: {
@@ -173,7 +173,7 @@ class DefaultAutoNATService implements Startable {
           try {
             request = Message.decode(buf)
           } catch (err) {
-            log.error('Could not decode message', err)
+            log.error('could not decode message', err)
 
             yield Message.encode({
               type: Message.MessageType.DIAL_RESPONSE,
@@ -189,7 +189,7 @@ class DefaultAutoNATService implements Startable {
           const dialRequest = request.dial
 
           if (dialRequest == null) {
-            log.error('Dial was missing from message')
+            log.error('dial was missing from message')
 
             yield Message.encode({
               type: Message.MessageType.DIAL_RESPONSE,
@@ -222,7 +222,7 @@ class DefaultAutoNATService implements Startable {
           try {
             peerId = peerIdFromBytes(peer.id)
           } catch (err) {
-            log.error('Invalid PeerId', err)
+            log.error('invalid PeerId', err)
 
             yield Message.encode({
               type: Message.MessageType.DIAL_RESPONSE,
@@ -235,11 +235,11 @@ class DefaultAutoNATService implements Startable {
             return
           }
 
-          log('Incoming request from %p', peerId)
+          log('incoming request from %p', peerId)
 
           // reject any dial requests that arrive via relays
           if (!data.connection.remotePeer.equals(peerId)) {
-            log('Target peer %p did not equal sending peer %p', peerId, data.connection.remotePeer)
+            log('target peer %p did not equal sending peer %p', peerId, data.connection.remotePeer)
 
             yield Message.encode({
               type: Message.MessageType.DIAL_RESPONSE,
@@ -258,7 +258,7 @@ class DefaultAutoNATService implements Startable {
             .filter(ma => {
               const isFromSameHost = ma.toOptions().host === data.connection.remoteAddr.toOptions().host
 
-              log.trace('Request to dial %s was sent from %s is same host %s', ma, data.connection.remoteAddr, isFromSameHost)
+              log.trace('request to dial %s was sent from %s is same host %s', ma, data.connection.remoteAddr, isFromSameHost)
               // skip any Multiaddrs where the target node's IP does not match the sending node's IP
               return isFromSameHost
             })
@@ -266,7 +266,7 @@ class DefaultAutoNATService implements Startable {
               const host = ma.toOptions().host
               const isPublicIp = !(isPrivateIp(host) ?? false)
 
-              log.trace('Host %s was public %s', host, isPublicIp)
+              log.trace('host %s was public %s', host, isPublicIp)
               // don't try to dial private addresses
               return isPublicIp
             })
@@ -274,14 +274,14 @@ class DefaultAutoNATService implements Startable {
               const host = ma.toOptions().host
               const isNotOurHost = !ourHosts.includes(host)
 
-              log.trace('Host %s was not our host %s', host, isNotOurHost)
+              log.trace('host %s was not our host %s', host, isNotOurHost)
               // don't try to dial nodes on the same host as us
               return isNotOurHost
             })
             .filter(ma => {
               const isSupportedTransport = Boolean(self.components.transportManager.transportForMultiaddr(ma))
 
-              log.trace('Transport for %s is supported %s', ma, isSupportedTransport)
+              log.trace('transport for %s is supported %s', ma, isSupportedTransport)
               // skip any Multiaddrs that have transports we do not support
               return isSupportedTransport
             })
@@ -296,7 +296,7 @@ class DefaultAutoNATService implements Startable {
 
           // make sure we have something to dial
           if (multiaddrs.length === 0) {
-            log('No valid multiaddrs for %p in message', peerId)
+            log('no valid multiaddrs for %p in message', peerId)
 
             yield Message.encode({
               type: Message.MessageType.DIAL_RESPONSE,
@@ -309,7 +309,7 @@ class DefaultAutoNATService implements Startable {
             return
           }
 
-          log('Dial multiaddrs %s for peer %p', multiaddrs.map(ma => ma.toString()).join(', '), peerId)
+          log('dial multiaddrs %s for peer %p', multiaddrs.map(ma => ma.toString()).join(', '), peerId)
 
           let errorMessage = ''
           let lastMultiaddr = multiaddrs[0]
@@ -324,7 +324,7 @@ class DefaultAutoNATService implements Startable {
               })
 
               if (!connection.remoteAddr.equals(multiaddr)) {
-                log.error('Tried to dial %s but dialed %s', multiaddr, connection.remoteAddr)
+                log.error('tried to dial %s but dialed %s', multiaddr, connection.remoteAddr)
                 throw new Error('Unexpected remote address')
               }
 
@@ -340,7 +340,7 @@ class DefaultAutoNATService implements Startable {
 
               return
             } catch (err: any) {
-              log('Could not dial %p', peerId, err)
+              log('could not dial %p', peerId, err)
               errorMessage = err.message
             } finally {
               if (connection != null) {
@@ -364,7 +364,7 @@ class DefaultAutoNATService implements Startable {
         data.stream
       )
     } catch (err) {
-      log.error(err)
+      log.error('error handling incoming autonat stream', err)
     } finally {
       signal.clear()
     }
@@ -373,7 +373,7 @@ class DefaultAutoNATService implements Startable {
   _verifyExternalAddresses (): void {
     void this.verifyExternalAddresses()
       .catch(err => {
-        log.error(err)
+        log.error('error verifying external address', err)
       })
   }
 
@@ -398,7 +398,7 @@ class DefaultAutoNATService implements Startable {
       })
 
     if (multiaddrs.length === 0) {
-      log('No public addresses found, not requesting verification')
+      log('no public addresses found, not requesting verification')
       this.verifyAddressTimeout = setTimeout(this._verifyExternalAddresses, this.refreshInterval)
 
       return
@@ -436,7 +436,7 @@ class DefaultAutoNATService implements Startable {
 
       const verifyAddress = async (peer: PeerInfo): Promise<Message.DialResponse | undefined> => {
         try {
-          log('Asking %p to verify multiaddr', peer.id)
+          log('asking %p to verify multiaddr', peer.id)
 
           const connection = await self.components.connectionManager.openConnection(peer.id, {
             signal
@@ -452,16 +452,16 @@ 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)
+            log('no response received from %p', connection.remotePeer)
             return undefined
           }
           const response = Message.decode(buf)
 
           if (response.type !== Message.MessageType.DIAL_RESPONSE || response.dialResponse == null) {
-            log('Invalid autonat response from %s', connection.remotePeer)
+            log('invalid autonat response from %p', connection.remotePeer)
             return undefined
           }
 
@@ -477,12 +477,12 @@ class DefaultAutoNATService implements Startable {
               const octets = options.host.split(':')
               segment = octets[0]
             } else {
-              log('Remote address "%s" was not IP4 or IP6?', options.host)
+              log('remote address "%s" was not IP4 or IP6?', options.host)
               return undefined
             }
 
             if (networkSegments.includes(segment)) {
-              log('Already have response from network segment %d - %s', segment, options.host)
+              log('already have response from network segment %d - %s', segment, options.host)
               return undefined
             }
 
@@ -491,13 +491,13 @@ class DefaultAutoNATService implements Startable {
 
           return response.dialResponse
         } catch (err) {
-          log.error(err)
+          log.error('error asking remote to verify multiaddr', err)
         }
       }
 
       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 {
@@ -508,7 +508,7 @@ class DefaultAutoNATService implements Startable {
           // they either told us which address worked/didn't work, or we only sent them one address
           const addr = dialResponse.addr == null ? multiaddrs[0] : multiaddr(dialResponse.addr)
 
-          log('Autonat response for %s is %s', addr, dialResponse.status)
+          log('autonat response for %s is %s', addr, dialResponse.status)
 
           if (dialResponse.status === Message.ResponseStatus.E_BAD_REQUEST) {
             // the remote could not parse our request
@@ -526,7 +526,7 @@ class DefaultAutoNATService implements Startable {
           }
 
           if (!multiaddrs.some(ma => ma.equals(addr))) {
-            log('Peer reported %s as %s but it was not in our observed address list', addr, dialResponse.status)
+            log('peer reported %s as %s but it was not in our observed address list', addr, dialResponse.status)
             continue
           }
 
@@ -556,7 +556,7 @@ class DefaultAutoNATService implements Startable {
             return
           }
         } catch (err) {
-          log.error('Could not verify external address', err)
+          log.error('could not verify external address', err)
         }
       }
     } finally {
@@ -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
@@ -188,8 +183,10 @@ class CircuitRelayTransport implements Transport {
       disconnectOnFailure = true
     }
 
+    let stream: Stream | undefined
+
     try {
-      const stream = await relayConnection.newStream([RELAY_V2_HOP_CODEC])
+      stream = await relayConnection.newStream([RELAY_V2_HOP_CODEC])
 
       return await this.connectV2({
         stream,
@@ -202,6 +199,11 @@ class CircuitRelayTransport implements Transport {
       })
     } catch (err: any) {
       log.error(`Circuit relay dial to destination ${destinationPeer.toString()} via relay ${relayPeer.toString()} failed`, err)
+
+      if (stream != null) {
+        stream.abort(err)
+      }
+
       disconnectOnFailure && await relayConnection.close()
       throw err
     }

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