libp2p 2.10.0 → 3.0.0-049bfa0fa

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p",
-  "version": "2.10.0",
+  "version": "3.0.0-049bfa0fa",
   "description": "JavaScript implementation of libp2p, a modular peer to peer network stack",
   "license": "Apache-2.0 OR MIT",
   "homepage": "https://github.com/libp2p/js-libp2p/tree/main/packages/libp2p#readme",
@@ -80,47 +80,44 @@
   "dependencies": {
     "@chainsafe/is-ip": "^2.1.0",
     "@chainsafe/netmask": "^2.0.0",
-    "@libp2p/crypto": "^5.1.8",
-    "@libp2p/interface": "^2.11.0",
-    "@libp2p/interface-internal": "^2.3.19",
-    "@libp2p/logger": "^5.2.0",
-    "@libp2p/multistream-select": "^6.0.29",
-    "@libp2p/peer-collections": "^6.0.35",
-    "@libp2p/peer-id": "^5.1.9",
-    "@libp2p/peer-store": "^11.2.7",
-    "@libp2p/utils": "^6.7.2",
+    "@libp2p/crypto": "5.1.9-049bfa0fa",
+    "@libp2p/interface": "3.0.0-049bfa0fa",
+    "@libp2p/interface-internal": "3.0.0-049bfa0fa",
+    "@libp2p/logger": "6.0.0-049bfa0fa",
+    "@libp2p/multistream-select": "7.0.0-049bfa0fa",
+    "@libp2p/peer-collections": "7.0.0-049bfa0fa",
+    "@libp2p/peer-id": "6.0.0-049bfa0fa",
+    "@libp2p/peer-store": "12.0.0-049bfa0fa",
+    "@libp2p/utils": "7.0.0-049bfa0fa",
     "@multiformats/dns": "^1.0.6",
-    "@multiformats/multiaddr": "^12.4.4",
-    "@multiformats/multiaddr-matcher": "^2.0.0",
+    "@multiformats/multiaddr": "^13.0.1",
+    "@multiformats/multiaddr-matcher": "^3.0.1",
     "any-signal": "^4.1.1",
-    "datastore-core": "^10.0.2",
-    "interface-datastore": "^8.3.1",
-    "it-byte-stream": "^2.0.2",
-    "it-merge": "^3.0.11",
-    "it-parallel": "^3.0.11",
+    "datastore-core": "^10.0.4",
+    "interface-datastore": "^8.3.2",
+    "it-merge": "^3.0.12",
+    "it-parallel": "^3.0.13",
     "main-event": "^1.0.1",
-    "multiformats": "^13.3.6",
+    "multiformats": "^13.4.0",
     "p-defer": "^4.0.1",
-    "p-retry": "^6.2.1",
+    "p-event": "^6.0.1",
+    "p-retry": "^7.0.0",
     "progress-events": "^1.0.1",
-    "race-event": "^1.3.0",
-    "race-signal": "^1.1.3",
+    "race-signal": "^2.0.0",
     "uint8arrays": "^5.1.0"
   },
   "devDependencies": {
-    "aegir": "^47.0.14",
+    "aegir": "^47.0.22",
     "delay": "^6.0.0",
-    "it-all": "^3.0.8",
-    "it-drain": "^3.0.9",
+    "it-all": "^3.0.9",
+    "it-drain": "^3.0.10",
     "it-length-prefixed": "^10.0.1",
-    "it-map": "^3.1.3",
-    "it-pair": "^2.0.6",
-    "it-pipe": "^3.0.1",
-    "it-take": "^3.0.8",
-    "p-event": "^6.0.1",
+    "it-map": "^3.1.4",
+    "it-take": "^3.0.9",
     "p-wait-for": "^5.0.2",
-    "sinon": "^20.0.0",
+    "sinon": "^21.0.0",
     "sinon-ts": "^2.0.0",
+    "uint8arraylist": "^2.4.8",
     "wherearewe": "^2.0.1"
   },
   "browser": {

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

@@ -1,10 +1,9 @@
-import { isPrivateIp } from '@libp2p/utils/private-ip'
-import { trackedMap } from '@libp2p/utils/tracked-map'
-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
 
@@ -19,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>
@@ -39,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) {
@@ -67,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
@@ -85,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,
@@ -128,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()) {
@@ -157,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()) {
@@ -171,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,10 +1,8 @@
 /* eslint-disable complexity */
 import { isIPv4 } from '@chainsafe/is-ip'
 import { peerIdFromString } from '@libp2p/peer-id'
-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 { 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'
@@ -12,7 +10,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/filters'
+import type { Filter } from '@libp2p/utils'
 import type { Multiaddr } from '@multiformats/multiaddr'
 import type { TypedEventTarget } from 'main-event'
 
@@ -101,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) {
@@ -177,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()}`)
         }
 
@@ -224,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)) {
@@ -477,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
     }
 
@@ -502,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
       })
 
@@ -516,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/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
 }