libp2p 2.10.0-8484de8a2 → 2.10.0-87bc8d4fb

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

@@ -1,9 +1,10 @@
-import { getNetConfig, isNetworkAddress, isPrivateIp, trackedMap } from '@libp2p/utils'
-import { CODE_SNI, CODE_TLS, multiaddr } from '@multiformats/multiaddr'
+import { isPrivateIp } from '@libp2p/utils/private-ip'
+import { trackedMap } from '@libp2p/utils/tracked-map'
+import { multiaddr, protocols } 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 } from '@multiformats/multiaddr'
+import type { Multiaddr, StringTuple } from '@multiformats/multiaddr'
 
 const MAX_DATE = 8_640_000_000_000_000
 
@@ -18,6 +19,13 @@ 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>
@@ -31,12 +39,7 @@ export class DNSMappings {
   }
 
   has (ma: Multiaddr): boolean {
-    const config = getNetConfig(ma)
-    let host = config.host
-
-    if ((config.type === 'ip4' || config.type === 'ip6') && config.sni != null) {
-      host = config.sni
-    }
+    const host = this.findHost(ma)
 
     for (const mapping of this.mappings.values()) {
       if (mapping.domain === host) {
@@ -64,16 +67,11 @@ export class DNSMappings {
   }
 
   remove (ma: Multiaddr): boolean {
-    const config = getNetConfig(ma)
-
-    if (config.type !== 'ip4' && config.type !== 'ip6') {
-      return false
-    }
-
+    const host = this.findHost(ma)
     let wasConfident = false
 
     for (const [ip, mapping] of this.mappings.entries()) {
-      if (mapping.domain === config.sni) {
+      if (mapping.domain === host) {
         this.log('removing %s to %s DNS mapping %e', ip, mapping.domain)
         this.mappings.delete(ip)
         wasConfident = wasConfident || mapping.verified
@@ -87,30 +85,37 @@ export class DNSMappings {
     const dnsMappedAddresses: NodeAddress[] = []
 
     for (let i = 0; i < addresses.length; i++) {
-      const address = addresses[i].multiaddr
+      const address = addresses[i]
+      const tuples = address.multiaddr.stringTuples()
+      const host = tuples[0][1]
 
-      if (!isNetworkAddress(address)) {
+      if (host == null) {
         continue
       }
 
-      const config = getNetConfig(address)
-
       for (const [ip, mapping] of this.mappings.entries()) {
-        if (config.host !== ip) {
+        if (host !== ip) {
           continue
         }
 
         // insert SNI tuple after TLS tuple, if one is present
-        const maWithSni = this.maybeAddSNIComponent(address, mapping.domain)
+        const mappedIp = this.maybeAddSNITuple(tuples, mapping.domain)
 
-        if (maWithSni != null) {
+        if (mappedIp) {
           // remove the address and replace it with the version that includes
           // the SNI tuple
           addresses.splice(i, 1)
           i--
 
           dnsMappedAddresses.push({
-            multiaddr: maWithSni,
+            multiaddr: multiaddr(`/${
+              tuples.map(tuple => {
+                return [
+                  protocols(tuple[0]).name,
+                  tuple[1]
+                ].join('/')
+              }).join('/')
+            }`),
             verified: mapping.verified,
             type: 'dns-mapping',
             expires: mapping.expires,
@@ -123,30 +128,19 @@ export class DNSMappings {
     return dnsMappedAddresses
   }
 
-  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)
+  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
       }
     }
+
+    return false
   }
 
   confirm (ma: Multiaddr, ttl: number): boolean {
-    const config = getNetConfig(ma)
-    let host = config.host
-
-    if ((config.type === 'ip4' || config.type === 'ip6') && config.sni != null) {
-      host = config.sni
-    }
-
+    const host = this.findHost(ma)
     let startingConfidence = false
 
     for (const [ip, mapping] of this.mappings.entries()) {
@@ -163,13 +157,7 @@ export class DNSMappings {
   }
 
   unconfirm (ma: Multiaddr, ttl: number): boolean {
-    const config = getNetConfig(ma)
-
-    if (config.type !== 'ip4' && config.type !== 'ip6') {
-      return false
-    }
-
-    const host = config.sni ?? config.host
+    const host = this.findHost(ma)
     let wasConfident = false
 
     for (const [ip, mapping] of this.mappings.entries()) {
@@ -183,4 +171,16 @@ 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,10 @@
 /* eslint-disable complexity */
 import { isIPv4 } from '@chainsafe/is-ip'
 import { peerIdFromString } from '@libp2p/peer-id'
-import { debounce, createScalableCuckooFilter, isPrivateIp, getNetConfig, isNetworkAddress, isLoopback } from '@libp2p/utils'
-import { CODE_P2P, multiaddr } from '@multiformats/multiaddr'
+import { debounce } from '@libp2p/utils/debounce'
+import { createScalableCuckooFilter } from '@libp2p/utils/filters'
+import { isPrivateIp } from '@libp2p/utils/private-ip'
+import { 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'
@@ -10,7 +12,7 @@ import { ObservedAddresses } from './observed-addresses.js'
 import { TransportAddresses } from './transport-addresses.js'
 import type { ComponentLogger, Libp2pEvents, Logger, PeerId, PeerStore, Metrics } from '@libp2p/interface'
 import type { AddressManager as AddressManagerInterface, TransportManager, NodeAddress, ConfirmAddressOptions } from '@libp2p/interface-internal'
-import type { Filter } from '@libp2p/utils'
+import type { Filter } from '@libp2p/utils/filters'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
 
@@ -99,7 +101,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.getComponents().findLast(c => c.code === CODE_P2P)?.value
+  const observedPeerIdStr = ma.getPeerId()
 
   // strip our peer id if it has been passed
   if (observedPeerIdStr != null) {
@@ -175,7 +177,7 @@ export class AddressManager implements AddressManagerInterface {
     const addrs = this.getAddresses()
       .map(ma => {
         // strip our peer id if it is present
-        if (ma.getComponents().findLast(c => c.code === CODE_P2P)?.value === this.components.peerId.toString()) {
+        if (ma.getPeerId() === this.components.peerId.toString()) {
           return ma.decapsulate(`/p2p/${this.components.peerId.toString()}`)
         }
 
@@ -222,22 +224,8 @@ export class AddressManager implements AddressManagerInterface {
    * Add peer observed addresses
    */
   addObservedAddr (addr: Multiaddr): void {
-    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
-      }
-    }
+    const tuples = addr.stringTuples()
+    const socketAddress = `${tuples[0][1]}:${tuples[1][1]}`
 
     // ignore if this address if it's been observed before
     if (this.observedAddressFilter.has(socketAddress)) {
@@ -489,14 +477,10 @@ export class AddressManager implements AddressManagerInterface {
       return false
     }
 
-    if (!isNetworkAddress(ma)) {
-      return false
-    }
-
-    const config = getNetConfig(ma)
+    const maOptions = ma.toOptions()
 
     // only public IPv4 addresses
-    if (config.type !== 'ip4' || isPrivateIp(config.host) === true) {
+    if (maOptions.family === 6 || maOptions.host === '127.0.0.1' || isPrivateIp(maOptions.host) === true) {
       return false
     }
 
@@ -518,7 +502,7 @@ export class AddressManager implements AddressManagerInterface {
       const transportListeners = listeners.filter(listener => {
         return listener.getAddrs().filter(ma => {
           // only IPv4 addresses of the matcher type
-          return getNetConfig(ma).type === 'ip4' && matcher(ma)
+          return ma.toOptions().family === 4 && matcher(ma)
         }).length > 0
       })
 
@@ -532,27 +516,23 @@ 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 !isLoopback(ma)
+        return ma.toOptions().host !== '127.0.0.1'
       }).pop()
 
       if (linkLocalAddr == null) {
         continue
       }
 
-      const linkLocalOptions = getNetConfig(linkLocalAddr)
-
-      if (linkLocalOptions.port == null) {
-        return false
-      }
+      const linkLocalOptions = linkLocalAddr.toOptions()
 
       // upgrade observed address to IP mapping
       this.observed.remove(ma)
       this.ipMappings.add(
         linkLocalOptions.host,
         linkLocalOptions.port,
-        config.host,
-        config.port,
-        config.protocol
+        maOptions.host,
+        maOptions.port,
+        maOptions.transport
       )
 
       return true

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

@@ -1,6 +1,6 @@
 import { isIPv4 } from '@chainsafe/is-ip'
-import { getNetConfig, isNetworkAddress, trackedMap } from '@libp2p/utils'
-import { CODE_IP4, CODE_IP6, multiaddr } from '@multiformats/multiaddr'
+import { trackedMap } from '@libp2p/utils/tracked-map'
+import { multiaddr, protocols } from '@multiformats/multiaddr'
 import type { AddressManagerComponents, AddressManagerInit } from './index.js'
 import type { Logger } from '@libp2p/interface'
 import type { NodeAddress } from '@libp2p/interface-internal'
@@ -22,6 +22,11 @@ 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[]>
@@ -35,15 +40,11 @@ export class IPMappings {
   }
 
   has (ma: Multiaddr): boolean {
-    const config = getNetConfig(ma)
-
-    if (config.type !== 'ip4' && config.type !== 'ip6') {
-      return false
-    }
+    const tuples = ma.stringTuples()
 
     for (const mappings of this.mappings.values()) {
       for (const mapping of mappings) {
-        if (mapping.externalIp === config.host) {
+        if (mapping.externalIp === tuples[0][1]) {
           return true
         }
       }
@@ -71,20 +72,18 @@ export class IPMappings {
   }
 
   remove (ma: Multiaddr): boolean {
-    const config = getNetConfig(ma)
-
-    if (config.type !== 'ip4' && config.type !== 'ip6') {
-      return false
-    }
-
+    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')
     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 === 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)
+        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)
 
           wasConfident = wasConfident || mapping.verified
           mappings.splice(i, 1)
@@ -104,38 +103,40 @@ export class IPMappings {
     const ipMappedAddresses: NodeAddress[] = []
 
     for (const { multiaddr: ma } of addresses) {
-      if (!isNetworkAddress(ma)) {
-        continue
-      }
-
-      const config = getNetConfig(ma)
-
-      if (config.type !== 'ip4' && config.type !== 'ip6') {
-        continue
-      }
-
-      let key: string | undefined
+      const tuples = ma.stringTuples()
+      let tuple: string | undefined
 
       // see if the internal host/port/protocol tuple has been mapped externally
-      if (config.protocol === 'tcp') {
-        key = `${config.host}-${config.port}-tcp`
-      } else if (config.protocol === 'udp') {
-        key = `${config.host}-${config.port}-udp`
+      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 (key == null) {
+      if (tuple == null) {
         continue
       }
 
-      const mappings = this.mappings.get(key)
+      const mappings = this.mappings.get(tuple)
 
       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: this.maybeOverrideIp(ma, mapping.externalIp, mapping.externalFamily, mapping.protocol, mapping.externalPort),
+          multiaddr: multiaddr(`/${
+            tuples.map(tuple => {
+              return [
+                protocols(tuple[0]).name,
+                tuple[1]
+              ].join('/')
+            }).join('/')
+          }`),
           verified: mapping.verified,
           type: 'ip-mapping',
           expires: mapping.expires,
@@ -147,34 +148,14 @@ 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 {
-    if (!isNetworkAddress(ma)) {
-      return false
-    }
-
-    const config = getNetConfig(ma)
+    const tuples = ma.stringTuples()
+    const host = tuples[0][1]
     let startingConfidence = false
 
     for (const mappings of this.mappings.values()) {
       for (const mapping of mappings) {
-        if (mapping.externalIp === config.host) {
+        if (mapping.externalIp === host) {
           this.log('marking %s to %s IP mapping as verified', mapping.internalIp, mapping.externalIp)
           startingConfidence = mapping.verified
           mapping.verified = true
@@ -188,19 +169,18 @@ export class IPMappings {
   }
 
   unconfirm (ma: Multiaddr, ttl: number): boolean {
-    if (!isNetworkAddress(ma)) {
-      return false
-    }
-
-    const config = getNetConfig(ma)
+    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')
     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 === 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)
+        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)
 
           wasConfident = wasConfident || mapping.verified
           mapping.verified = false

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

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

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

@@ -1,8 +1,11 @@
-import { isPrivate } from '@libp2p/utils'
+import { isPrivateIp } from '@libp2p/utils/private-ip'
 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.
@@ -18,11 +21,17 @@ export function connectionGater (gater: ConnectionGater = {}): ConnectionGater {
     denyDialMultiaddr: async (multiaddr: Multiaddr) => {
       // do not connect to insecure websockets by default
       if (WebSockets.matches(multiaddr)) {
-        return true
+        return false
       }
 
+      const tuples = multiaddr.stringTuples()
+
       // do not connect to private addresses by default
-      return isPrivate(multiaddr)
+      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,

package/src/config.ts

@@ -1,5 +1,5 @@
 import { FaultTolerance, InvalidParametersError } from '@libp2p/interface'
-import { mergeOptions } from '@libp2p/utils'
+import { mergeOptions } from '@libp2p/utils/merge-options'
 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,4 +1,5 @@
-import { isLoopback, isPrivate } from '@libp2p/utils'
+import { isLoopback } from '@libp2p/utils/multiaddr/is-loopback'
+import { isPrivate } from '@libp2p/utils/multiaddr/is-private'
 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 { getNetConfig, isNetworkAddress } from '@libp2p/utils'
-import { multiaddrToIpNet, safelyCloseConnectionIfUnused } from './utils.js'
+import { safelyCloseConnectionIfUnused } from '@libp2p/utils/close'
+import { multiaddrToIpNet } 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,12 +103,7 @@ 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) => {
-        if (isNetworkAddress(connection.remoteAddr)) {
-          const config = getNetConfig(connection.remoteAddr)
-          return ipNet.contains(config.host)
-        }
-
-        return true
+        return ipNet.contains(connection.remoteAddr.nodeAddress().address)
       })
 
       // Connections in the allow list should be excluded from pruning

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

@@ -3,11 +3,6 @@
  */
 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
  */