libp2p 2.10.0-a02cb0461 → 2.10.0-e8398d97e

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

@@ -1,9 +1,9 @@
-import { isPrivateIp, trackedMap } from '@libp2p/utils'
-import { multiaddr, protocols } from '@multiformats/multiaddr'
+import { getNetConfig, isNetworkAddress, isPrivateIp, trackedMap } from '@libp2p/utils'
+import { CODE_SNI, CODE_TLS, multiaddr } from '@multiformats/multiaddr'
 import type { AddressManagerComponents, AddressManagerInit } from './index.js'
 import type { Logger } from '@libp2p/interface'
 import type { NodeAddress } from '@libp2p/interface-internal'
-import type { Multiaddr, StringTuple } from '@multiformats/multiaddr'
+import type { Multiaddr } from '@multiformats/multiaddr'
 
 const MAX_DATE = 8_640_000_000_000_000
 
@@ -18,13 +18,6 @@ interface DNSMapping {
   lastVerified?: number
 }
 
-const CODEC_TLS = 0x01c0
-const CODEC_SNI = 0x01c1
-const CODEC_DNS = 0x35
-const CODEC_DNS4 = 0x36
-const CODEC_DNS6 = 0x37
-const CODEC_DNSADDR = 0x38
-
 export class DNSMappings {
   private readonly log: Logger
   private readonly mappings: Map<string, DNSMapping>
@@ -38,7 +31,12 @@ export class DNSMappings {
   }
 
   has (ma: Multiaddr): boolean {
-    const host = this.findHost(ma)
+    const config = getNetConfig(ma)
+    let host = config.host
+
+    if ((config.type === 'ip4' || config.type === 'ip6') && config.sni != null) {
+      host = config.sni
+    }
 
     for (const mapping of this.mappings.values()) {
       if (mapping.domain === host) {
@@ -66,11 +64,16 @@ export class DNSMappings {
   }
 
   remove (ma: Multiaddr): boolean {
-    const host = this.findHost(ma)
+    const config = getNetConfig(ma)
+
+    if (config.type !== 'ip4' && config.type !== 'ip6') {
+      return false
+    }
+
     let wasConfident = false
 
     for (const [ip, mapping] of this.mappings.entries()) {
-      if (mapping.domain === host) {
+      if (mapping.domain === config.sni) {
         this.log('removing %s to %s DNS mapping %e', ip, mapping.domain)
         this.mappings.delete(ip)
         wasConfident = wasConfident || mapping.verified
@@ -84,37 +87,30 @@ export class DNSMappings {
     const dnsMappedAddresses: NodeAddress[] = []
 
     for (let i = 0; i < addresses.length; i++) {
-      const address = addresses[i]
-      const tuples = address.multiaddr.stringTuples()
-      const host = tuples[0][1]
+      const address = addresses[i].multiaddr
 
-      if (host == null) {
+      if (!isNetworkAddress(address)) {
         continue
       }
 
+      const config = getNetConfig(address)
+
       for (const [ip, mapping] of this.mappings.entries()) {
-        if (host !== ip) {
+        if (config.host !== ip) {
           continue
         }
 
         // insert SNI tuple after TLS tuple, if one is present
-        const mappedIp = this.maybeAddSNITuple(tuples, mapping.domain)
+        const maWithSni = this.maybeAddSNIComponent(address, mapping.domain)
 
-        if (mappedIp) {
+        if (maWithSni != null) {
           // remove the address and replace it with the version that includes
           // the SNI tuple
           addresses.splice(i, 1)
           i--
 
           dnsMappedAddresses.push({
-            multiaddr: multiaddr(`/${
-              tuples.map(tuple => {
-                return [
-                  protocols(tuple[0]).name,
-                  tuple[1]
-                ].join('/')
-              }).join('/')
-            }`),
+            multiaddr: maWithSni,
             verified: mapping.verified,
             type: 'dns-mapping',
             expires: mapping.expires,
@@ -127,19 +123,30 @@ export class DNSMappings {
     return dnsMappedAddresses
   }
 
-  private maybeAddSNITuple (tuples: StringTuple[], domain: string): boolean {
-    for (let j = 0; j < tuples.length; j++) {
-      if (tuples[j][0] === CODEC_TLS && tuples[j + 1]?.[0] !== CODEC_SNI) {
-        tuples.splice(j + 1, 0, [CODEC_SNI, domain])
-        return true
+  private maybeAddSNIComponent (ma: Multiaddr, domain: string): Multiaddr | undefined {
+    const components = ma.getComponents()
+
+    for (let j = 0; j < components.length; j++) {
+      if (components[j].code === CODE_TLS && components[j + 1]?.code !== CODE_SNI) {
+        components.splice(j + 1, 0, {
+          name: 'sni',
+          code: CODE_SNI,
+          value: domain
+        })
+
+        return multiaddr(components)
       }
     }
-
-    return false
   }
 
   confirm (ma: Multiaddr, ttl: number): boolean {
-    const host = this.findHost(ma)
+    const config = getNetConfig(ma)
+    let host = config.host
+
+    if ((config.type === 'ip4' || config.type === 'ip6') && config.sni != null) {
+      host = config.sni
+    }
+
     let startingConfidence = false
 
     for (const [ip, mapping] of this.mappings.entries()) {
@@ -156,7 +163,13 @@ export class DNSMappings {
   }
 
   unconfirm (ma: Multiaddr, ttl: number): boolean {
-    const host = this.findHost(ma)
+    const config = getNetConfig(ma)
+
+    if (config.type !== 'ip4' && config.type !== 'ip6') {
+      return false
+    }
+
+    const host = config.sni ?? config.host
     let wasConfident = false
 
     for (const [ip, mapping] of this.mappings.entries()) {
@@ -170,16 +183,4 @@ export class DNSMappings {
 
     return wasConfident
   }
-
-  private findHost (ma: Multiaddr): string | undefined {
-    for (const tuple of ma.stringTuples()) {
-      if (tuple[0] === CODEC_SNI) {
-        return tuple[1]
-      }
-
-      if (tuple[0] === CODEC_DNS || tuple[0] === CODEC_DNS4 || tuple[0] === CODEC_DNS6 || tuple[0] === CODEC_DNSADDR) {
-        return tuple[1]
-      }
-    }
-  }
 }

package/src/address-manager/index.ts

@@ -1,8 +1,8 @@
 /* eslint-disable complexity */
 import { isIPv4 } from '@chainsafe/is-ip'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { debounce, createScalableCuckooFilter, isPrivateIp } from '@libp2p/utils'
-import { multiaddr } from '@multiformats/multiaddr'
+import { debounce, createScalableCuckooFilter, isPrivateIp, getNetConfig, isNetworkAddress, isLoopback } from '@libp2p/utils'
+import { CODE_P2P, multiaddr } from '@multiformats/multiaddr'
 import { QUIC_V1, TCP, WebSockets, WebSocketsSecure } from '@multiformats/multiaddr-matcher'
 import { DNSMappings } from './dns-mappings.js'
 import { IPMappings } from './ip-mappings.js'
@@ -99,7 +99,7 @@ const defaultAddressFilter = (addrs: Multiaddr[]): Multiaddr[] => addrs
  * If the passed multiaddr contains the passed peer id, remove it
  */
 function stripPeerId (ma: Multiaddr, peerId: PeerId): Multiaddr {
-  const observedPeerIdStr = ma.getPeerId()
+  const observedPeerIdStr = ma.getComponents().findLast(c => c.code === CODE_P2P)?.value
 
   // strip our peer id if it has been passed
   if (observedPeerIdStr != null) {
@@ -175,7 +175,7 @@ export class AddressManager implements AddressManagerInterface {
     const addrs = this.getAddresses()
       .map(ma => {
         // strip our peer id if it is present
-        if (ma.getPeerId() === this.components.peerId.toString()) {
+        if (ma.getComponents().findLast(c => c.code === CODE_P2P)?.value === this.components.peerId.toString()) {
           return ma.decapsulate(`/p2p/${this.components.peerId.toString()}`)
         }
 
@@ -222,8 +222,22 @@ export class AddressManager implements AddressManagerInterface {
    * Add peer observed addresses
    */
   addObservedAddr (addr: Multiaddr): void {
-    const tuples = addr.stringTuples()
-    const socketAddress = `${tuples[0][1]}:${tuples[1][1]}`
+    const config = getNetConfig(addr)
+    let socketAddress: string
+
+    switch (config.type) {
+      case 'ip4': {
+        socketAddress = `${config.host}:${config.port}`
+        break
+      }
+      case 'ip6': {
+        socketAddress = `[${config.host}]:${config.port}`
+        break
+      }
+      default: {
+        return
+      }
+    }
 
     // ignore if this address if it's been observed before
     if (this.observedAddressFilter.has(socketAddress)) {
@@ -475,10 +489,14 @@ export class AddressManager implements AddressManagerInterface {
       return false
     }
 
-    const maOptions = ma.toOptions()
+    if (!isNetworkAddress(ma)) {
+      return false
+    }
+
+    const config = getNetConfig(ma)
 
     // only public IPv4 addresses
-    if (maOptions.family === 6 || maOptions.host === '127.0.0.1' || isPrivateIp(maOptions.host) === true) {
+    if (config.type !== 'ip4' || isPrivateIp(config.host) === true) {
       return false
     }
 
@@ -500,7 +518,7 @@ export class AddressManager implements AddressManagerInterface {
       const transportListeners = listeners.filter(listener => {
         return listener.getAddrs().filter(ma => {
           // only IPv4 addresses of the matcher type
-          return ma.toOptions().family === 4 && matcher(ma)
+          return getNetConfig(ma).type === 'ip4' && matcher(ma)
         }).length > 0
       })
 
@@ -514,23 +532,27 @@ export class AddressManager implements AddressManagerInterface {
       // we have one listener which listens on one port so whatever the external
       // NAT port mapping is, it should be for this listener
       const linkLocalAddr = transportListeners[0].getAddrs().filter(ma => {
-        return ma.toOptions().host !== '127.0.0.1'
+        return !isLoopback(ma)
       }).pop()
 
       if (linkLocalAddr == null) {
         continue
       }
 
-      const linkLocalOptions = linkLocalAddr.toOptions()
+      const linkLocalOptions = getNetConfig(linkLocalAddr)
+
+      if (linkLocalOptions.port == null) {
+        return false
+      }
 
       // upgrade observed address to IP mapping
       this.observed.remove(ma)
       this.ipMappings.add(
         linkLocalOptions.host,
         linkLocalOptions.port,
-        maOptions.host,
-        maOptions.port,
-        maOptions.transport
+        config.host,
+        config.port,
+        config.protocol
       )
 
       return true

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

@@ -1,6 +1,6 @@
 import { isIPv4 } from '@chainsafe/is-ip'
-import { trackedMap } from '@libp2p/utils'
-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/transport-addresses.ts

@@ -1,4 +1,4 @@
-import { isNetworkAddress, isPrivate, trackedMap } from '@libp2p/utils'
+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'
@@ -112,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'
+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.
@@ -16,30 +13,17 @@ const CODEC_IP6 = 0x29
  * confusion.
  */
 export function connectionGater (gater: ConnectionGater = {}): ConnectionGater {
-  return {
-    denyDialPeer: async () => false,
-    denyDialMultiaddr: async (multiaddr: Multiaddr) => {
+  if (gater.denyDialMultiaddr == null) {
+    gater.denyDialMultiaddr = (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
-    },
-    denyInboundConnection: async () => false,
-    denyOutboundConnection: async () => false,
-    denyInboundEncryptedConnection: async () => false,
-    denyOutboundEncryptedConnection: async () => false,
-    denyInboundUpgradedConnection: async () => false,
-    denyOutboundUpgradedConnection: async () => false,
-    filterMultiaddrForPeer: async () => true,
-    ...gater
+      return isPrivate(multiaddr)
+    }
   }
+
+  return gater
 }

package/src/config/connection-gater.ts

@@ -4,16 +4,5 @@ import type { ConnectionGater } from '@libp2p/interface'
  * Returns a default connection gater implementation that allows everything
  */
 export function connectionGater (gater: ConnectionGater = {}): ConnectionGater {
-  return {
-    denyDialPeer: async () => false,
-    denyDialMultiaddr: async () => false,
-    denyInboundConnection: async () => false,
-    denyOutboundConnection: async () => false,
-    denyInboundEncryptedConnection: async () => false,
-    denyOutboundEncryptedConnection: async () => false,
-    denyInboundUpgradedConnection: async () => false,
-    denyOutboundUpgradedConnection: async () => false,
-    filterMultiaddrForPeer: async () => true,
-    ...gater
-  }
+  return gater
 }

package/src/config.ts

@@ -1,33 +1,11 @@
-import { FaultTolerance, InvalidParametersError } from '@libp2p/interface'
-import { mergeOptions } from '@libp2p/utils'
-import { dnsaddrResolver } from './connection-manager/resolvers/dnsaddr.ts'
+import { InvalidParametersError } from '@libp2p/interface'
 import type { Libp2pInit } from './index.js'
 import type { ServiceMap } from '@libp2p/interface'
-import type { Multiaddr } from '@multiformats/multiaddr'
-
-const DefaultConfig: Libp2pInit = {
-  addresses: {
-    listen: [],
-    announce: [],
-    noAnnounce: [],
-    announceFilter: (multiaddrs: Multiaddr[]) => multiaddrs
-  },
-  connectionManager: {
-    resolvers: {
-      dnsaddr: dnsaddrResolver
-    }
-  },
-  transportManager: {
-    faultTolerance: FaultTolerance.FATAL_ALL
-  }
-}
 
 export async function validateConfig <T extends ServiceMap = Record<string, unknown>> (opts: Libp2pInit<T>): Promise<Libp2pInit<T>> {
-  const resultingOptions: Libp2pInit<T> = mergeOptions(DefaultConfig, opts)
-
-  if (resultingOptions.connectionProtector === null && globalThis.process?.env?.LIBP2P_FORCE_PNET != null) {
+  if (opts.connectionProtector === null && globalThis.process?.env?.LIBP2P_FORCE_PNET != null) {
     throw new InvalidParametersError('Private network is enforced, but no protector was provided')
   }
 
-  return resultingOptions
+  return opts
 }

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

@@ -1,4 +1,5 @@
 import { PeerMap } from '@libp2p/peer-collections'
+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'
@@ -102,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/dial-queue.ts

@@ -2,7 +2,7 @@
 import { TimeoutError, DialError, AbortError } from '@libp2p/interface'
 import { PeerMap } from '@libp2p/peer-collections'
 import { PriorityQueue } from '@libp2p/utils'
-import { multiaddr } from '@multiformats/multiaddr'
+import { CODE_P2P, multiaddr } from '@multiformats/multiaddr'
 import { Circuit } from '@multiformats/multiaddr-matcher'
 import { anySignal } from 'any-signal'
 import { setMaxListeners } from 'main-event'
@@ -446,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)
       }