libp2p 2.9.0 → 2.10.0-6059227cb

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.
@@ -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/merge-options'
-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/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)
       }