libp2p 2.9.0 → 2.10.0-8484de8a2

package/src/address-manager/ip-mappings.ts

@@ -1,6 +1,6 @@
 import { isIPv4 } from '@chainsafe/is-ip'
-import { trackedMap } from '@libp2p/utils/tracked-map'
-import { multiaddr, protocols } from '@multiformats/multiaddr'
+import { getNetConfig, isNetworkAddress, trackedMap } from '@libp2p/utils'
+import { CODE_IP4, CODE_IP6, multiaddr } from '@multiformats/multiaddr'
 import type { AddressManagerComponents, AddressManagerInit } from './index.js'
 import type { Logger } from '@libp2p/interface'
 import type { NodeAddress } from '@libp2p/interface-internal'
@@ -22,11 +22,6 @@ interface PublicAddressMapping {
   lastVerified?: number
 }
 
-const CODEC_IP4 = 0x04
-const CODEC_IP6 = 0x29
-const CODEC_TCP = 0x06
-const CODEC_UDP = 0x0111
-
 export class IPMappings {
   private readonly log: Logger
   private readonly mappings: Map<string, PublicAddressMapping[]>
@@ -40,11 +35,15 @@ export class IPMappings {
   }
 
   has (ma: Multiaddr): boolean {
-    const tuples = ma.stringTuples()
+    const config = getNetConfig(ma)
+
+    if (config.type !== 'ip4' && config.type !== 'ip6') {
+      return false
+    }
 
     for (const mappings of this.mappings.values()) {
       for (const mapping of mappings) {
-        if (mapping.externalIp === tuples[0][1]) {
+        if (mapping.externalIp === config.host) {
           return true
         }
       }
@@ -72,18 +71,20 @@ export class IPMappings {
   }
 
   remove (ma: Multiaddr): boolean {
-    const tuples = ma.stringTuples()
-    const host = tuples[0][1] ?? ''
-    const protocol = tuples[1][0] === CODEC_TCP ? 'tcp' : 'udp'
-    const port = parseInt(tuples[1][1] ?? '0')
+    const config = getNetConfig(ma)
+
+    if (config.type !== 'ip4' && config.type !== 'ip6') {
+      return false
+    }
+
     let wasConfident = false
 
     for (const [key, mappings] of this.mappings.entries()) {
       for (let i = 0; i < mappings.length; i++) {
         const mapping = mappings[i]
 
-        if (mapping.externalIp === host && mapping.externalPort === port && mapping.protocol === protocol) {
-          this.log('removing %s:%s to %s:%s %s IP mapping', mapping.externalIp, mapping.externalPort, host, port, protocol)
+        if (mapping.externalIp === config.host && mapping.externalPort === config.port && mapping.protocol === config.protocol) {
+          this.log('removing %s:%s to %s:%s %s IP mapping', mapping.externalIp, mapping.externalPort, config.host, config.port, config.protocol)
 
           wasConfident = wasConfident || mapping.verified
           mappings.splice(i, 1)
@@ -103,40 +104,38 @@ export class IPMappings {
     const ipMappedAddresses: NodeAddress[] = []
 
     for (const { multiaddr: ma } of addresses) {
-      const tuples = ma.stringTuples()
-      let tuple: string | undefined
+      if (!isNetworkAddress(ma)) {
+        continue
+      }
+
+      const config = getNetConfig(ma)
+
+      if (config.type !== 'ip4' && config.type !== 'ip6') {
+        continue
+      }
+
+      let key: string | undefined
 
       // see if the internal host/port/protocol tuple has been mapped externally
-      if ((tuples[0][0] === CODEC_IP4 || tuples[0][0] === CODEC_IP6) && tuples[1][0] === CODEC_TCP) {
-        tuple = `${tuples[0][1]}-${tuples[1][1]}-tcp`
-      } else if ((tuples[0][0] === CODEC_IP4 || tuples[0][0] === CODEC_IP6) && tuples[1][0] === CODEC_UDP) {
-        tuple = `${tuples[0][1]}-${tuples[1][1]}-udp`
+      if (config.protocol === 'tcp') {
+        key = `${config.host}-${config.port}-tcp`
+      } else if (config.protocol === 'udp') {
+        key = `${config.host}-${config.port}-udp`
       }
 
-      if (tuple == null) {
+      if (key == null) {
         continue
       }
 
-      const mappings = this.mappings.get(tuple)
+      const mappings = this.mappings.get(key)
 
       if (mappings == null) {
         continue
       }
 
       for (const mapping of mappings) {
-        tuples[0][0] = mapping.externalFamily === 4 ? CODEC_IP4 : CODEC_IP6
-        tuples[0][1] = mapping.externalIp
-        tuples[1][1] = `${mapping.externalPort}`
-
         ipMappedAddresses.push({
-          multiaddr: multiaddr(`/${
-            tuples.map(tuple => {
-              return [
-                protocols(tuple[0]).name,
-                tuple[1]
-              ].join('/')
-            }).join('/')
-          }`),
+          multiaddr: this.maybeOverrideIp(ma, mapping.externalIp, mapping.externalFamily, mapping.protocol, mapping.externalPort),
           verified: mapping.verified,
           type: 'ip-mapping',
           expires: mapping.expires,
@@ -148,14 +147,34 @@ export class IPMappings {
     return ipMappedAddresses
   }
 
+  private maybeOverrideIp (ma: Multiaddr, externalIp: string, externalFamily: number, protocol: 'tcp' | 'udp', externalPort: number): Multiaddr {
+    const components = ma.getComponents()
+
+    const ipIndex = components.findIndex(c => c.code === CODE_IP4 || c.code === CODE_IP6)
+    const portIndex = components.findIndex(c => c.name === protocol)
+
+    if (ipIndex > -1 && portIndex > -1) {
+      components[ipIndex].value = externalIp
+      components[ipIndex].code = externalFamily === 4 ? CODE_IP4 : CODE_IP6
+      components[portIndex].value = `${externalPort}`
+
+      return multiaddr(components)
+    }
+
+    return ma
+  }
+
   confirm (ma: Multiaddr, ttl: number): boolean {
-    const tuples = ma.stringTuples()
-    const host = tuples[0][1]
+    if (!isNetworkAddress(ma)) {
+      return false
+    }
+
+    const config = getNetConfig(ma)
     let startingConfidence = false
 
     for (const mappings of this.mappings.values()) {
       for (const mapping of mappings) {
-        if (mapping.externalIp === host) {
+        if (mapping.externalIp === config.host) {
           this.log('marking %s to %s IP mapping as verified', mapping.internalIp, mapping.externalIp)
           startingConfidence = mapping.verified
           mapping.verified = true
@@ -169,18 +188,19 @@ export class IPMappings {
   }
 
   unconfirm (ma: Multiaddr, ttl: number): boolean {
-    const tuples = ma.stringTuples()
-    const host = tuples[0][1] ?? ''
-    const protocol = tuples[1][0] === CODEC_TCP ? 'tcp' : 'udp'
-    const port = parseInt(tuples[1][1] ?? '0')
+    if (!isNetworkAddress(ma)) {
+      return false
+    }
+
+    const config = getNetConfig(ma)
     let wasConfident = false
 
     for (const mappings of this.mappings.values()) {
       for (let i = 0; i < mappings.length; i++) {
         const mapping = mappings[i]
 
-        if (mapping.externalIp === host && mapping.externalPort === port && mapping.protocol === protocol) {
-          this.log('removing verification of %s:%s to %s:%s %s IP mapping', mapping.externalIp, mapping.externalPort, host, port, protocol)
+        if (mapping.externalIp === config.host && mapping.externalPort === config.port && mapping.protocol === config.protocol) {
+          this.log('removing verification of %s:%s to %s:%s %s IP mapping', mapping.externalIp, mapping.externalPort, config.host, config.port, config.protocol)
 
           wasConfident = wasConfident || mapping.verified
           mapping.verified = false

package/src/address-manager/observed-addresses.ts

@@ -1,6 +1,4 @@
-import { isLinkLocal } from '@libp2p/utils/multiaddr/is-link-local'
-import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
-import { trackedMap } from '@libp2p/utils/tracked-map'
+import { isLinkLocal, isPrivate, trackedMap } from '@libp2p/utils'
 import { multiaddr } from '@multiformats/multiaddr'
 import type { AddressManagerComponents, AddressManagerInit } from './index.js'
 import type { Logger } from '@libp2p/interface'

package/src/address-manager/transport-addresses.ts

@@ -1,6 +1,4 @@
-import { isNetworkAddress } from '@libp2p/utils/multiaddr/is-network-address'
-import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
-import { trackedMap } from '@libp2p/utils/tracked-map'
+import { getNetConfig, isNetworkAddress, isPrivate, trackedMap } from '@libp2p/utils'
 import type { AddressManagerComponents, AddressManagerInit } from './index.js'
 import type { Logger } from '@libp2p/interface'
 import type { NodeAddress } from '@libp2p/interface-internal'
@@ -114,13 +112,13 @@ export class TransportAddresses {
   }
 
   private toKey (ma: Multiaddr): string {
-    if (isNetworkAddress(ma)) {
-      // only works for dns/ip based addresses
-      const options = ma.toOptions()
-
-      return `${options.host}-${options.port}-${options.transport}`
+    if (!isNetworkAddress(ma)) {
+      return ma.toString()
     }
 
-    return ma.toString()
+    // only works for dns/ip based addresses
+    const config = getNetConfig(ma)
+
+    return `${config.host}-${config.port}-${config.protocol}`
   }
 }

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

@@ -1,11 +1,8 @@
-import { isPrivateIp } from '@libp2p/utils/private-ip'
+import { isPrivate } from '@libp2p/utils'
 import { WebSockets } from '@multiformats/multiaddr-matcher'
 import type { ConnectionGater } from '@libp2p/interface'
 import type { Multiaddr } from '@multiformats/multiaddr'
 
-const CODEC_IP4 = 0x04
-const CODEC_IP6 = 0x29
-
 /**
  * Returns a connection gater that disallows dialling private addresses or
  * insecure websockets by default.
@@ -21,17 +18,11 @@ export function connectionGater (gater: ConnectionGater = {}): ConnectionGater {
     denyDialMultiaddr: async (multiaddr: Multiaddr) => {
       // do not connect to insecure websockets by default
       if (WebSockets.matches(multiaddr)) {
-        return false
+        return true
       }
 
-      const tuples = multiaddr.stringTuples()
-
       // do not connect to private addresses by default
-      if (tuples[0][0] === CODEC_IP4 || tuples[0][0] === CODEC_IP6) {
-        return Boolean(isPrivateIp(`${tuples[0][1]}`))
-      }
-
-      return false
+      return isPrivate(multiaddr)
     },
     denyInboundConnection: async () => false,
     denyOutboundConnection: async () => false,

package/src/config.ts

@@ -1,5 +1,5 @@
 import { FaultTolerance, InvalidParametersError } from '@libp2p/interface'
-import { mergeOptions } from '@libp2p/utils/merge-options'
+import { mergeOptions } from '@libp2p/utils'
 import { dnsaddrResolver } from './connection-manager/resolvers/dnsaddr.ts'
 import type { Libp2pInit } from './index.js'
 import type { ServiceMap } from '@libp2p/interface'

package/src/connection-manager/address-sorter.ts

@@ -1,5 +1,4 @@
-import { isLoopback } from '@libp2p/utils/multiaddr/is-loopback'
-import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
+import { isLoopback, isPrivate } from '@libp2p/utils'
 import { Circuit, WebSockets, WebSocketsSecure, WebRTC, WebRTCDirect, WebTransport, TCP } from '@multiformats/multiaddr-matcher'
 import type { Address } from '@libp2p/interface'
 

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

@@ -1,6 +1,6 @@
 import { PeerMap } from '@libp2p/peer-collections'
-import { safelyCloseConnectionIfUnused } from '@libp2p/utils/close'
-import { multiaddrToIpNet } from './utils.js'
+import { getNetConfig, isNetworkAddress } from '@libp2p/utils'
+import { multiaddrToIpNet, safelyCloseConnectionIfUnused } from './utils.js'
 import type { IpNet } from '@chainsafe/netmask'
 import type { Libp2pEvents, Logger, ComponentLogger, PeerStore, Connection } from '@libp2p/interface'
 import type { ConnectionManager } from '@libp2p/interface-internal'
@@ -103,7 +103,12 @@ export class ConnectionPruner {
       this.log('too many connections open - closing a connection to %p', connection.remotePeer)
       // check allow list
       const connectionInAllowList = this.allow.some((ipNet) => {
-        return ipNet.contains(connection.remoteAddr.nodeAddress().address)
+        if (isNetworkAddress(connection.remoteAddr)) {
+          const config = getNetConfig(connection.remoteAddr)
+          return ipNet.contains(config.host)
+        }
+
+        return true
       })
 
       // Connections in the allow list should be excluded from pruning

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

@@ -3,6 +3,11 @@
  */
 export const DIAL_TIMEOUT = 10_000
 
+/**
+ * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#connectionCloseTimeout
+ */
+export const CONNECTION_CLOSE_TIMEOUT = 1_000
+
 /**
  * @see https://libp2p.github.io/js-libp2p/interfaces/index._internal_.ConnectionManagerConfig.html#inboundUpgradeTimeout
  */

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

@@ -1,8 +1,8 @@
 /* eslint-disable max-depth */
 import { TimeoutError, DialError, AbortError } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
-import { PriorityQueue } from '@libp2p/utils/priority-queue'
-import { multiaddr } from '@multiformats/multiaddr'
+import { PriorityQueue } from '@libp2p/utils'
+import { CODE_P2P, multiaddr } from '@multiformats/multiaddr'
 import { Circuit } from '@multiformats/multiaddr-matcher'
 import { anySignal } from 'any-signal'
 import { setMaxListeners } from 'main-event'
@@ -20,10 +20,11 @@ import {
   LAST_DIAL_SUCCESS_KEY
 } from './constants.js'
 import { resolveMultiaddr, dnsaddrResolver } from './resolvers/index.js'
+import { findExistingConnection } from './utils.ts'
 import { DEFAULT_DIAL_PRIORITY } from './index.js'
 import type { AddressSorter, ComponentLogger, Logger, Connection, ConnectionGater, Metrics, PeerId, Address, PeerStore, PeerRouting, IsDialableOptions, OpenConnectionProgressEvents, MultiaddrResolver } from '@libp2p/interface'
 import type { OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
-import type { PriorityQueueJobOptions } from '@libp2p/utils/priority-queue'
+import type { PriorityQueueJobOptions } from '@libp2p/utils'
 import type { DNS } from '@multiformats/dns'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { ProgressOptions } from 'progress-events'
@@ -101,9 +102,9 @@ export class DialQueue {
       metrics: components.metrics
     })
     // a started job errored
-    this.queue.addEventListener('error', (event) => {
-      if (event.detail?.name !== AbortError.name) {
-        this.log.error('error in dial queue - %e', event.detail)
+    this.queue.addEventListener('failure', (event) => {
+      if (event.detail?.error.name !== AbortError.name) {
+        this.log.error('error in dial queue - %e', event.detail.error)
       }
     })
   }
@@ -136,30 +137,14 @@ export class DialQueue {
   async dial (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], options: OpenConnectionOptions = {}): Promise<Connection> {
     const { peerId, multiaddrs } = getPeerAddress(peerIdOrMultiaddr)
 
-    // make sure we don't have an existing non-limited connection to any of the
-    // addresses we are about to dial
-    const existingConnection = Array.from(this.connections.values()).flat().find(conn => {
-      if (options.force === true) {
-        return false
-      }
-
-      if (conn.limits != null) {
-        return false
-      }
+    if (peerId != null && options.force !== true) {
+      const existingConnection = findExistingConnection(peerId, this.connections.get(peerId), multiaddrs)
 
-      if (conn.remotePeer.equals(peerId)) {
-        return true
+      if (existingConnection != null) {
+        this.log('already connected to %a', existingConnection.remoteAddr)
+        options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
+        return existingConnection
       }
-
-      return multiaddrs.find(addr => {
-        return addr.equals(conn.remoteAddr)
-      })
-    })
-
-    if (existingConnection?.status === 'open') {
-      this.log('already connected to %a', existingConnection.remoteAddr)
-      options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
-      return existingConnection
     }
 
     // ready to dial, all async work finished - make sure we don't have any
@@ -461,7 +446,7 @@ export class DialQueue {
       // if the resolved multiaddr has a PeerID but it's the wrong one, ignore it
       // - this can happen with addresses like bootstrap.libp2p.io that resolve
       // to multiple different peers
-      const addrPeerId = addr.multiaddr.getPeerId()
+      const addrPeerId = addr.multiaddr.getComponents().findLast(c => c.code === CODE_P2P)?.value
       if (peerId != null && addrPeerId != null) {
         return peerId.equals(addrPeerId)
       }

package/src/connection-manager/index.ts

@@ -1,7 +1,8 @@
 import { ConnectionClosedError, InvalidMultiaddrError, InvalidParametersError, InvalidPeerIdError, NotStartedError, start, stop } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
-import { RateLimiter } from '@libp2p/utils/rate-limiter'
+import { getNetConfig, isNetworkAddress, RateLimiter } from '@libp2p/utils'
 import { multiaddr } from '@multiformats/multiaddr'
+import { pEvent } from 'p-event'
 import { CustomProgressEvent } from 'progress-events'
 import { getPeerAddress } from '../get-peer.js'
 import { ConnectionPruner } from './connection-pruner.js'
@@ -9,11 +10,11 @@ import { DIAL_TIMEOUT, INBOUND_CONNECTION_THRESHOLD, MAX_CONNECTIONS, MAX_DIAL_Q
 import { DialQueue } from './dial-queue.js'
 import { ReconnectQueue } from './reconnect-queue.js'
 import { dnsaddrResolver } from './resolvers/index.ts'
-import { multiaddrToIpNet } from './utils.js'
+import { findExistingConnection, multiaddrToIpNet } from './utils.js'
 import type { IpNet } from '@chainsafe/netmask'
-import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions, MultiaddrResolver } from '@libp2p/interface'
+import type { PendingDial, AddressSorter, Libp2pEvents, AbortOptions, ComponentLogger, Logger, Connection, MultiaddrConnection, ConnectionGater, Metrics, PeerId, PeerStore, Startable, PendingDialStatus, PeerRouting, IsDialableOptions, MultiaddrResolver, Stream, NewStreamOptions } from '@libp2p/interface'
 import type { ConnectionManager, OpenConnectionOptions, TransportManager } from '@libp2p/interface-internal'
-import type { JobStatus } from '@libp2p/utils/queue'
+import type { JobStatus } from '@libp2p/utils'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
 
@@ -65,6 +66,14 @@ export interface ConnectionManagerInit {
    */
   dialTimeout?: number
 
+  /**
+   * How many ms to wait when closing a connection if an abort signal is not
+   * passed
+   *
+   * @default 1_000
+   */
+  connectionCloseTimeout?: number
+
   /**
    * When a new incoming connection is opened, the upgrade process (e.g.
    * protect, encrypt, multiplex etc) must complete within this number of ms.
@@ -241,8 +250,8 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     this.onDisconnect = this.onDisconnect.bind(this)
 
     // allow/deny lists
-    this.allow = (init.allow ?? []).map(str => multiaddrToIpNet(str))
-    this.deny = (init.deny ?? []).map(str => multiaddrToIpNet(str))
+    this.allow = (init.allow ?? []).map(str => multiaddrToIpNet(multiaddr(str)))
+    this.deny = (init.deny ?? []).map(str => multiaddrToIpNet(multiaddr(str)))
 
     this.incomingPendingConnections = 0
     this.maxIncomingPendingConnections = init.maxIncomingPendingConnections ?? defaultOptions.maxIncomingPendingConnections
@@ -399,16 +408,22 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     )
 
     // Close all connections we're tracking
-    const tasks: Array<Promise<void>> = []
+    const tasks: Array<Promise<any>> = []
     for (const connectionList of this.connections.values()) {
       for (const connection of connectionList) {
-        tasks.push((async () => {
-          try {
-            await connection.close()
-          } catch (err) {
-            this.log.error(err)
-          }
-        })())
+        tasks.push(
+          Promise.all([
+            pEvent(connection, 'close', {
+              signal: AbortSignal.timeout(500)
+            }),
+            connection.close({
+              signal: AbortSignal.timeout(500)
+            })
+          ])
+            .catch(err => {
+              connection.abort(err)
+            })
+        )
       }
     }
 
@@ -500,11 +515,11 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     if (filteredPeerConns.length === 0) {
       // trigger disconnect event if no connections remain
-      this.log('onDisconnect remove all connections for peer %p', peerId)
+      this.log.trace('peer %p disconnected, removing connection map entry', peerId)
       this.connections.delete(peerId)
 
       // broadcast disconnect event
-      this.events.safeDispatchEvent('peer:disconnect', { detail: connection.remotePeer })
+      this.events.safeDispatchEvent('peer:disconnect', { detail: peerId })
     }
   }
 
@@ -536,7 +551,7 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     try {
       options.signal?.throwIfAborted()
 
-      const { peerId } = getPeerAddress(peerIdOrMultiaddr)
+      const { peerId, multiaddrs } = getPeerAddress(peerIdOrMultiaddr)
 
       if (this.peerId.equals(peerId)) {
         throw new InvalidPeerIdError('Can not dial self')
@@ -544,11 +559,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.limits == null)
+        const existingConnection = findExistingConnection(peerId, this.getConnections(peerId), multiaddrs)
 
         if (existingConnection != null) {
-          this.log('had an existing non-limited connection to %p', peerId)
+          this.log('had an existing connection to %p as %a', peerId, existingConnection.remoteAddr)
 
           options.onProgress?.(new CustomProgressEvent('dial-queue:already-connected'))
           return existingConnection
@@ -600,13 +614,22 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     }
   }
 
+  async openStream (peerIdOrMultiaddr: PeerId | Multiaddr | Multiaddr[], protocol: string | string[], options: OpenConnectionOptions & NewStreamOptions = {}): Promise<Stream> {
+    const connection = await this.openConnection(peerIdOrMultiaddr, options)
+
+    return connection.newStream(protocol, options)
+  }
+
   async closeConnections (peerId: PeerId, options: AbortOptions = {}): Promise<void> {
     const connections = this.connections.get(peerId) ?? []
 
     await Promise.all(
       connections.map(async connection => {
         try {
-          await connection.close(options)
+          await Promise.all([
+            pEvent(connection, 'close', options),
+            connection.close(options)
+          ])
         } catch (err: any) {
           connection.abort(err)
         }
@@ -614,10 +637,15 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
     )
   }
 
-  async acceptIncomingConnection (maConn: MultiaddrConnection): Promise<boolean> {
+  acceptIncomingConnection (maConn: MultiaddrConnection): boolean {
     // check deny list
-    const denyConnection = this.deny.some(ma => {
-      return ma.contains(maConn.remoteAddr.nodeAddress().address)
+    const denyConnection = this.deny.some(ipNet => {
+      if (isNetworkAddress(maConn.remoteAddr)) {
+        const config = getNetConfig(maConn.remoteAddr)
+        return ipNet.contains(config.host)
+      }
+
+      return false
     })
 
     if (denyConnection) {
@@ -627,7 +655,12 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
 
     // check allow list
     const allowConnection = this.allow.some(ipNet => {
-      return ipNet.contains(maConn.remoteAddr.nodeAddress().address)
+      if (isNetworkAddress(maConn.remoteAddr)) {
+        const config = getNetConfig(maConn.remoteAddr)
+        return ipNet.contains(config.host)
+      }
+
+      return true
     })
 
     if (allowConnection) {
@@ -642,13 +675,13 @@ export class DefaultConnectionManager implements ConnectionManager, Startable {
       return false
     }
 
-    if (maConn.remoteAddr.isThinWaistAddress()) {
-      const host = maConn.remoteAddr.nodeAddress().address
+    if (isNetworkAddress(maConn.remoteAddr)) {
+      const config = getNetConfig(maConn.remoteAddr)
 
       try {
-        await this.inboundConnectionRateLimiter.consume(host, 1)
+        this.inboundConnectionRateLimiter.consume(config.host, 1)
       } catch {
-        this.log('connection from %a refused - inboundConnectionThreshold exceeded by host %s', maConn.remoteAddr, host)
+        this.log('connection from %a refused - inboundConnectionThreshold exceeded by host %s', maConn.remoteAddr, config.host)
         return false
       }
     }

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

@@ -1,5 +1,5 @@
 import { KEEP_ALIVE } from '@libp2p/interface'
-import { PeerQueue } from '@libp2p/utils/peer-queue'
+import { PeerQueue } from '@libp2p/utils'
 import pRetry from 'p-retry'
 import { MAX_PARALLEL_RECONNECTS } from './constants.js'
 import type { ComponentLogger, Libp2pEvents, Logger, Metrics, Peer, PeerId, PeerStore, Startable } from '@libp2p/interface'